1 // Generated by the protocol buffer compiler. DO NOT EDIT!
2 // source: icing/proto/scoring.proto
3
4 #ifndef GOOGLE_PROTOBUF_INCLUDED_icing_2fproto_2fscoring_2eproto
5 #define GOOGLE_PROTOBUF_INCLUDED_icing_2fproto_2fscoring_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/generated_enum_util.h>
33 #include "icing/proto/term.pb.h"
34 // @@protoc_insertion_point(includes)
35 #include <google/protobuf/port_def.inc>
36 #define PROTOBUF_INTERNAL_EXPORT_icing_2fproto_2fscoring_2eproto
37 PROTOBUF_NAMESPACE_OPEN
38 namespace internal {
39 class AnyMetadata;
40 } // namespace internal
41 PROTOBUF_NAMESPACE_CLOSE
42
43 // Internal implementation detail -- do not use these members.
44 struct TableStruct_icing_2fproto_2fscoring_2eproto {
45 static const ::uint32_t offsets[];
46 };
47 namespace icing {
48 namespace lib {
49 class PropertyWeight;
50 struct PropertyWeightDefaultTypeInternal;
51 extern PropertyWeightDefaultTypeInternal _PropertyWeight_default_instance_;
52 class SchemaTypeAliasMapProto;
53 struct SchemaTypeAliasMapProtoDefaultTypeInternal;
54 extern SchemaTypeAliasMapProtoDefaultTypeInternal _SchemaTypeAliasMapProto_default_instance_;
55 class ScoringSpecProto;
56 struct ScoringSpecProtoDefaultTypeInternal;
57 extern ScoringSpecProtoDefaultTypeInternal _ScoringSpecProto_default_instance_;
58 class ScoringSpecProto_Order;
59 struct ScoringSpecProto_OrderDefaultTypeInternal;
60 extern ScoringSpecProto_OrderDefaultTypeInternal _ScoringSpecProto_Order_default_instance_;
61 class ScoringSpecProto_RankingStrategy;
62 struct ScoringSpecProto_RankingStrategyDefaultTypeInternal;
63 extern ScoringSpecProto_RankingStrategyDefaultTypeInternal _ScoringSpecProto_RankingStrategy_default_instance_;
64 class SuggestionScoringSpecProto;
65 struct SuggestionScoringSpecProtoDefaultTypeInternal;
66 extern SuggestionScoringSpecProtoDefaultTypeInternal _SuggestionScoringSpecProto_default_instance_;
67 class SuggestionScoringSpecProto_SuggestionRankingStrategy;
68 struct SuggestionScoringSpecProto_SuggestionRankingStrategyDefaultTypeInternal;
69 extern SuggestionScoringSpecProto_SuggestionRankingStrategyDefaultTypeInternal _SuggestionScoringSpecProto_SuggestionRankingStrategy_default_instance_;
70 class TypePropertyWeights;
71 struct TypePropertyWeightsDefaultTypeInternal;
72 extern TypePropertyWeightsDefaultTypeInternal _TypePropertyWeights_default_instance_;
73 } // namespace lib
74 } // namespace icing
75 PROTOBUF_NAMESPACE_OPEN
76 template<> ::icing::lib::PropertyWeight* Arena::CreateMaybeMessage<::icing::lib::PropertyWeight>(Arena*);
77 template<> ::icing::lib::SchemaTypeAliasMapProto* Arena::CreateMaybeMessage<::icing::lib::SchemaTypeAliasMapProto>(Arena*);
78 template<> ::icing::lib::ScoringSpecProto* Arena::CreateMaybeMessage<::icing::lib::ScoringSpecProto>(Arena*);
79 template<> ::icing::lib::ScoringSpecProto_Order* Arena::CreateMaybeMessage<::icing::lib::ScoringSpecProto_Order>(Arena*);
80 template<> ::icing::lib::ScoringSpecProto_RankingStrategy* Arena::CreateMaybeMessage<::icing::lib::ScoringSpecProto_RankingStrategy>(Arena*);
81 template<> ::icing::lib::SuggestionScoringSpecProto* Arena::CreateMaybeMessage<::icing::lib::SuggestionScoringSpecProto>(Arena*);
82 template<> ::icing::lib::SuggestionScoringSpecProto_SuggestionRankingStrategy* Arena::CreateMaybeMessage<::icing::lib::SuggestionScoringSpecProto_SuggestionRankingStrategy>(Arena*);
83 template<> ::icing::lib::TypePropertyWeights* Arena::CreateMaybeMessage<::icing::lib::TypePropertyWeights>(Arena*);
84 PROTOBUF_NAMESPACE_CLOSE
85 namespace icing {
86 namespace lib {
87
88 enum ScoringSpecProto_RankingStrategy_Code : int {
89 ScoringSpecProto_RankingStrategy_Code_NONE = 0,
90 ScoringSpecProto_RankingStrategy_Code_DOCUMENT_SCORE = 1,
91 ScoringSpecProto_RankingStrategy_Code_CREATION_TIMESTAMP = 2,
92 ScoringSpecProto_RankingStrategy_Code_USAGE_TYPE1_COUNT = 3,
93 ScoringSpecProto_RankingStrategy_Code_USAGE_TYPE2_COUNT = 4,
94 ScoringSpecProto_RankingStrategy_Code_USAGE_TYPE3_COUNT = 5,
95 ScoringSpecProto_RankingStrategy_Code_USAGE_TYPE1_LAST_USED_TIMESTAMP = 6,
96 ScoringSpecProto_RankingStrategy_Code_USAGE_TYPE2_LAST_USED_TIMESTAMP = 7,
97 ScoringSpecProto_RankingStrategy_Code_USAGE_TYPE3_LAST_USED_TIMESTAMP = 8,
98 ScoringSpecProto_RankingStrategy_Code_RELEVANCE_SCORE = 9,
99 ScoringSpecProto_RankingStrategy_Code_JOIN_AGGREGATE_SCORE = 10,
100 ScoringSpecProto_RankingStrategy_Code_ADVANCED_SCORING_EXPRESSION = 11
101 };
102 bool ScoringSpecProto_RankingStrategy_Code_IsValid(int value);
103 constexpr ScoringSpecProto_RankingStrategy_Code ScoringSpecProto_RankingStrategy_Code_Code_MIN = ScoringSpecProto_RankingStrategy_Code_NONE;
104 constexpr ScoringSpecProto_RankingStrategy_Code ScoringSpecProto_RankingStrategy_Code_Code_MAX = ScoringSpecProto_RankingStrategy_Code_ADVANCED_SCORING_EXPRESSION;
105 constexpr int ScoringSpecProto_RankingStrategy_Code_Code_ARRAYSIZE = ScoringSpecProto_RankingStrategy_Code_Code_MAX + 1;
106
107 const std::string& ScoringSpecProto_RankingStrategy_Code_Name(ScoringSpecProto_RankingStrategy_Code value);
108 template<typename T>
ScoringSpecProto_RankingStrategy_Code_Name(T enum_t_value)109 inline const std::string& ScoringSpecProto_RankingStrategy_Code_Name(T enum_t_value) {
110 static_assert(::std::is_same<T, ScoringSpecProto_RankingStrategy_Code>::value ||
111 ::std::is_integral<T>::value,
112 "Incorrect type passed to function ScoringSpecProto_RankingStrategy_Code_Name.");
113 return ScoringSpecProto_RankingStrategy_Code_Name(static_cast<ScoringSpecProto_RankingStrategy_Code>(enum_t_value));
114 }
115 bool ScoringSpecProto_RankingStrategy_Code_Parse(
116 ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ScoringSpecProto_RankingStrategy_Code* value);
117 enum ScoringSpecProto_Order_Code : int {
118 ScoringSpecProto_Order_Code_DESC = 0,
119 ScoringSpecProto_Order_Code_ASC = 1
120 };
121 bool ScoringSpecProto_Order_Code_IsValid(int value);
122 constexpr ScoringSpecProto_Order_Code ScoringSpecProto_Order_Code_Code_MIN = ScoringSpecProto_Order_Code_DESC;
123 constexpr ScoringSpecProto_Order_Code ScoringSpecProto_Order_Code_Code_MAX = ScoringSpecProto_Order_Code_ASC;
124 constexpr int ScoringSpecProto_Order_Code_Code_ARRAYSIZE = ScoringSpecProto_Order_Code_Code_MAX + 1;
125
126 const std::string& ScoringSpecProto_Order_Code_Name(ScoringSpecProto_Order_Code value);
127 template<typename T>
ScoringSpecProto_Order_Code_Name(T enum_t_value)128 inline const std::string& ScoringSpecProto_Order_Code_Name(T enum_t_value) {
129 static_assert(::std::is_same<T, ScoringSpecProto_Order_Code>::value ||
130 ::std::is_integral<T>::value,
131 "Incorrect type passed to function ScoringSpecProto_Order_Code_Name.");
132 return ScoringSpecProto_Order_Code_Name(static_cast<ScoringSpecProto_Order_Code>(enum_t_value));
133 }
134 bool ScoringSpecProto_Order_Code_Parse(
135 ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ScoringSpecProto_Order_Code* value);
136 enum SuggestionScoringSpecProto_SuggestionRankingStrategy_Code : int {
137 SuggestionScoringSpecProto_SuggestionRankingStrategy_Code_NONE = 0,
138 SuggestionScoringSpecProto_SuggestionRankingStrategy_Code_DOCUMENT_COUNT = 1,
139 SuggestionScoringSpecProto_SuggestionRankingStrategy_Code_TERM_FREQUENCY = 2
140 };
141 bool SuggestionScoringSpecProto_SuggestionRankingStrategy_Code_IsValid(int value);
142 constexpr SuggestionScoringSpecProto_SuggestionRankingStrategy_Code SuggestionScoringSpecProto_SuggestionRankingStrategy_Code_Code_MIN = SuggestionScoringSpecProto_SuggestionRankingStrategy_Code_NONE;
143 constexpr SuggestionScoringSpecProto_SuggestionRankingStrategy_Code SuggestionScoringSpecProto_SuggestionRankingStrategy_Code_Code_MAX = SuggestionScoringSpecProto_SuggestionRankingStrategy_Code_TERM_FREQUENCY;
144 constexpr int SuggestionScoringSpecProto_SuggestionRankingStrategy_Code_Code_ARRAYSIZE = SuggestionScoringSpecProto_SuggestionRankingStrategy_Code_Code_MAX + 1;
145
146 const std::string& SuggestionScoringSpecProto_SuggestionRankingStrategy_Code_Name(SuggestionScoringSpecProto_SuggestionRankingStrategy_Code value);
147 template<typename T>
SuggestionScoringSpecProto_SuggestionRankingStrategy_Code_Name(T enum_t_value)148 inline const std::string& SuggestionScoringSpecProto_SuggestionRankingStrategy_Code_Name(T enum_t_value) {
149 static_assert(::std::is_same<T, SuggestionScoringSpecProto_SuggestionRankingStrategy_Code>::value ||
150 ::std::is_integral<T>::value,
151 "Incorrect type passed to function SuggestionScoringSpecProto_SuggestionRankingStrategy_Code_Name.");
152 return SuggestionScoringSpecProto_SuggestionRankingStrategy_Code_Name(static_cast<SuggestionScoringSpecProto_SuggestionRankingStrategy_Code>(enum_t_value));
153 }
154 bool SuggestionScoringSpecProto_SuggestionRankingStrategy_Code_Parse(
155 ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SuggestionScoringSpecProto_SuggestionRankingStrategy_Code* value);
156 enum ScoringFeatureType : int {
157 SCORING_FEATURE_TYPE_UNKNOWN = 0,
158 SCORABLE_PROPERTY_RANKING = 1
159 };
160 bool ScoringFeatureType_IsValid(int value);
161 constexpr ScoringFeatureType ScoringFeatureType_MIN = SCORING_FEATURE_TYPE_UNKNOWN;
162 constexpr ScoringFeatureType ScoringFeatureType_MAX = SCORABLE_PROPERTY_RANKING;
163 constexpr int ScoringFeatureType_ARRAYSIZE = ScoringFeatureType_MAX + 1;
164
165 const std::string& ScoringFeatureType_Name(ScoringFeatureType value);
166 template<typename T>
ScoringFeatureType_Name(T enum_t_value)167 inline const std::string& ScoringFeatureType_Name(T enum_t_value) {
168 static_assert(::std::is_same<T, ScoringFeatureType>::value ||
169 ::std::is_integral<T>::value,
170 "Incorrect type passed to function ScoringFeatureType_Name.");
171 return ScoringFeatureType_Name(static_cast<ScoringFeatureType>(enum_t_value));
172 }
173 bool ScoringFeatureType_Parse(
174 ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ScoringFeatureType* value);
175 // ===================================================================
176
177 class ScoringSpecProto_RankingStrategy final :
178 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:icing.lib.ScoringSpecProto.RankingStrategy) */ {
179 public:
ScoringSpecProto_RankingStrategy()180 inline ScoringSpecProto_RankingStrategy() : ScoringSpecProto_RankingStrategy(nullptr) {}
181 ~ScoringSpecProto_RankingStrategy() override;
182 explicit PROTOBUF_CONSTEXPR ScoringSpecProto_RankingStrategy(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
183
184 ScoringSpecProto_RankingStrategy(const ScoringSpecProto_RankingStrategy& from);
ScoringSpecProto_RankingStrategy(ScoringSpecProto_RankingStrategy && from)185 ScoringSpecProto_RankingStrategy(ScoringSpecProto_RankingStrategy&& from) noexcept
186 : ScoringSpecProto_RankingStrategy() {
187 *this = ::std::move(from);
188 }
189
190 inline ScoringSpecProto_RankingStrategy& operator=(const ScoringSpecProto_RankingStrategy& from) {
191 if (this == &from) return *this;
192 CopyFrom(from);
193 return *this;
194 }
195 inline ScoringSpecProto_RankingStrategy& operator=(ScoringSpecProto_RankingStrategy&& from) noexcept {
196 if (this == &from) return *this;
197 if (GetOwningArena() == from.GetOwningArena()
198 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
199 && GetOwningArena() != nullptr
200 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
201 ) {
202 InternalSwap(&from);
203 } else {
204 CopyFrom(from);
205 }
206 return *this;
207 }
208
unknown_fields()209 inline const std::string& unknown_fields() const {
210 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
211 }
mutable_unknown_fields()212 inline std::string* mutable_unknown_fields() {
213 return _internal_metadata_.mutable_unknown_fields<std::string>();
214 }
215
default_instance()216 static const ScoringSpecProto_RankingStrategy& default_instance() {
217 return *internal_default_instance();
218 }
internal_default_instance()219 static inline const ScoringSpecProto_RankingStrategy* internal_default_instance() {
220 return reinterpret_cast<const ScoringSpecProto_RankingStrategy*>(
221 &_ScoringSpecProto_RankingStrategy_default_instance_);
222 }
223 static constexpr int kIndexInFileMessages =
224 0;
225
swap(ScoringSpecProto_RankingStrategy & a,ScoringSpecProto_RankingStrategy & b)226 friend void swap(ScoringSpecProto_RankingStrategy& a, ScoringSpecProto_RankingStrategy& b) {
227 a.Swap(&b);
228 }
Swap(ScoringSpecProto_RankingStrategy * other)229 inline void Swap(ScoringSpecProto_RankingStrategy* other) {
230 if (other == this) return;
231 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
232 if (GetOwningArena() != nullptr &&
233 GetOwningArena() == other->GetOwningArena()) {
234 #else // PROTOBUF_FORCE_COPY_IN_SWAP
235 if (GetOwningArena() == other->GetOwningArena()) {
236 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
237 InternalSwap(other);
238 } else {
239 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
240 }
241 }
242 void UnsafeArenaSwap(ScoringSpecProto_RankingStrategy* other) {
243 if (other == this) return;
244 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
245 InternalSwap(other);
246 }
247
248 // implements Message ----------------------------------------------
249
250 ScoringSpecProto_RankingStrategy* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
251 return CreateMaybeMessage<ScoringSpecProto_RankingStrategy>(arena);
252 }
253 ScoringSpecProto_RankingStrategy* New() const {
254 return New(nullptr);
255 }
256 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
257 void CopyFrom(const ScoringSpecProto_RankingStrategy& from);
258 void MergeFrom(const ScoringSpecProto_RankingStrategy& from);
259 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
260 bool IsInitialized() const final;
261
262 size_t ByteSizeLong() const final;
263 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
264 ::uint8_t* _InternalSerialize(
265 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
266 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
267
268 private:
269 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
270 void SharedDtor();
271 void SetCachedSize(int size) const;
272 void InternalSwap(ScoringSpecProto_RankingStrategy* other);
273
274 private:
275 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
276 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
277 return "icing.lib.ScoringSpecProto.RankingStrategy";
278 }
279 protected:
280 explicit ScoringSpecProto_RankingStrategy(::PROTOBUF_NAMESPACE_ID::Arena* arena,
281 bool is_message_owned = false);
282 public:
283
284 std::string GetTypeName() const final;
285
286 // nested types ----------------------------------------------------
287
288 typedef ScoringSpecProto_RankingStrategy_Code Code;
289 static constexpr Code NONE =
290 ScoringSpecProto_RankingStrategy_Code_NONE;
291 static constexpr Code DOCUMENT_SCORE =
292 ScoringSpecProto_RankingStrategy_Code_DOCUMENT_SCORE;
293 static constexpr Code CREATION_TIMESTAMP =
294 ScoringSpecProto_RankingStrategy_Code_CREATION_TIMESTAMP;
295 static constexpr Code USAGE_TYPE1_COUNT =
296 ScoringSpecProto_RankingStrategy_Code_USAGE_TYPE1_COUNT;
297 static constexpr Code USAGE_TYPE2_COUNT =
298 ScoringSpecProto_RankingStrategy_Code_USAGE_TYPE2_COUNT;
299 static constexpr Code USAGE_TYPE3_COUNT =
300 ScoringSpecProto_RankingStrategy_Code_USAGE_TYPE3_COUNT;
301 static constexpr Code USAGE_TYPE1_LAST_USED_TIMESTAMP =
302 ScoringSpecProto_RankingStrategy_Code_USAGE_TYPE1_LAST_USED_TIMESTAMP;
303 static constexpr Code USAGE_TYPE2_LAST_USED_TIMESTAMP =
304 ScoringSpecProto_RankingStrategy_Code_USAGE_TYPE2_LAST_USED_TIMESTAMP;
305 static constexpr Code USAGE_TYPE3_LAST_USED_TIMESTAMP =
306 ScoringSpecProto_RankingStrategy_Code_USAGE_TYPE3_LAST_USED_TIMESTAMP;
307 static constexpr Code RELEVANCE_SCORE =
308 ScoringSpecProto_RankingStrategy_Code_RELEVANCE_SCORE;
309 static constexpr Code JOIN_AGGREGATE_SCORE =
310 ScoringSpecProto_RankingStrategy_Code_JOIN_AGGREGATE_SCORE;
311 static constexpr Code ADVANCED_SCORING_EXPRESSION =
312 ScoringSpecProto_RankingStrategy_Code_ADVANCED_SCORING_EXPRESSION;
313 static inline bool Code_IsValid(int value) {
314 return ScoringSpecProto_RankingStrategy_Code_IsValid(value);
315 }
316 static constexpr Code Code_MIN =
317 ScoringSpecProto_RankingStrategy_Code_Code_MIN;
318 static constexpr Code Code_MAX =
319 ScoringSpecProto_RankingStrategy_Code_Code_MAX;
320 static constexpr int Code_ARRAYSIZE =
321 ScoringSpecProto_RankingStrategy_Code_Code_ARRAYSIZE;
322 template<typename T>
323 static inline const std::string& Code_Name(T enum_t_value) {
324 static_assert(::std::is_same<T, Code>::value ||
325 ::std::is_integral<T>::value,
326 "Incorrect type passed to function Code_Name.");
327 return ScoringSpecProto_RankingStrategy_Code_Name(enum_t_value);
328 }
329 static inline bool Code_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
330 Code* value) {
331 return ScoringSpecProto_RankingStrategy_Code_Parse(name, value);
332 }
333
334 // accessors -------------------------------------------------------
335
336 // @@protoc_insertion_point(class_scope:icing.lib.ScoringSpecProto.RankingStrategy)
337 private:
338 class _Internal;
339
340 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
341 typedef void InternalArenaConstructable_;
342 typedef void DestructorSkippable_;
343 struct Impl_ {
344 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
345 };
346 union { Impl_ _impl_; };
347 friend struct ::TableStruct_icing_2fproto_2fscoring_2eproto;
348 };
349 // -------------------------------------------------------------------
350
351 class ScoringSpecProto_Order final :
352 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:icing.lib.ScoringSpecProto.Order) */ {
353 public:
ScoringSpecProto_Order()354 inline ScoringSpecProto_Order() : ScoringSpecProto_Order(nullptr) {}
355 ~ScoringSpecProto_Order() override;
356 explicit PROTOBUF_CONSTEXPR ScoringSpecProto_Order(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
357
358 ScoringSpecProto_Order(const ScoringSpecProto_Order& from);
ScoringSpecProto_Order(ScoringSpecProto_Order && from)359 ScoringSpecProto_Order(ScoringSpecProto_Order&& from) noexcept
360 : ScoringSpecProto_Order() {
361 *this = ::std::move(from);
362 }
363
364 inline ScoringSpecProto_Order& operator=(const ScoringSpecProto_Order& from) {
365 if (this == &from) return *this;
366 CopyFrom(from);
367 return *this;
368 }
369 inline ScoringSpecProto_Order& operator=(ScoringSpecProto_Order&& from) noexcept {
370 if (this == &from) return *this;
371 if (GetOwningArena() == from.GetOwningArena()
372 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
373 && GetOwningArena() != nullptr
374 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
375 ) {
376 InternalSwap(&from);
377 } else {
378 CopyFrom(from);
379 }
380 return *this;
381 }
382
unknown_fields()383 inline const std::string& unknown_fields() const {
384 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
385 }
mutable_unknown_fields()386 inline std::string* mutable_unknown_fields() {
387 return _internal_metadata_.mutable_unknown_fields<std::string>();
388 }
389
default_instance()390 static const ScoringSpecProto_Order& default_instance() {
391 return *internal_default_instance();
392 }
internal_default_instance()393 static inline const ScoringSpecProto_Order* internal_default_instance() {
394 return reinterpret_cast<const ScoringSpecProto_Order*>(
395 &_ScoringSpecProto_Order_default_instance_);
396 }
397 static constexpr int kIndexInFileMessages =
398 1;
399
swap(ScoringSpecProto_Order & a,ScoringSpecProto_Order & b)400 friend void swap(ScoringSpecProto_Order& a, ScoringSpecProto_Order& b) {
401 a.Swap(&b);
402 }
Swap(ScoringSpecProto_Order * other)403 inline void Swap(ScoringSpecProto_Order* other) {
404 if (other == this) return;
405 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
406 if (GetOwningArena() != nullptr &&
407 GetOwningArena() == other->GetOwningArena()) {
408 #else // PROTOBUF_FORCE_COPY_IN_SWAP
409 if (GetOwningArena() == other->GetOwningArena()) {
410 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
411 InternalSwap(other);
412 } else {
413 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
414 }
415 }
416 void UnsafeArenaSwap(ScoringSpecProto_Order* other) {
417 if (other == this) return;
418 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
419 InternalSwap(other);
420 }
421
422 // implements Message ----------------------------------------------
423
424 ScoringSpecProto_Order* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
425 return CreateMaybeMessage<ScoringSpecProto_Order>(arena);
426 }
427 ScoringSpecProto_Order* New() const {
428 return New(nullptr);
429 }
430 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
431 void CopyFrom(const ScoringSpecProto_Order& from);
432 void MergeFrom(const ScoringSpecProto_Order& from);
433 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
434 bool IsInitialized() const final;
435
436 size_t ByteSizeLong() const final;
437 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
438 ::uint8_t* _InternalSerialize(
439 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
440 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
441
442 private:
443 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
444 void SharedDtor();
445 void SetCachedSize(int size) const;
446 void InternalSwap(ScoringSpecProto_Order* other);
447
448 private:
449 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
450 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
451 return "icing.lib.ScoringSpecProto.Order";
452 }
453 protected:
454 explicit ScoringSpecProto_Order(::PROTOBUF_NAMESPACE_ID::Arena* arena,
455 bool is_message_owned = false);
456 public:
457
458 std::string GetTypeName() const final;
459
460 // nested types ----------------------------------------------------
461
462 typedef ScoringSpecProto_Order_Code Code;
463 static constexpr Code DESC =
464 ScoringSpecProto_Order_Code_DESC;
465 static constexpr Code ASC =
466 ScoringSpecProto_Order_Code_ASC;
467 static inline bool Code_IsValid(int value) {
468 return ScoringSpecProto_Order_Code_IsValid(value);
469 }
470 static constexpr Code Code_MIN =
471 ScoringSpecProto_Order_Code_Code_MIN;
472 static constexpr Code Code_MAX =
473 ScoringSpecProto_Order_Code_Code_MAX;
474 static constexpr int Code_ARRAYSIZE =
475 ScoringSpecProto_Order_Code_Code_ARRAYSIZE;
476 template<typename T>
477 static inline const std::string& Code_Name(T enum_t_value) {
478 static_assert(::std::is_same<T, Code>::value ||
479 ::std::is_integral<T>::value,
480 "Incorrect type passed to function Code_Name.");
481 return ScoringSpecProto_Order_Code_Name(enum_t_value);
482 }
483 static inline bool Code_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
484 Code* value) {
485 return ScoringSpecProto_Order_Code_Parse(name, value);
486 }
487
488 // accessors -------------------------------------------------------
489
490 // @@protoc_insertion_point(class_scope:icing.lib.ScoringSpecProto.Order)
491 private:
492 class _Internal;
493
494 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
495 typedef void InternalArenaConstructable_;
496 typedef void DestructorSkippable_;
497 struct Impl_ {
498 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
499 };
500 union { Impl_ _impl_; };
501 friend struct ::TableStruct_icing_2fproto_2fscoring_2eproto;
502 };
503 // -------------------------------------------------------------------
504
505 class ScoringSpecProto final :
506 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:icing.lib.ScoringSpecProto) */ {
507 public:
ScoringSpecProto()508 inline ScoringSpecProto() : ScoringSpecProto(nullptr) {}
509 ~ScoringSpecProto() override;
510 explicit PROTOBUF_CONSTEXPR ScoringSpecProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
511
512 ScoringSpecProto(const ScoringSpecProto& from);
ScoringSpecProto(ScoringSpecProto && from)513 ScoringSpecProto(ScoringSpecProto&& from) noexcept
514 : ScoringSpecProto() {
515 *this = ::std::move(from);
516 }
517
518 inline ScoringSpecProto& operator=(const ScoringSpecProto& from) {
519 if (this == &from) return *this;
520 CopyFrom(from);
521 return *this;
522 }
523 inline ScoringSpecProto& operator=(ScoringSpecProto&& from) noexcept {
524 if (this == &from) return *this;
525 if (GetOwningArena() == from.GetOwningArena()
526 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
527 && GetOwningArena() != nullptr
528 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
529 ) {
530 InternalSwap(&from);
531 } else {
532 CopyFrom(from);
533 }
534 return *this;
535 }
536
unknown_fields()537 inline const std::string& unknown_fields() const {
538 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
539 }
mutable_unknown_fields()540 inline std::string* mutable_unknown_fields() {
541 return _internal_metadata_.mutable_unknown_fields<std::string>();
542 }
543
default_instance()544 static const ScoringSpecProto& default_instance() {
545 return *internal_default_instance();
546 }
internal_default_instance()547 static inline const ScoringSpecProto* internal_default_instance() {
548 return reinterpret_cast<const ScoringSpecProto*>(
549 &_ScoringSpecProto_default_instance_);
550 }
551 static constexpr int kIndexInFileMessages =
552 2;
553
swap(ScoringSpecProto & a,ScoringSpecProto & b)554 friend void swap(ScoringSpecProto& a, ScoringSpecProto& b) {
555 a.Swap(&b);
556 }
Swap(ScoringSpecProto * other)557 inline void Swap(ScoringSpecProto* other) {
558 if (other == this) return;
559 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
560 if (GetOwningArena() != nullptr &&
561 GetOwningArena() == other->GetOwningArena()) {
562 #else // PROTOBUF_FORCE_COPY_IN_SWAP
563 if (GetOwningArena() == other->GetOwningArena()) {
564 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
565 InternalSwap(other);
566 } else {
567 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
568 }
569 }
570 void UnsafeArenaSwap(ScoringSpecProto* other) {
571 if (other == this) return;
572 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
573 InternalSwap(other);
574 }
575
576 // implements Message ----------------------------------------------
577
578 ScoringSpecProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
579 return CreateMaybeMessage<ScoringSpecProto>(arena);
580 }
581 ScoringSpecProto* New() const {
582 return New(nullptr);
583 }
584 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
585 void CopyFrom(const ScoringSpecProto& from);
586 void MergeFrom(const ScoringSpecProto& from);
587 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
588 bool IsInitialized() const final;
589
590 size_t ByteSizeLong() const final;
591 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
592 ::uint8_t* _InternalSerialize(
593 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
594 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
595
596 private:
597 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
598 void SharedDtor();
599 void SetCachedSize(int size) const;
600 void InternalSwap(ScoringSpecProto* other);
601
602 private:
603 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
604 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
605 return "icing.lib.ScoringSpecProto";
606 }
607 protected:
608 explicit ScoringSpecProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
609 bool is_message_owned = false);
610 public:
611
612 std::string GetTypeName() const final;
613
614 // nested types ----------------------------------------------------
615
616 typedef ScoringSpecProto_RankingStrategy RankingStrategy;
617 typedef ScoringSpecProto_Order Order;
618
619 // accessors -------------------------------------------------------
620
621 enum : int {
622 kTypePropertyWeightsFieldNumber = 3,
623 kAdditionalAdvancedScoringExpressionsFieldNumber = 5,
624 kSchemaTypeAliasMapProtosFieldNumber = 6,
625 kScoringFeatureTypesEnabledFieldNumber = 7,
626 kAdvancedScoringExpressionFieldNumber = 4,
627 kRankByFieldNumber = 1,
628 kOrderByFieldNumber = 2,
629 };
630 // repeated .icing.lib.TypePropertyWeights type_property_weights = 3;
631 int type_property_weights_size() const;
632 private:
633 int _internal_type_property_weights_size() const;
634 public:
635 void clear_type_property_weights();
636 ::icing::lib::TypePropertyWeights* mutable_type_property_weights(int index);
637 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::TypePropertyWeights >*
638 mutable_type_property_weights();
639 private:
640 const ::icing::lib::TypePropertyWeights& _internal_type_property_weights(int index) const;
641 ::icing::lib::TypePropertyWeights* _internal_add_type_property_weights();
642 public:
643 const ::icing::lib::TypePropertyWeights& type_property_weights(int index) const;
644 ::icing::lib::TypePropertyWeights* add_type_property_weights();
645 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::TypePropertyWeights >&
646 type_property_weights() const;
647
648 // repeated string additional_advanced_scoring_expressions = 5;
649 int additional_advanced_scoring_expressions_size() const;
650 private:
651 int _internal_additional_advanced_scoring_expressions_size() const;
652 public:
653 void clear_additional_advanced_scoring_expressions();
654 const std::string& additional_advanced_scoring_expressions(int index) const;
655 std::string* mutable_additional_advanced_scoring_expressions(int index);
656 void set_additional_advanced_scoring_expressions(int index, const std::string& value);
657 void set_additional_advanced_scoring_expressions(int index, std::string&& value);
658 void set_additional_advanced_scoring_expressions(int index, const char* value);
659 void set_additional_advanced_scoring_expressions(int index, const char* value, size_t size);
660 std::string* add_additional_advanced_scoring_expressions();
661 void add_additional_advanced_scoring_expressions(const std::string& value);
662 void add_additional_advanced_scoring_expressions(std::string&& value);
663 void add_additional_advanced_scoring_expressions(const char* value);
664 void add_additional_advanced_scoring_expressions(const char* value, size_t size);
665 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& additional_advanced_scoring_expressions() const;
666 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_additional_advanced_scoring_expressions();
667 private:
668 const std::string& _internal_additional_advanced_scoring_expressions(int index) const;
669 std::string* _internal_add_additional_advanced_scoring_expressions();
670 public:
671
672 // repeated .icing.lib.SchemaTypeAliasMapProto schema_type_alias_map_protos = 6;
673 int schema_type_alias_map_protos_size() const;
674 private:
675 int _internal_schema_type_alias_map_protos_size() const;
676 public:
677 void clear_schema_type_alias_map_protos();
678 ::icing::lib::SchemaTypeAliasMapProto* mutable_schema_type_alias_map_protos(int index);
679 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::SchemaTypeAliasMapProto >*
680 mutable_schema_type_alias_map_protos();
681 private:
682 const ::icing::lib::SchemaTypeAliasMapProto& _internal_schema_type_alias_map_protos(int index) const;
683 ::icing::lib::SchemaTypeAliasMapProto* _internal_add_schema_type_alias_map_protos();
684 public:
685 const ::icing::lib::SchemaTypeAliasMapProto& schema_type_alias_map_protos(int index) const;
686 ::icing::lib::SchemaTypeAliasMapProto* add_schema_type_alias_map_protos();
687 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::SchemaTypeAliasMapProto >&
688 schema_type_alias_map_protos() const;
689
690 // repeated .icing.lib.ScoringFeatureType scoring_feature_types_enabled = 7 [packed = true];
691 int scoring_feature_types_enabled_size() const;
692 private:
693 int _internal_scoring_feature_types_enabled_size() const;
694 public:
695 void clear_scoring_feature_types_enabled();
696 private:
697 ::icing::lib::ScoringFeatureType _internal_scoring_feature_types_enabled(int index) const;
698 void _internal_add_scoring_feature_types_enabled(::icing::lib::ScoringFeatureType value);
699 ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* _internal_mutable_scoring_feature_types_enabled();
700 public:
701 ::icing::lib::ScoringFeatureType scoring_feature_types_enabled(int index) const;
702 void set_scoring_feature_types_enabled(int index, ::icing::lib::ScoringFeatureType value);
703 void add_scoring_feature_types_enabled(::icing::lib::ScoringFeatureType value);
704 const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>& scoring_feature_types_enabled() const;
705 ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* mutable_scoring_feature_types_enabled();
706
707 // optional string advanced_scoring_expression = 4;
708 bool has_advanced_scoring_expression() const;
709 private:
710 bool _internal_has_advanced_scoring_expression() const;
711 public:
712 void clear_advanced_scoring_expression();
713 const std::string& advanced_scoring_expression() const;
714 template <typename ArgT0 = const std::string&, typename... ArgT>
715 void set_advanced_scoring_expression(ArgT0&& arg0, ArgT... args);
716 std::string* mutable_advanced_scoring_expression();
717 PROTOBUF_NODISCARD std::string* release_advanced_scoring_expression();
718 void set_allocated_advanced_scoring_expression(std::string* advanced_scoring_expression);
719 private:
720 const std::string& _internal_advanced_scoring_expression() const;
721 inline PROTOBUF_ALWAYS_INLINE void _internal_set_advanced_scoring_expression(const std::string& value);
722 std::string* _internal_mutable_advanced_scoring_expression();
723 public:
724
725 // optional .icing.lib.ScoringSpecProto.RankingStrategy.Code rank_by = 1;
726 bool has_rank_by() const;
727 private:
728 bool _internal_has_rank_by() const;
729 public:
730 void clear_rank_by();
731 ::icing::lib::ScoringSpecProto_RankingStrategy_Code rank_by() const;
732 void set_rank_by(::icing::lib::ScoringSpecProto_RankingStrategy_Code value);
733 private:
734 ::icing::lib::ScoringSpecProto_RankingStrategy_Code _internal_rank_by() const;
735 void _internal_set_rank_by(::icing::lib::ScoringSpecProto_RankingStrategy_Code value);
736 public:
737
738 // optional .icing.lib.ScoringSpecProto.Order.Code order_by = 2;
739 bool has_order_by() const;
740 private:
741 bool _internal_has_order_by() const;
742 public:
743 void clear_order_by();
744 ::icing::lib::ScoringSpecProto_Order_Code order_by() const;
745 void set_order_by(::icing::lib::ScoringSpecProto_Order_Code value);
746 private:
747 ::icing::lib::ScoringSpecProto_Order_Code _internal_order_by() const;
748 void _internal_set_order_by(::icing::lib::ScoringSpecProto_Order_Code value);
749 public:
750
751 // @@protoc_insertion_point(class_scope:icing.lib.ScoringSpecProto)
752 private:
753 class _Internal;
754
755 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
756 typedef void InternalArenaConstructable_;
757 typedef void DestructorSkippable_;
758 struct Impl_ {
759 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
760 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
761 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::TypePropertyWeights > type_property_weights_;
762 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> additional_advanced_scoring_expressions_;
763 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::SchemaTypeAliasMapProto > schema_type_alias_map_protos_;
764 ::PROTOBUF_NAMESPACE_ID::RepeatedField<int> scoring_feature_types_enabled_;
765 mutable std::atomic<int> _scoring_feature_types_enabled_cached_byte_size_;
766 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr advanced_scoring_expression_;
767 int rank_by_;
768 int order_by_;
769 };
770 union { Impl_ _impl_; };
771 friend struct ::TableStruct_icing_2fproto_2fscoring_2eproto;
772 };
773 // -------------------------------------------------------------------
774
775 class SuggestionScoringSpecProto_SuggestionRankingStrategy final :
776 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:icing.lib.SuggestionScoringSpecProto.SuggestionRankingStrategy) */ {
777 public:
SuggestionScoringSpecProto_SuggestionRankingStrategy()778 inline SuggestionScoringSpecProto_SuggestionRankingStrategy() : SuggestionScoringSpecProto_SuggestionRankingStrategy(nullptr) {}
779 ~SuggestionScoringSpecProto_SuggestionRankingStrategy() override;
780 explicit PROTOBUF_CONSTEXPR SuggestionScoringSpecProto_SuggestionRankingStrategy(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
781
782 SuggestionScoringSpecProto_SuggestionRankingStrategy(const SuggestionScoringSpecProto_SuggestionRankingStrategy& from);
SuggestionScoringSpecProto_SuggestionRankingStrategy(SuggestionScoringSpecProto_SuggestionRankingStrategy && from)783 SuggestionScoringSpecProto_SuggestionRankingStrategy(SuggestionScoringSpecProto_SuggestionRankingStrategy&& from) noexcept
784 : SuggestionScoringSpecProto_SuggestionRankingStrategy() {
785 *this = ::std::move(from);
786 }
787
788 inline SuggestionScoringSpecProto_SuggestionRankingStrategy& operator=(const SuggestionScoringSpecProto_SuggestionRankingStrategy& from) {
789 if (this == &from) return *this;
790 CopyFrom(from);
791 return *this;
792 }
793 inline SuggestionScoringSpecProto_SuggestionRankingStrategy& operator=(SuggestionScoringSpecProto_SuggestionRankingStrategy&& from) noexcept {
794 if (this == &from) return *this;
795 if (GetOwningArena() == from.GetOwningArena()
796 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
797 && GetOwningArena() != nullptr
798 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
799 ) {
800 InternalSwap(&from);
801 } else {
802 CopyFrom(from);
803 }
804 return *this;
805 }
806
unknown_fields()807 inline const std::string& unknown_fields() const {
808 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
809 }
mutable_unknown_fields()810 inline std::string* mutable_unknown_fields() {
811 return _internal_metadata_.mutable_unknown_fields<std::string>();
812 }
813
default_instance()814 static const SuggestionScoringSpecProto_SuggestionRankingStrategy& default_instance() {
815 return *internal_default_instance();
816 }
internal_default_instance()817 static inline const SuggestionScoringSpecProto_SuggestionRankingStrategy* internal_default_instance() {
818 return reinterpret_cast<const SuggestionScoringSpecProto_SuggestionRankingStrategy*>(
819 &_SuggestionScoringSpecProto_SuggestionRankingStrategy_default_instance_);
820 }
821 static constexpr int kIndexInFileMessages =
822 3;
823
swap(SuggestionScoringSpecProto_SuggestionRankingStrategy & a,SuggestionScoringSpecProto_SuggestionRankingStrategy & b)824 friend void swap(SuggestionScoringSpecProto_SuggestionRankingStrategy& a, SuggestionScoringSpecProto_SuggestionRankingStrategy& b) {
825 a.Swap(&b);
826 }
Swap(SuggestionScoringSpecProto_SuggestionRankingStrategy * other)827 inline void Swap(SuggestionScoringSpecProto_SuggestionRankingStrategy* other) {
828 if (other == this) return;
829 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
830 if (GetOwningArena() != nullptr &&
831 GetOwningArena() == other->GetOwningArena()) {
832 #else // PROTOBUF_FORCE_COPY_IN_SWAP
833 if (GetOwningArena() == other->GetOwningArena()) {
834 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
835 InternalSwap(other);
836 } else {
837 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
838 }
839 }
840 void UnsafeArenaSwap(SuggestionScoringSpecProto_SuggestionRankingStrategy* other) {
841 if (other == this) return;
842 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
843 InternalSwap(other);
844 }
845
846 // implements Message ----------------------------------------------
847
848 SuggestionScoringSpecProto_SuggestionRankingStrategy* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
849 return CreateMaybeMessage<SuggestionScoringSpecProto_SuggestionRankingStrategy>(arena);
850 }
851 SuggestionScoringSpecProto_SuggestionRankingStrategy* New() const {
852 return New(nullptr);
853 }
854 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
855 void CopyFrom(const SuggestionScoringSpecProto_SuggestionRankingStrategy& from);
856 void MergeFrom(const SuggestionScoringSpecProto_SuggestionRankingStrategy& from);
857 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
858 bool IsInitialized() const final;
859
860 size_t ByteSizeLong() const final;
861 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
862 ::uint8_t* _InternalSerialize(
863 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
864 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
865
866 private:
867 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
868 void SharedDtor();
869 void SetCachedSize(int size) const;
870 void InternalSwap(SuggestionScoringSpecProto_SuggestionRankingStrategy* other);
871
872 private:
873 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
874 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
875 return "icing.lib.SuggestionScoringSpecProto.SuggestionRankingStrategy";
876 }
877 protected:
878 explicit SuggestionScoringSpecProto_SuggestionRankingStrategy(::PROTOBUF_NAMESPACE_ID::Arena* arena,
879 bool is_message_owned = false);
880 public:
881
882 std::string GetTypeName() const final;
883
884 // nested types ----------------------------------------------------
885
886 typedef SuggestionScoringSpecProto_SuggestionRankingStrategy_Code Code;
887 static constexpr Code NONE =
888 SuggestionScoringSpecProto_SuggestionRankingStrategy_Code_NONE;
889 static constexpr Code DOCUMENT_COUNT =
890 SuggestionScoringSpecProto_SuggestionRankingStrategy_Code_DOCUMENT_COUNT;
891 static constexpr Code TERM_FREQUENCY =
892 SuggestionScoringSpecProto_SuggestionRankingStrategy_Code_TERM_FREQUENCY;
893 static inline bool Code_IsValid(int value) {
894 return SuggestionScoringSpecProto_SuggestionRankingStrategy_Code_IsValid(value);
895 }
896 static constexpr Code Code_MIN =
897 SuggestionScoringSpecProto_SuggestionRankingStrategy_Code_Code_MIN;
898 static constexpr Code Code_MAX =
899 SuggestionScoringSpecProto_SuggestionRankingStrategy_Code_Code_MAX;
900 static constexpr int Code_ARRAYSIZE =
901 SuggestionScoringSpecProto_SuggestionRankingStrategy_Code_Code_ARRAYSIZE;
902 template<typename T>
903 static inline const std::string& Code_Name(T enum_t_value) {
904 static_assert(::std::is_same<T, Code>::value ||
905 ::std::is_integral<T>::value,
906 "Incorrect type passed to function Code_Name.");
907 return SuggestionScoringSpecProto_SuggestionRankingStrategy_Code_Name(enum_t_value);
908 }
909 static inline bool Code_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
910 Code* value) {
911 return SuggestionScoringSpecProto_SuggestionRankingStrategy_Code_Parse(name, value);
912 }
913
914 // accessors -------------------------------------------------------
915
916 // @@protoc_insertion_point(class_scope:icing.lib.SuggestionScoringSpecProto.SuggestionRankingStrategy)
917 private:
918 class _Internal;
919
920 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
921 typedef void InternalArenaConstructable_;
922 typedef void DestructorSkippable_;
923 struct Impl_ {
924 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
925 };
926 union { Impl_ _impl_; };
927 friend struct ::TableStruct_icing_2fproto_2fscoring_2eproto;
928 };
929 // -------------------------------------------------------------------
930
931 class SuggestionScoringSpecProto final :
932 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:icing.lib.SuggestionScoringSpecProto) */ {
933 public:
SuggestionScoringSpecProto()934 inline SuggestionScoringSpecProto() : SuggestionScoringSpecProto(nullptr) {}
935 ~SuggestionScoringSpecProto() override;
936 explicit PROTOBUF_CONSTEXPR SuggestionScoringSpecProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
937
938 SuggestionScoringSpecProto(const SuggestionScoringSpecProto& from);
SuggestionScoringSpecProto(SuggestionScoringSpecProto && from)939 SuggestionScoringSpecProto(SuggestionScoringSpecProto&& from) noexcept
940 : SuggestionScoringSpecProto() {
941 *this = ::std::move(from);
942 }
943
944 inline SuggestionScoringSpecProto& operator=(const SuggestionScoringSpecProto& from) {
945 if (this == &from) return *this;
946 CopyFrom(from);
947 return *this;
948 }
949 inline SuggestionScoringSpecProto& operator=(SuggestionScoringSpecProto&& from) noexcept {
950 if (this == &from) return *this;
951 if (GetOwningArena() == from.GetOwningArena()
952 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
953 && GetOwningArena() != nullptr
954 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
955 ) {
956 InternalSwap(&from);
957 } else {
958 CopyFrom(from);
959 }
960 return *this;
961 }
962
unknown_fields()963 inline const std::string& unknown_fields() const {
964 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
965 }
mutable_unknown_fields()966 inline std::string* mutable_unknown_fields() {
967 return _internal_metadata_.mutable_unknown_fields<std::string>();
968 }
969
default_instance()970 static const SuggestionScoringSpecProto& default_instance() {
971 return *internal_default_instance();
972 }
internal_default_instance()973 static inline const SuggestionScoringSpecProto* internal_default_instance() {
974 return reinterpret_cast<const SuggestionScoringSpecProto*>(
975 &_SuggestionScoringSpecProto_default_instance_);
976 }
977 static constexpr int kIndexInFileMessages =
978 4;
979
swap(SuggestionScoringSpecProto & a,SuggestionScoringSpecProto & b)980 friend void swap(SuggestionScoringSpecProto& a, SuggestionScoringSpecProto& b) {
981 a.Swap(&b);
982 }
Swap(SuggestionScoringSpecProto * other)983 inline void Swap(SuggestionScoringSpecProto* other) {
984 if (other == this) return;
985 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
986 if (GetOwningArena() != nullptr &&
987 GetOwningArena() == other->GetOwningArena()) {
988 #else // PROTOBUF_FORCE_COPY_IN_SWAP
989 if (GetOwningArena() == other->GetOwningArena()) {
990 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
991 InternalSwap(other);
992 } else {
993 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
994 }
995 }
996 void UnsafeArenaSwap(SuggestionScoringSpecProto* other) {
997 if (other == this) return;
998 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
999 InternalSwap(other);
1000 }
1001
1002 // implements Message ----------------------------------------------
1003
1004 SuggestionScoringSpecProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1005 return CreateMaybeMessage<SuggestionScoringSpecProto>(arena);
1006 }
1007 SuggestionScoringSpecProto* New() const {
1008 return New(nullptr);
1009 }
1010 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
1011 void CopyFrom(const SuggestionScoringSpecProto& from);
1012 void MergeFrom(const SuggestionScoringSpecProto& from);
1013 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1014 bool IsInitialized() const final;
1015
1016 size_t ByteSizeLong() const final;
1017 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1018 ::uint8_t* _InternalSerialize(
1019 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1020 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1021
1022 private:
1023 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1024 void SharedDtor();
1025 void SetCachedSize(int size) const;
1026 void InternalSwap(SuggestionScoringSpecProto* other);
1027
1028 private:
1029 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1030 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1031 return "icing.lib.SuggestionScoringSpecProto";
1032 }
1033 protected:
1034 explicit SuggestionScoringSpecProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1035 bool is_message_owned = false);
1036 public:
1037
1038 std::string GetTypeName() const final;
1039
1040 // nested types ----------------------------------------------------
1041
1042 typedef SuggestionScoringSpecProto_SuggestionRankingStrategy SuggestionRankingStrategy;
1043
1044 // accessors -------------------------------------------------------
1045
1046 enum : int {
1047 kScoringMatchTypeFieldNumber = 1,
1048 kRankByFieldNumber = 2,
1049 };
1050 // optional .icing.lib.TermMatchType.Code scoring_match_type = 1;
1051 bool has_scoring_match_type() const;
1052 private:
1053 bool _internal_has_scoring_match_type() const;
1054 public:
1055 void clear_scoring_match_type();
1056 ::icing::lib::TermMatchType_Code scoring_match_type() const;
1057 void set_scoring_match_type(::icing::lib::TermMatchType_Code value);
1058 private:
1059 ::icing::lib::TermMatchType_Code _internal_scoring_match_type() const;
1060 void _internal_set_scoring_match_type(::icing::lib::TermMatchType_Code value);
1061 public:
1062
1063 // optional .icing.lib.SuggestionScoringSpecProto.SuggestionRankingStrategy.Code rank_by = 2;
1064 bool has_rank_by() const;
1065 private:
1066 bool _internal_has_rank_by() const;
1067 public:
1068 void clear_rank_by();
1069 ::icing::lib::SuggestionScoringSpecProto_SuggestionRankingStrategy_Code rank_by() const;
1070 void set_rank_by(::icing::lib::SuggestionScoringSpecProto_SuggestionRankingStrategy_Code value);
1071 private:
1072 ::icing::lib::SuggestionScoringSpecProto_SuggestionRankingStrategy_Code _internal_rank_by() const;
1073 void _internal_set_rank_by(::icing::lib::SuggestionScoringSpecProto_SuggestionRankingStrategy_Code value);
1074 public:
1075
1076 // @@protoc_insertion_point(class_scope:icing.lib.SuggestionScoringSpecProto)
1077 private:
1078 class _Internal;
1079
1080 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1081 typedef void InternalArenaConstructable_;
1082 typedef void DestructorSkippable_;
1083 struct Impl_ {
1084 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
1085 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1086 int scoring_match_type_;
1087 int rank_by_;
1088 };
1089 union { Impl_ _impl_; };
1090 friend struct ::TableStruct_icing_2fproto_2fscoring_2eproto;
1091 };
1092 // -------------------------------------------------------------------
1093
1094 class TypePropertyWeights final :
1095 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:icing.lib.TypePropertyWeights) */ {
1096 public:
TypePropertyWeights()1097 inline TypePropertyWeights() : TypePropertyWeights(nullptr) {}
1098 ~TypePropertyWeights() override;
1099 explicit PROTOBUF_CONSTEXPR TypePropertyWeights(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1100
1101 TypePropertyWeights(const TypePropertyWeights& from);
TypePropertyWeights(TypePropertyWeights && from)1102 TypePropertyWeights(TypePropertyWeights&& from) noexcept
1103 : TypePropertyWeights() {
1104 *this = ::std::move(from);
1105 }
1106
1107 inline TypePropertyWeights& operator=(const TypePropertyWeights& from) {
1108 if (this == &from) return *this;
1109 CopyFrom(from);
1110 return *this;
1111 }
1112 inline TypePropertyWeights& operator=(TypePropertyWeights&& from) noexcept {
1113 if (this == &from) return *this;
1114 if (GetOwningArena() == from.GetOwningArena()
1115 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1116 && GetOwningArena() != nullptr
1117 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
1118 ) {
1119 InternalSwap(&from);
1120 } else {
1121 CopyFrom(from);
1122 }
1123 return *this;
1124 }
1125
unknown_fields()1126 inline const std::string& unknown_fields() const {
1127 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
1128 }
mutable_unknown_fields()1129 inline std::string* mutable_unknown_fields() {
1130 return _internal_metadata_.mutable_unknown_fields<std::string>();
1131 }
1132
default_instance()1133 static const TypePropertyWeights& default_instance() {
1134 return *internal_default_instance();
1135 }
internal_default_instance()1136 static inline const TypePropertyWeights* internal_default_instance() {
1137 return reinterpret_cast<const TypePropertyWeights*>(
1138 &_TypePropertyWeights_default_instance_);
1139 }
1140 static constexpr int kIndexInFileMessages =
1141 5;
1142
swap(TypePropertyWeights & a,TypePropertyWeights & b)1143 friend void swap(TypePropertyWeights& a, TypePropertyWeights& b) {
1144 a.Swap(&b);
1145 }
Swap(TypePropertyWeights * other)1146 inline void Swap(TypePropertyWeights* other) {
1147 if (other == this) return;
1148 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1149 if (GetOwningArena() != nullptr &&
1150 GetOwningArena() == other->GetOwningArena()) {
1151 #else // PROTOBUF_FORCE_COPY_IN_SWAP
1152 if (GetOwningArena() == other->GetOwningArena()) {
1153 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
1154 InternalSwap(other);
1155 } else {
1156 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1157 }
1158 }
1159 void UnsafeArenaSwap(TypePropertyWeights* other) {
1160 if (other == this) return;
1161 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1162 InternalSwap(other);
1163 }
1164
1165 // implements Message ----------------------------------------------
1166
1167 TypePropertyWeights* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1168 return CreateMaybeMessage<TypePropertyWeights>(arena);
1169 }
1170 TypePropertyWeights* New() const {
1171 return New(nullptr);
1172 }
1173 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
1174 void CopyFrom(const TypePropertyWeights& from);
1175 void MergeFrom(const TypePropertyWeights& from);
1176 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1177 bool IsInitialized() const final;
1178
1179 size_t ByteSizeLong() const final;
1180 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1181 ::uint8_t* _InternalSerialize(
1182 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1183 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1184
1185 private:
1186 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1187 void SharedDtor();
1188 void SetCachedSize(int size) const;
1189 void InternalSwap(TypePropertyWeights* other);
1190
1191 private:
1192 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1193 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1194 return "icing.lib.TypePropertyWeights";
1195 }
1196 protected:
1197 explicit TypePropertyWeights(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1198 bool is_message_owned = false);
1199 public:
1200
1201 std::string GetTypeName() const final;
1202
1203 // nested types ----------------------------------------------------
1204
1205 // accessors -------------------------------------------------------
1206
1207 enum : int {
1208 kPropertyWeightsFieldNumber = 2,
1209 kSchemaTypeFieldNumber = 1,
1210 };
1211 // repeated .icing.lib.PropertyWeight property_weights = 2;
1212 int property_weights_size() const;
1213 private:
1214 int _internal_property_weights_size() const;
1215 public:
1216 void clear_property_weights();
1217 ::icing::lib::PropertyWeight* mutable_property_weights(int index);
1218 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::PropertyWeight >*
1219 mutable_property_weights();
1220 private:
1221 const ::icing::lib::PropertyWeight& _internal_property_weights(int index) const;
1222 ::icing::lib::PropertyWeight* _internal_add_property_weights();
1223 public:
1224 const ::icing::lib::PropertyWeight& property_weights(int index) const;
1225 ::icing::lib::PropertyWeight* add_property_weights();
1226 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::PropertyWeight >&
1227 property_weights() const;
1228
1229 // optional string schema_type = 1;
1230 bool has_schema_type() const;
1231 private:
1232 bool _internal_has_schema_type() const;
1233 public:
1234 void clear_schema_type();
1235 const std::string& schema_type() const;
1236 template <typename ArgT0 = const std::string&, typename... ArgT>
1237 void set_schema_type(ArgT0&& arg0, ArgT... args);
1238 std::string* mutable_schema_type();
1239 PROTOBUF_NODISCARD std::string* release_schema_type();
1240 void set_allocated_schema_type(std::string* schema_type);
1241 private:
1242 const std::string& _internal_schema_type() const;
1243 inline PROTOBUF_ALWAYS_INLINE void _internal_set_schema_type(const std::string& value);
1244 std::string* _internal_mutable_schema_type();
1245 public:
1246
1247 // @@protoc_insertion_point(class_scope:icing.lib.TypePropertyWeights)
1248 private:
1249 class _Internal;
1250
1251 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1252 typedef void InternalArenaConstructable_;
1253 typedef void DestructorSkippable_;
1254 struct Impl_ {
1255 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
1256 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1257 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::PropertyWeight > property_weights_;
1258 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr schema_type_;
1259 };
1260 union { Impl_ _impl_; };
1261 friend struct ::TableStruct_icing_2fproto_2fscoring_2eproto;
1262 };
1263 // -------------------------------------------------------------------
1264
1265 class PropertyWeight final :
1266 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:icing.lib.PropertyWeight) */ {
1267 public:
PropertyWeight()1268 inline PropertyWeight() : PropertyWeight(nullptr) {}
1269 ~PropertyWeight() override;
1270 explicit PROTOBUF_CONSTEXPR PropertyWeight(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1271
1272 PropertyWeight(const PropertyWeight& from);
PropertyWeight(PropertyWeight && from)1273 PropertyWeight(PropertyWeight&& from) noexcept
1274 : PropertyWeight() {
1275 *this = ::std::move(from);
1276 }
1277
1278 inline PropertyWeight& operator=(const PropertyWeight& from) {
1279 if (this == &from) return *this;
1280 CopyFrom(from);
1281 return *this;
1282 }
1283 inline PropertyWeight& operator=(PropertyWeight&& from) noexcept {
1284 if (this == &from) return *this;
1285 if (GetOwningArena() == from.GetOwningArena()
1286 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1287 && GetOwningArena() != nullptr
1288 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
1289 ) {
1290 InternalSwap(&from);
1291 } else {
1292 CopyFrom(from);
1293 }
1294 return *this;
1295 }
1296
unknown_fields()1297 inline const std::string& unknown_fields() const {
1298 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
1299 }
mutable_unknown_fields()1300 inline std::string* mutable_unknown_fields() {
1301 return _internal_metadata_.mutable_unknown_fields<std::string>();
1302 }
1303
default_instance()1304 static const PropertyWeight& default_instance() {
1305 return *internal_default_instance();
1306 }
internal_default_instance()1307 static inline const PropertyWeight* internal_default_instance() {
1308 return reinterpret_cast<const PropertyWeight*>(
1309 &_PropertyWeight_default_instance_);
1310 }
1311 static constexpr int kIndexInFileMessages =
1312 6;
1313
swap(PropertyWeight & a,PropertyWeight & b)1314 friend void swap(PropertyWeight& a, PropertyWeight& b) {
1315 a.Swap(&b);
1316 }
Swap(PropertyWeight * other)1317 inline void Swap(PropertyWeight* other) {
1318 if (other == this) return;
1319 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1320 if (GetOwningArena() != nullptr &&
1321 GetOwningArena() == other->GetOwningArena()) {
1322 #else // PROTOBUF_FORCE_COPY_IN_SWAP
1323 if (GetOwningArena() == other->GetOwningArena()) {
1324 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
1325 InternalSwap(other);
1326 } else {
1327 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1328 }
1329 }
1330 void UnsafeArenaSwap(PropertyWeight* other) {
1331 if (other == this) return;
1332 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1333 InternalSwap(other);
1334 }
1335
1336 // implements Message ----------------------------------------------
1337
1338 PropertyWeight* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1339 return CreateMaybeMessage<PropertyWeight>(arena);
1340 }
1341 PropertyWeight* New() const {
1342 return New(nullptr);
1343 }
1344 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
1345 void CopyFrom(const PropertyWeight& from);
1346 void MergeFrom(const PropertyWeight& from);
1347 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1348 bool IsInitialized() const final;
1349
1350 size_t ByteSizeLong() const final;
1351 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1352 ::uint8_t* _InternalSerialize(
1353 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1354 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1355
1356 private:
1357 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1358 void SharedDtor();
1359 void SetCachedSize(int size) const;
1360 void InternalSwap(PropertyWeight* other);
1361
1362 private:
1363 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1364 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1365 return "icing.lib.PropertyWeight";
1366 }
1367 protected:
1368 explicit PropertyWeight(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1369 bool is_message_owned = false);
1370 public:
1371
1372 std::string GetTypeName() const final;
1373
1374 // nested types ----------------------------------------------------
1375
1376 // accessors -------------------------------------------------------
1377
1378 enum : int {
1379 kPathFieldNumber = 1,
1380 kWeightFieldNumber = 2,
1381 };
1382 // optional string path = 1;
1383 bool has_path() const;
1384 private:
1385 bool _internal_has_path() const;
1386 public:
1387 void clear_path();
1388 const std::string& path() const;
1389 template <typename ArgT0 = const std::string&, typename... ArgT>
1390 void set_path(ArgT0&& arg0, ArgT... args);
1391 std::string* mutable_path();
1392 PROTOBUF_NODISCARD std::string* release_path();
1393 void set_allocated_path(std::string* path);
1394 private:
1395 const std::string& _internal_path() const;
1396 inline PROTOBUF_ALWAYS_INLINE void _internal_set_path(const std::string& value);
1397 std::string* _internal_mutable_path();
1398 public:
1399
1400 // optional double weight = 2;
1401 bool has_weight() const;
1402 private:
1403 bool _internal_has_weight() const;
1404 public:
1405 void clear_weight();
1406 double weight() const;
1407 void set_weight(double value);
1408 private:
1409 double _internal_weight() const;
1410 void _internal_set_weight(double value);
1411 public:
1412
1413 // @@protoc_insertion_point(class_scope:icing.lib.PropertyWeight)
1414 private:
1415 class _Internal;
1416
1417 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1418 typedef void InternalArenaConstructable_;
1419 typedef void DestructorSkippable_;
1420 struct Impl_ {
1421 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
1422 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1423 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr path_;
1424 double weight_;
1425 };
1426 union { Impl_ _impl_; };
1427 friend struct ::TableStruct_icing_2fproto_2fscoring_2eproto;
1428 };
1429 // -------------------------------------------------------------------
1430
1431 class SchemaTypeAliasMapProto final :
1432 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:icing.lib.SchemaTypeAliasMapProto) */ {
1433 public:
SchemaTypeAliasMapProto()1434 inline SchemaTypeAliasMapProto() : SchemaTypeAliasMapProto(nullptr) {}
1435 ~SchemaTypeAliasMapProto() override;
1436 explicit PROTOBUF_CONSTEXPR SchemaTypeAliasMapProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1437
1438 SchemaTypeAliasMapProto(const SchemaTypeAliasMapProto& from);
SchemaTypeAliasMapProto(SchemaTypeAliasMapProto && from)1439 SchemaTypeAliasMapProto(SchemaTypeAliasMapProto&& from) noexcept
1440 : SchemaTypeAliasMapProto() {
1441 *this = ::std::move(from);
1442 }
1443
1444 inline SchemaTypeAliasMapProto& operator=(const SchemaTypeAliasMapProto& from) {
1445 if (this == &from) return *this;
1446 CopyFrom(from);
1447 return *this;
1448 }
1449 inline SchemaTypeAliasMapProto& operator=(SchemaTypeAliasMapProto&& from) noexcept {
1450 if (this == &from) return *this;
1451 if (GetOwningArena() == from.GetOwningArena()
1452 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1453 && GetOwningArena() != nullptr
1454 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
1455 ) {
1456 InternalSwap(&from);
1457 } else {
1458 CopyFrom(from);
1459 }
1460 return *this;
1461 }
1462
unknown_fields()1463 inline const std::string& unknown_fields() const {
1464 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
1465 }
mutable_unknown_fields()1466 inline std::string* mutable_unknown_fields() {
1467 return _internal_metadata_.mutable_unknown_fields<std::string>();
1468 }
1469
default_instance()1470 static const SchemaTypeAliasMapProto& default_instance() {
1471 return *internal_default_instance();
1472 }
internal_default_instance()1473 static inline const SchemaTypeAliasMapProto* internal_default_instance() {
1474 return reinterpret_cast<const SchemaTypeAliasMapProto*>(
1475 &_SchemaTypeAliasMapProto_default_instance_);
1476 }
1477 static constexpr int kIndexInFileMessages =
1478 7;
1479
swap(SchemaTypeAliasMapProto & a,SchemaTypeAliasMapProto & b)1480 friend void swap(SchemaTypeAliasMapProto& a, SchemaTypeAliasMapProto& b) {
1481 a.Swap(&b);
1482 }
Swap(SchemaTypeAliasMapProto * other)1483 inline void Swap(SchemaTypeAliasMapProto* other) {
1484 if (other == this) return;
1485 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1486 if (GetOwningArena() != nullptr &&
1487 GetOwningArena() == other->GetOwningArena()) {
1488 #else // PROTOBUF_FORCE_COPY_IN_SWAP
1489 if (GetOwningArena() == other->GetOwningArena()) {
1490 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
1491 InternalSwap(other);
1492 } else {
1493 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1494 }
1495 }
1496 void UnsafeArenaSwap(SchemaTypeAliasMapProto* other) {
1497 if (other == this) return;
1498 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1499 InternalSwap(other);
1500 }
1501
1502 // implements Message ----------------------------------------------
1503
1504 SchemaTypeAliasMapProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1505 return CreateMaybeMessage<SchemaTypeAliasMapProto>(arena);
1506 }
1507 SchemaTypeAliasMapProto* New() const {
1508 return New(nullptr);
1509 }
1510 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
1511 void CopyFrom(const SchemaTypeAliasMapProto& from);
1512 void MergeFrom(const SchemaTypeAliasMapProto& from);
1513 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1514 bool IsInitialized() const final;
1515
1516 size_t ByteSizeLong() const final;
1517 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1518 ::uint8_t* _InternalSerialize(
1519 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1520 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1521
1522 private:
1523 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1524 void SharedDtor();
1525 void SetCachedSize(int size) const;
1526 void InternalSwap(SchemaTypeAliasMapProto* other);
1527
1528 private:
1529 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1530 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1531 return "icing.lib.SchemaTypeAliasMapProto";
1532 }
1533 protected:
1534 explicit SchemaTypeAliasMapProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1535 bool is_message_owned = false);
1536 public:
1537
1538 std::string GetTypeName() const final;
1539
1540 // nested types ----------------------------------------------------
1541
1542 // accessors -------------------------------------------------------
1543
1544 enum : int {
1545 kSchemaTypesFieldNumber = 2,
1546 kAliasSchemaTypeFieldNumber = 1,
1547 };
1548 // repeated string schema_types = 2;
1549 int schema_types_size() const;
1550 private:
1551 int _internal_schema_types_size() const;
1552 public:
1553 void clear_schema_types();
1554 const std::string& schema_types(int index) const;
1555 std::string* mutable_schema_types(int index);
1556 void set_schema_types(int index, const std::string& value);
1557 void set_schema_types(int index, std::string&& value);
1558 void set_schema_types(int index, const char* value);
1559 void set_schema_types(int index, const char* value, size_t size);
1560 std::string* add_schema_types();
1561 void add_schema_types(const std::string& value);
1562 void add_schema_types(std::string&& value);
1563 void add_schema_types(const char* value);
1564 void add_schema_types(const char* value, size_t size);
1565 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& schema_types() const;
1566 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_schema_types();
1567 private:
1568 const std::string& _internal_schema_types(int index) const;
1569 std::string* _internal_add_schema_types();
1570 public:
1571
1572 // optional string alias_schema_type = 1;
1573 bool has_alias_schema_type() const;
1574 private:
1575 bool _internal_has_alias_schema_type() const;
1576 public:
1577 void clear_alias_schema_type();
1578 const std::string& alias_schema_type() const;
1579 template <typename ArgT0 = const std::string&, typename... ArgT>
1580 void set_alias_schema_type(ArgT0&& arg0, ArgT... args);
1581 std::string* mutable_alias_schema_type();
1582 PROTOBUF_NODISCARD std::string* release_alias_schema_type();
1583 void set_allocated_alias_schema_type(std::string* alias_schema_type);
1584 private:
1585 const std::string& _internal_alias_schema_type() const;
1586 inline PROTOBUF_ALWAYS_INLINE void _internal_set_alias_schema_type(const std::string& value);
1587 std::string* _internal_mutable_alias_schema_type();
1588 public:
1589
1590 // @@protoc_insertion_point(class_scope:icing.lib.SchemaTypeAliasMapProto)
1591 private:
1592 class _Internal;
1593
1594 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1595 typedef void InternalArenaConstructable_;
1596 typedef void DestructorSkippable_;
1597 struct Impl_ {
1598 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
1599 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1600 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> schema_types_;
1601 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr alias_schema_type_;
1602 };
1603 union { Impl_ _impl_; };
1604 friend struct ::TableStruct_icing_2fproto_2fscoring_2eproto;
1605 };
1606 // ===================================================================
1607
1608
1609 // ===================================================================
1610
1611 #ifdef __GNUC__
1612 #pragma GCC diagnostic push
1613 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
1614 #endif // __GNUC__
1615 // ScoringSpecProto_RankingStrategy
1616
1617 // -------------------------------------------------------------------
1618
1619 // ScoringSpecProto_Order
1620
1621 // -------------------------------------------------------------------
1622
1623 // ScoringSpecProto
1624
1625 // optional .icing.lib.ScoringSpecProto.RankingStrategy.Code rank_by = 1;
_internal_has_rank_by()1626 inline bool ScoringSpecProto::_internal_has_rank_by() const {
1627 bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
1628 return value;
1629 }
has_rank_by()1630 inline bool ScoringSpecProto::has_rank_by() const {
1631 return _internal_has_rank_by();
1632 }
clear_rank_by()1633 inline void ScoringSpecProto::clear_rank_by() {
1634 _impl_.rank_by_ = 0;
1635 _impl_._has_bits_[0] &= ~0x00000002u;
1636 }
_internal_rank_by()1637 inline ::icing::lib::ScoringSpecProto_RankingStrategy_Code ScoringSpecProto::_internal_rank_by() const {
1638 return static_cast< ::icing::lib::ScoringSpecProto_RankingStrategy_Code >(_impl_.rank_by_);
1639 }
rank_by()1640 inline ::icing::lib::ScoringSpecProto_RankingStrategy_Code ScoringSpecProto::rank_by() const {
1641 // @@protoc_insertion_point(field_get:icing.lib.ScoringSpecProto.rank_by)
1642 return _internal_rank_by();
1643 }
_internal_set_rank_by(::icing::lib::ScoringSpecProto_RankingStrategy_Code value)1644 inline void ScoringSpecProto::_internal_set_rank_by(::icing::lib::ScoringSpecProto_RankingStrategy_Code value) {
1645 assert(::icing::lib::ScoringSpecProto_RankingStrategy_Code_IsValid(value));
1646 _impl_._has_bits_[0] |= 0x00000002u;
1647 _impl_.rank_by_ = value;
1648 }
set_rank_by(::icing::lib::ScoringSpecProto_RankingStrategy_Code value)1649 inline void ScoringSpecProto::set_rank_by(::icing::lib::ScoringSpecProto_RankingStrategy_Code value) {
1650 _internal_set_rank_by(value);
1651 // @@protoc_insertion_point(field_set:icing.lib.ScoringSpecProto.rank_by)
1652 }
1653
1654 // optional .icing.lib.ScoringSpecProto.Order.Code order_by = 2;
_internal_has_order_by()1655 inline bool ScoringSpecProto::_internal_has_order_by() const {
1656 bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
1657 return value;
1658 }
has_order_by()1659 inline bool ScoringSpecProto::has_order_by() const {
1660 return _internal_has_order_by();
1661 }
clear_order_by()1662 inline void ScoringSpecProto::clear_order_by() {
1663 _impl_.order_by_ = 0;
1664 _impl_._has_bits_[0] &= ~0x00000004u;
1665 }
_internal_order_by()1666 inline ::icing::lib::ScoringSpecProto_Order_Code ScoringSpecProto::_internal_order_by() const {
1667 return static_cast< ::icing::lib::ScoringSpecProto_Order_Code >(_impl_.order_by_);
1668 }
order_by()1669 inline ::icing::lib::ScoringSpecProto_Order_Code ScoringSpecProto::order_by() const {
1670 // @@protoc_insertion_point(field_get:icing.lib.ScoringSpecProto.order_by)
1671 return _internal_order_by();
1672 }
_internal_set_order_by(::icing::lib::ScoringSpecProto_Order_Code value)1673 inline void ScoringSpecProto::_internal_set_order_by(::icing::lib::ScoringSpecProto_Order_Code value) {
1674 assert(::icing::lib::ScoringSpecProto_Order_Code_IsValid(value));
1675 _impl_._has_bits_[0] |= 0x00000004u;
1676 _impl_.order_by_ = value;
1677 }
set_order_by(::icing::lib::ScoringSpecProto_Order_Code value)1678 inline void ScoringSpecProto::set_order_by(::icing::lib::ScoringSpecProto_Order_Code value) {
1679 _internal_set_order_by(value);
1680 // @@protoc_insertion_point(field_set:icing.lib.ScoringSpecProto.order_by)
1681 }
1682
1683 // repeated .icing.lib.TypePropertyWeights type_property_weights = 3;
_internal_type_property_weights_size()1684 inline int ScoringSpecProto::_internal_type_property_weights_size() const {
1685 return _impl_.type_property_weights_.size();
1686 }
type_property_weights_size()1687 inline int ScoringSpecProto::type_property_weights_size() const {
1688 return _internal_type_property_weights_size();
1689 }
clear_type_property_weights()1690 inline void ScoringSpecProto::clear_type_property_weights() {
1691 _impl_.type_property_weights_.Clear();
1692 }
mutable_type_property_weights(int index)1693 inline ::icing::lib::TypePropertyWeights* ScoringSpecProto::mutable_type_property_weights(int index) {
1694 // @@protoc_insertion_point(field_mutable:icing.lib.ScoringSpecProto.type_property_weights)
1695 return _impl_.type_property_weights_.Mutable(index);
1696 }
1697 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::TypePropertyWeights >*
mutable_type_property_weights()1698 ScoringSpecProto::mutable_type_property_weights() {
1699 // @@protoc_insertion_point(field_mutable_list:icing.lib.ScoringSpecProto.type_property_weights)
1700 return &_impl_.type_property_weights_;
1701 }
_internal_type_property_weights(int index)1702 inline const ::icing::lib::TypePropertyWeights& ScoringSpecProto::_internal_type_property_weights(int index) const {
1703 return _impl_.type_property_weights_.Get(index);
1704 }
type_property_weights(int index)1705 inline const ::icing::lib::TypePropertyWeights& ScoringSpecProto::type_property_weights(int index) const {
1706 // @@protoc_insertion_point(field_get:icing.lib.ScoringSpecProto.type_property_weights)
1707 return _internal_type_property_weights(index);
1708 }
_internal_add_type_property_weights()1709 inline ::icing::lib::TypePropertyWeights* ScoringSpecProto::_internal_add_type_property_weights() {
1710 return _impl_.type_property_weights_.Add();
1711 }
add_type_property_weights()1712 inline ::icing::lib::TypePropertyWeights* ScoringSpecProto::add_type_property_weights() {
1713 ::icing::lib::TypePropertyWeights* _add = _internal_add_type_property_weights();
1714 // @@protoc_insertion_point(field_add:icing.lib.ScoringSpecProto.type_property_weights)
1715 return _add;
1716 }
1717 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::TypePropertyWeights >&
type_property_weights()1718 ScoringSpecProto::type_property_weights() const {
1719 // @@protoc_insertion_point(field_list:icing.lib.ScoringSpecProto.type_property_weights)
1720 return _impl_.type_property_weights_;
1721 }
1722
1723 // optional string advanced_scoring_expression = 4;
_internal_has_advanced_scoring_expression()1724 inline bool ScoringSpecProto::_internal_has_advanced_scoring_expression() const {
1725 bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
1726 return value;
1727 }
has_advanced_scoring_expression()1728 inline bool ScoringSpecProto::has_advanced_scoring_expression() const {
1729 return _internal_has_advanced_scoring_expression();
1730 }
clear_advanced_scoring_expression()1731 inline void ScoringSpecProto::clear_advanced_scoring_expression() {
1732 _impl_.advanced_scoring_expression_.ClearToEmpty();
1733 _impl_._has_bits_[0] &= ~0x00000001u;
1734 }
advanced_scoring_expression()1735 inline const std::string& ScoringSpecProto::advanced_scoring_expression() const {
1736 // @@protoc_insertion_point(field_get:icing.lib.ScoringSpecProto.advanced_scoring_expression)
1737 return _internal_advanced_scoring_expression();
1738 }
1739 template <typename ArgT0, typename... ArgT>
1740 inline PROTOBUF_ALWAYS_INLINE
set_advanced_scoring_expression(ArgT0 && arg0,ArgT...args)1741 void ScoringSpecProto::set_advanced_scoring_expression(ArgT0&& arg0, ArgT... args) {
1742 _impl_._has_bits_[0] |= 0x00000001u;
1743 _impl_.advanced_scoring_expression_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
1744 // @@protoc_insertion_point(field_set:icing.lib.ScoringSpecProto.advanced_scoring_expression)
1745 }
mutable_advanced_scoring_expression()1746 inline std::string* ScoringSpecProto::mutable_advanced_scoring_expression() {
1747 std::string* _s = _internal_mutable_advanced_scoring_expression();
1748 // @@protoc_insertion_point(field_mutable:icing.lib.ScoringSpecProto.advanced_scoring_expression)
1749 return _s;
1750 }
_internal_advanced_scoring_expression()1751 inline const std::string& ScoringSpecProto::_internal_advanced_scoring_expression() const {
1752 return _impl_.advanced_scoring_expression_.Get();
1753 }
_internal_set_advanced_scoring_expression(const std::string & value)1754 inline void ScoringSpecProto::_internal_set_advanced_scoring_expression(const std::string& value) {
1755 _impl_._has_bits_[0] |= 0x00000001u;
1756 _impl_.advanced_scoring_expression_.Set(value, GetArenaForAllocation());
1757 }
_internal_mutable_advanced_scoring_expression()1758 inline std::string* ScoringSpecProto::_internal_mutable_advanced_scoring_expression() {
1759 _impl_._has_bits_[0] |= 0x00000001u;
1760 return _impl_.advanced_scoring_expression_.Mutable(GetArenaForAllocation());
1761 }
release_advanced_scoring_expression()1762 inline std::string* ScoringSpecProto::release_advanced_scoring_expression() {
1763 // @@protoc_insertion_point(field_release:icing.lib.ScoringSpecProto.advanced_scoring_expression)
1764 if (!_internal_has_advanced_scoring_expression()) {
1765 return nullptr;
1766 }
1767 _impl_._has_bits_[0] &= ~0x00000001u;
1768 auto* p = _impl_.advanced_scoring_expression_.Release();
1769 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1770 if (_impl_.advanced_scoring_expression_.IsDefault()) {
1771 _impl_.advanced_scoring_expression_.Set("", GetArenaForAllocation());
1772 }
1773 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1774 return p;
1775 }
set_allocated_advanced_scoring_expression(std::string * advanced_scoring_expression)1776 inline void ScoringSpecProto::set_allocated_advanced_scoring_expression(std::string* advanced_scoring_expression) {
1777 if (advanced_scoring_expression != nullptr) {
1778 _impl_._has_bits_[0] |= 0x00000001u;
1779 } else {
1780 _impl_._has_bits_[0] &= ~0x00000001u;
1781 }
1782 _impl_.advanced_scoring_expression_.SetAllocated(advanced_scoring_expression, GetArenaForAllocation());
1783 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1784 if (_impl_.advanced_scoring_expression_.IsDefault()) {
1785 _impl_.advanced_scoring_expression_.Set("", GetArenaForAllocation());
1786 }
1787 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1788 // @@protoc_insertion_point(field_set_allocated:icing.lib.ScoringSpecProto.advanced_scoring_expression)
1789 }
1790
1791 // repeated string additional_advanced_scoring_expressions = 5;
_internal_additional_advanced_scoring_expressions_size()1792 inline int ScoringSpecProto::_internal_additional_advanced_scoring_expressions_size() const {
1793 return _impl_.additional_advanced_scoring_expressions_.size();
1794 }
additional_advanced_scoring_expressions_size()1795 inline int ScoringSpecProto::additional_advanced_scoring_expressions_size() const {
1796 return _internal_additional_advanced_scoring_expressions_size();
1797 }
clear_additional_advanced_scoring_expressions()1798 inline void ScoringSpecProto::clear_additional_advanced_scoring_expressions() {
1799 _impl_.additional_advanced_scoring_expressions_.Clear();
1800 }
add_additional_advanced_scoring_expressions()1801 inline std::string* ScoringSpecProto::add_additional_advanced_scoring_expressions() {
1802 std::string* _s = _internal_add_additional_advanced_scoring_expressions();
1803 // @@protoc_insertion_point(field_add_mutable:icing.lib.ScoringSpecProto.additional_advanced_scoring_expressions)
1804 return _s;
1805 }
_internal_additional_advanced_scoring_expressions(int index)1806 inline const std::string& ScoringSpecProto::_internal_additional_advanced_scoring_expressions(int index) const {
1807 return _impl_.additional_advanced_scoring_expressions_.Get(index);
1808 }
additional_advanced_scoring_expressions(int index)1809 inline const std::string& ScoringSpecProto::additional_advanced_scoring_expressions(int index) const {
1810 // @@protoc_insertion_point(field_get:icing.lib.ScoringSpecProto.additional_advanced_scoring_expressions)
1811 return _internal_additional_advanced_scoring_expressions(index);
1812 }
mutable_additional_advanced_scoring_expressions(int index)1813 inline std::string* ScoringSpecProto::mutable_additional_advanced_scoring_expressions(int index) {
1814 // @@protoc_insertion_point(field_mutable:icing.lib.ScoringSpecProto.additional_advanced_scoring_expressions)
1815 return _impl_.additional_advanced_scoring_expressions_.Mutable(index);
1816 }
set_additional_advanced_scoring_expressions(int index,const std::string & value)1817 inline void ScoringSpecProto::set_additional_advanced_scoring_expressions(int index, const std::string& value) {
1818 _impl_.additional_advanced_scoring_expressions_.Mutable(index)->assign(value);
1819 // @@protoc_insertion_point(field_set:icing.lib.ScoringSpecProto.additional_advanced_scoring_expressions)
1820 }
set_additional_advanced_scoring_expressions(int index,std::string && value)1821 inline void ScoringSpecProto::set_additional_advanced_scoring_expressions(int index, std::string&& value) {
1822 _impl_.additional_advanced_scoring_expressions_.Mutable(index)->assign(std::move(value));
1823 // @@protoc_insertion_point(field_set:icing.lib.ScoringSpecProto.additional_advanced_scoring_expressions)
1824 }
set_additional_advanced_scoring_expressions(int index,const char * value)1825 inline void ScoringSpecProto::set_additional_advanced_scoring_expressions(int index, const char* value) {
1826 GOOGLE_DCHECK(value != nullptr);
1827 _impl_.additional_advanced_scoring_expressions_.Mutable(index)->assign(value);
1828 // @@protoc_insertion_point(field_set_char:icing.lib.ScoringSpecProto.additional_advanced_scoring_expressions)
1829 }
set_additional_advanced_scoring_expressions(int index,const char * value,size_t size)1830 inline void ScoringSpecProto::set_additional_advanced_scoring_expressions(int index, const char* value, size_t size) {
1831 _impl_.additional_advanced_scoring_expressions_.Mutable(index)->assign(
1832 reinterpret_cast<const char*>(value), size);
1833 // @@protoc_insertion_point(field_set_pointer:icing.lib.ScoringSpecProto.additional_advanced_scoring_expressions)
1834 }
_internal_add_additional_advanced_scoring_expressions()1835 inline std::string* ScoringSpecProto::_internal_add_additional_advanced_scoring_expressions() {
1836 return _impl_.additional_advanced_scoring_expressions_.Add();
1837 }
add_additional_advanced_scoring_expressions(const std::string & value)1838 inline void ScoringSpecProto::add_additional_advanced_scoring_expressions(const std::string& value) {
1839 _impl_.additional_advanced_scoring_expressions_.Add()->assign(value);
1840 // @@protoc_insertion_point(field_add:icing.lib.ScoringSpecProto.additional_advanced_scoring_expressions)
1841 }
add_additional_advanced_scoring_expressions(std::string && value)1842 inline void ScoringSpecProto::add_additional_advanced_scoring_expressions(std::string&& value) {
1843 _impl_.additional_advanced_scoring_expressions_.Add(std::move(value));
1844 // @@protoc_insertion_point(field_add:icing.lib.ScoringSpecProto.additional_advanced_scoring_expressions)
1845 }
add_additional_advanced_scoring_expressions(const char * value)1846 inline void ScoringSpecProto::add_additional_advanced_scoring_expressions(const char* value) {
1847 GOOGLE_DCHECK(value != nullptr);
1848 _impl_.additional_advanced_scoring_expressions_.Add()->assign(value);
1849 // @@protoc_insertion_point(field_add_char:icing.lib.ScoringSpecProto.additional_advanced_scoring_expressions)
1850 }
add_additional_advanced_scoring_expressions(const char * value,size_t size)1851 inline void ScoringSpecProto::add_additional_advanced_scoring_expressions(const char* value, size_t size) {
1852 _impl_.additional_advanced_scoring_expressions_.Add()->assign(reinterpret_cast<const char*>(value), size);
1853 // @@protoc_insertion_point(field_add_pointer:icing.lib.ScoringSpecProto.additional_advanced_scoring_expressions)
1854 }
1855 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
additional_advanced_scoring_expressions()1856 ScoringSpecProto::additional_advanced_scoring_expressions() const {
1857 // @@protoc_insertion_point(field_list:icing.lib.ScoringSpecProto.additional_advanced_scoring_expressions)
1858 return _impl_.additional_advanced_scoring_expressions_;
1859 }
1860 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
mutable_additional_advanced_scoring_expressions()1861 ScoringSpecProto::mutable_additional_advanced_scoring_expressions() {
1862 // @@protoc_insertion_point(field_mutable_list:icing.lib.ScoringSpecProto.additional_advanced_scoring_expressions)
1863 return &_impl_.additional_advanced_scoring_expressions_;
1864 }
1865
1866 // repeated .icing.lib.SchemaTypeAliasMapProto schema_type_alias_map_protos = 6;
_internal_schema_type_alias_map_protos_size()1867 inline int ScoringSpecProto::_internal_schema_type_alias_map_protos_size() const {
1868 return _impl_.schema_type_alias_map_protos_.size();
1869 }
schema_type_alias_map_protos_size()1870 inline int ScoringSpecProto::schema_type_alias_map_protos_size() const {
1871 return _internal_schema_type_alias_map_protos_size();
1872 }
clear_schema_type_alias_map_protos()1873 inline void ScoringSpecProto::clear_schema_type_alias_map_protos() {
1874 _impl_.schema_type_alias_map_protos_.Clear();
1875 }
mutable_schema_type_alias_map_protos(int index)1876 inline ::icing::lib::SchemaTypeAliasMapProto* ScoringSpecProto::mutable_schema_type_alias_map_protos(int index) {
1877 // @@protoc_insertion_point(field_mutable:icing.lib.ScoringSpecProto.schema_type_alias_map_protos)
1878 return _impl_.schema_type_alias_map_protos_.Mutable(index);
1879 }
1880 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::SchemaTypeAliasMapProto >*
mutable_schema_type_alias_map_protos()1881 ScoringSpecProto::mutable_schema_type_alias_map_protos() {
1882 // @@protoc_insertion_point(field_mutable_list:icing.lib.ScoringSpecProto.schema_type_alias_map_protos)
1883 return &_impl_.schema_type_alias_map_protos_;
1884 }
_internal_schema_type_alias_map_protos(int index)1885 inline const ::icing::lib::SchemaTypeAliasMapProto& ScoringSpecProto::_internal_schema_type_alias_map_protos(int index) const {
1886 return _impl_.schema_type_alias_map_protos_.Get(index);
1887 }
schema_type_alias_map_protos(int index)1888 inline const ::icing::lib::SchemaTypeAliasMapProto& ScoringSpecProto::schema_type_alias_map_protos(int index) const {
1889 // @@protoc_insertion_point(field_get:icing.lib.ScoringSpecProto.schema_type_alias_map_protos)
1890 return _internal_schema_type_alias_map_protos(index);
1891 }
_internal_add_schema_type_alias_map_protos()1892 inline ::icing::lib::SchemaTypeAliasMapProto* ScoringSpecProto::_internal_add_schema_type_alias_map_protos() {
1893 return _impl_.schema_type_alias_map_protos_.Add();
1894 }
add_schema_type_alias_map_protos()1895 inline ::icing::lib::SchemaTypeAliasMapProto* ScoringSpecProto::add_schema_type_alias_map_protos() {
1896 ::icing::lib::SchemaTypeAliasMapProto* _add = _internal_add_schema_type_alias_map_protos();
1897 // @@protoc_insertion_point(field_add:icing.lib.ScoringSpecProto.schema_type_alias_map_protos)
1898 return _add;
1899 }
1900 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::SchemaTypeAliasMapProto >&
schema_type_alias_map_protos()1901 ScoringSpecProto::schema_type_alias_map_protos() const {
1902 // @@protoc_insertion_point(field_list:icing.lib.ScoringSpecProto.schema_type_alias_map_protos)
1903 return _impl_.schema_type_alias_map_protos_;
1904 }
1905
1906 // repeated .icing.lib.ScoringFeatureType scoring_feature_types_enabled = 7 [packed = true];
_internal_scoring_feature_types_enabled_size()1907 inline int ScoringSpecProto::_internal_scoring_feature_types_enabled_size() const {
1908 return _impl_.scoring_feature_types_enabled_.size();
1909 }
scoring_feature_types_enabled_size()1910 inline int ScoringSpecProto::scoring_feature_types_enabled_size() const {
1911 return _internal_scoring_feature_types_enabled_size();
1912 }
clear_scoring_feature_types_enabled()1913 inline void ScoringSpecProto::clear_scoring_feature_types_enabled() {
1914 _impl_.scoring_feature_types_enabled_.Clear();
1915 }
_internal_scoring_feature_types_enabled(int index)1916 inline ::icing::lib::ScoringFeatureType ScoringSpecProto::_internal_scoring_feature_types_enabled(int index) const {
1917 return static_cast< ::icing::lib::ScoringFeatureType >(_impl_.scoring_feature_types_enabled_.Get(index));
1918 }
scoring_feature_types_enabled(int index)1919 inline ::icing::lib::ScoringFeatureType ScoringSpecProto::scoring_feature_types_enabled(int index) const {
1920 // @@protoc_insertion_point(field_get:icing.lib.ScoringSpecProto.scoring_feature_types_enabled)
1921 return _internal_scoring_feature_types_enabled(index);
1922 }
set_scoring_feature_types_enabled(int index,::icing::lib::ScoringFeatureType value)1923 inline void ScoringSpecProto::set_scoring_feature_types_enabled(int index, ::icing::lib::ScoringFeatureType value) {
1924 assert(::icing::lib::ScoringFeatureType_IsValid(value));
1925 _impl_.scoring_feature_types_enabled_.Set(index, value);
1926 // @@protoc_insertion_point(field_set:icing.lib.ScoringSpecProto.scoring_feature_types_enabled)
1927 }
_internal_add_scoring_feature_types_enabled(::icing::lib::ScoringFeatureType value)1928 inline void ScoringSpecProto::_internal_add_scoring_feature_types_enabled(::icing::lib::ScoringFeatureType value) {
1929 assert(::icing::lib::ScoringFeatureType_IsValid(value));
1930 _impl_.scoring_feature_types_enabled_.Add(value);
1931 }
add_scoring_feature_types_enabled(::icing::lib::ScoringFeatureType value)1932 inline void ScoringSpecProto::add_scoring_feature_types_enabled(::icing::lib::ScoringFeatureType value) {
1933 _internal_add_scoring_feature_types_enabled(value);
1934 // @@protoc_insertion_point(field_add:icing.lib.ScoringSpecProto.scoring_feature_types_enabled)
1935 }
1936 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>&
scoring_feature_types_enabled()1937 ScoringSpecProto::scoring_feature_types_enabled() const {
1938 // @@protoc_insertion_point(field_list:icing.lib.ScoringSpecProto.scoring_feature_types_enabled)
1939 return _impl_.scoring_feature_types_enabled_;
1940 }
1941 inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
_internal_mutable_scoring_feature_types_enabled()1942 ScoringSpecProto::_internal_mutable_scoring_feature_types_enabled() {
1943 return &_impl_.scoring_feature_types_enabled_;
1944 }
1945 inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
mutable_scoring_feature_types_enabled()1946 ScoringSpecProto::mutable_scoring_feature_types_enabled() {
1947 // @@protoc_insertion_point(field_mutable_list:icing.lib.ScoringSpecProto.scoring_feature_types_enabled)
1948 return _internal_mutable_scoring_feature_types_enabled();
1949 }
1950
1951 // -------------------------------------------------------------------
1952
1953 // SuggestionScoringSpecProto_SuggestionRankingStrategy
1954
1955 // -------------------------------------------------------------------
1956
1957 // SuggestionScoringSpecProto
1958
1959 // optional .icing.lib.TermMatchType.Code scoring_match_type = 1;
_internal_has_scoring_match_type()1960 inline bool SuggestionScoringSpecProto::_internal_has_scoring_match_type() const {
1961 bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
1962 return value;
1963 }
has_scoring_match_type()1964 inline bool SuggestionScoringSpecProto::has_scoring_match_type() const {
1965 return _internal_has_scoring_match_type();
1966 }
clear_scoring_match_type()1967 inline void SuggestionScoringSpecProto::clear_scoring_match_type() {
1968 _impl_.scoring_match_type_ = 0;
1969 _impl_._has_bits_[0] &= ~0x00000001u;
1970 }
_internal_scoring_match_type()1971 inline ::icing::lib::TermMatchType_Code SuggestionScoringSpecProto::_internal_scoring_match_type() const {
1972 return static_cast< ::icing::lib::TermMatchType_Code >(_impl_.scoring_match_type_);
1973 }
scoring_match_type()1974 inline ::icing::lib::TermMatchType_Code SuggestionScoringSpecProto::scoring_match_type() const {
1975 // @@protoc_insertion_point(field_get:icing.lib.SuggestionScoringSpecProto.scoring_match_type)
1976 return _internal_scoring_match_type();
1977 }
_internal_set_scoring_match_type(::icing::lib::TermMatchType_Code value)1978 inline void SuggestionScoringSpecProto::_internal_set_scoring_match_type(::icing::lib::TermMatchType_Code value) {
1979 assert(::icing::lib::TermMatchType_Code_IsValid(value));
1980 _impl_._has_bits_[0] |= 0x00000001u;
1981 _impl_.scoring_match_type_ = value;
1982 }
set_scoring_match_type(::icing::lib::TermMatchType_Code value)1983 inline void SuggestionScoringSpecProto::set_scoring_match_type(::icing::lib::TermMatchType_Code value) {
1984 _internal_set_scoring_match_type(value);
1985 // @@protoc_insertion_point(field_set:icing.lib.SuggestionScoringSpecProto.scoring_match_type)
1986 }
1987
1988 // optional .icing.lib.SuggestionScoringSpecProto.SuggestionRankingStrategy.Code rank_by = 2;
_internal_has_rank_by()1989 inline bool SuggestionScoringSpecProto::_internal_has_rank_by() const {
1990 bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
1991 return value;
1992 }
has_rank_by()1993 inline bool SuggestionScoringSpecProto::has_rank_by() const {
1994 return _internal_has_rank_by();
1995 }
clear_rank_by()1996 inline void SuggestionScoringSpecProto::clear_rank_by() {
1997 _impl_.rank_by_ = 0;
1998 _impl_._has_bits_[0] &= ~0x00000002u;
1999 }
_internal_rank_by()2000 inline ::icing::lib::SuggestionScoringSpecProto_SuggestionRankingStrategy_Code SuggestionScoringSpecProto::_internal_rank_by() const {
2001 return static_cast< ::icing::lib::SuggestionScoringSpecProto_SuggestionRankingStrategy_Code >(_impl_.rank_by_);
2002 }
rank_by()2003 inline ::icing::lib::SuggestionScoringSpecProto_SuggestionRankingStrategy_Code SuggestionScoringSpecProto::rank_by() const {
2004 // @@protoc_insertion_point(field_get:icing.lib.SuggestionScoringSpecProto.rank_by)
2005 return _internal_rank_by();
2006 }
_internal_set_rank_by(::icing::lib::SuggestionScoringSpecProto_SuggestionRankingStrategy_Code value)2007 inline void SuggestionScoringSpecProto::_internal_set_rank_by(::icing::lib::SuggestionScoringSpecProto_SuggestionRankingStrategy_Code value) {
2008 assert(::icing::lib::SuggestionScoringSpecProto_SuggestionRankingStrategy_Code_IsValid(value));
2009 _impl_._has_bits_[0] |= 0x00000002u;
2010 _impl_.rank_by_ = value;
2011 }
set_rank_by(::icing::lib::SuggestionScoringSpecProto_SuggestionRankingStrategy_Code value)2012 inline void SuggestionScoringSpecProto::set_rank_by(::icing::lib::SuggestionScoringSpecProto_SuggestionRankingStrategy_Code value) {
2013 _internal_set_rank_by(value);
2014 // @@protoc_insertion_point(field_set:icing.lib.SuggestionScoringSpecProto.rank_by)
2015 }
2016
2017 // -------------------------------------------------------------------
2018
2019 // TypePropertyWeights
2020
2021 // optional string schema_type = 1;
_internal_has_schema_type()2022 inline bool TypePropertyWeights::_internal_has_schema_type() const {
2023 bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
2024 return value;
2025 }
has_schema_type()2026 inline bool TypePropertyWeights::has_schema_type() const {
2027 return _internal_has_schema_type();
2028 }
clear_schema_type()2029 inline void TypePropertyWeights::clear_schema_type() {
2030 _impl_.schema_type_.ClearToEmpty();
2031 _impl_._has_bits_[0] &= ~0x00000001u;
2032 }
schema_type()2033 inline const std::string& TypePropertyWeights::schema_type() const {
2034 // @@protoc_insertion_point(field_get:icing.lib.TypePropertyWeights.schema_type)
2035 return _internal_schema_type();
2036 }
2037 template <typename ArgT0, typename... ArgT>
2038 inline PROTOBUF_ALWAYS_INLINE
set_schema_type(ArgT0 && arg0,ArgT...args)2039 void TypePropertyWeights::set_schema_type(ArgT0&& arg0, ArgT... args) {
2040 _impl_._has_bits_[0] |= 0x00000001u;
2041 _impl_.schema_type_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
2042 // @@protoc_insertion_point(field_set:icing.lib.TypePropertyWeights.schema_type)
2043 }
mutable_schema_type()2044 inline std::string* TypePropertyWeights::mutable_schema_type() {
2045 std::string* _s = _internal_mutable_schema_type();
2046 // @@protoc_insertion_point(field_mutable:icing.lib.TypePropertyWeights.schema_type)
2047 return _s;
2048 }
_internal_schema_type()2049 inline const std::string& TypePropertyWeights::_internal_schema_type() const {
2050 return _impl_.schema_type_.Get();
2051 }
_internal_set_schema_type(const std::string & value)2052 inline void TypePropertyWeights::_internal_set_schema_type(const std::string& value) {
2053 _impl_._has_bits_[0] |= 0x00000001u;
2054 _impl_.schema_type_.Set(value, GetArenaForAllocation());
2055 }
_internal_mutable_schema_type()2056 inline std::string* TypePropertyWeights::_internal_mutable_schema_type() {
2057 _impl_._has_bits_[0] |= 0x00000001u;
2058 return _impl_.schema_type_.Mutable(GetArenaForAllocation());
2059 }
release_schema_type()2060 inline std::string* TypePropertyWeights::release_schema_type() {
2061 // @@protoc_insertion_point(field_release:icing.lib.TypePropertyWeights.schema_type)
2062 if (!_internal_has_schema_type()) {
2063 return nullptr;
2064 }
2065 _impl_._has_bits_[0] &= ~0x00000001u;
2066 auto* p = _impl_.schema_type_.Release();
2067 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2068 if (_impl_.schema_type_.IsDefault()) {
2069 _impl_.schema_type_.Set("", GetArenaForAllocation());
2070 }
2071 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2072 return p;
2073 }
set_allocated_schema_type(std::string * schema_type)2074 inline void TypePropertyWeights::set_allocated_schema_type(std::string* schema_type) {
2075 if (schema_type != nullptr) {
2076 _impl_._has_bits_[0] |= 0x00000001u;
2077 } else {
2078 _impl_._has_bits_[0] &= ~0x00000001u;
2079 }
2080 _impl_.schema_type_.SetAllocated(schema_type, GetArenaForAllocation());
2081 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2082 if (_impl_.schema_type_.IsDefault()) {
2083 _impl_.schema_type_.Set("", GetArenaForAllocation());
2084 }
2085 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2086 // @@protoc_insertion_point(field_set_allocated:icing.lib.TypePropertyWeights.schema_type)
2087 }
2088
2089 // repeated .icing.lib.PropertyWeight property_weights = 2;
_internal_property_weights_size()2090 inline int TypePropertyWeights::_internal_property_weights_size() const {
2091 return _impl_.property_weights_.size();
2092 }
property_weights_size()2093 inline int TypePropertyWeights::property_weights_size() const {
2094 return _internal_property_weights_size();
2095 }
clear_property_weights()2096 inline void TypePropertyWeights::clear_property_weights() {
2097 _impl_.property_weights_.Clear();
2098 }
mutable_property_weights(int index)2099 inline ::icing::lib::PropertyWeight* TypePropertyWeights::mutable_property_weights(int index) {
2100 // @@protoc_insertion_point(field_mutable:icing.lib.TypePropertyWeights.property_weights)
2101 return _impl_.property_weights_.Mutable(index);
2102 }
2103 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::PropertyWeight >*
mutable_property_weights()2104 TypePropertyWeights::mutable_property_weights() {
2105 // @@protoc_insertion_point(field_mutable_list:icing.lib.TypePropertyWeights.property_weights)
2106 return &_impl_.property_weights_;
2107 }
_internal_property_weights(int index)2108 inline const ::icing::lib::PropertyWeight& TypePropertyWeights::_internal_property_weights(int index) const {
2109 return _impl_.property_weights_.Get(index);
2110 }
property_weights(int index)2111 inline const ::icing::lib::PropertyWeight& TypePropertyWeights::property_weights(int index) const {
2112 // @@protoc_insertion_point(field_get:icing.lib.TypePropertyWeights.property_weights)
2113 return _internal_property_weights(index);
2114 }
_internal_add_property_weights()2115 inline ::icing::lib::PropertyWeight* TypePropertyWeights::_internal_add_property_weights() {
2116 return _impl_.property_weights_.Add();
2117 }
add_property_weights()2118 inline ::icing::lib::PropertyWeight* TypePropertyWeights::add_property_weights() {
2119 ::icing::lib::PropertyWeight* _add = _internal_add_property_weights();
2120 // @@protoc_insertion_point(field_add:icing.lib.TypePropertyWeights.property_weights)
2121 return _add;
2122 }
2123 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::PropertyWeight >&
property_weights()2124 TypePropertyWeights::property_weights() const {
2125 // @@protoc_insertion_point(field_list:icing.lib.TypePropertyWeights.property_weights)
2126 return _impl_.property_weights_;
2127 }
2128
2129 // -------------------------------------------------------------------
2130
2131 // PropertyWeight
2132
2133 // optional string path = 1;
_internal_has_path()2134 inline bool PropertyWeight::_internal_has_path() const {
2135 bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
2136 return value;
2137 }
has_path()2138 inline bool PropertyWeight::has_path() const {
2139 return _internal_has_path();
2140 }
clear_path()2141 inline void PropertyWeight::clear_path() {
2142 _impl_.path_.ClearToEmpty();
2143 _impl_._has_bits_[0] &= ~0x00000001u;
2144 }
path()2145 inline const std::string& PropertyWeight::path() const {
2146 // @@protoc_insertion_point(field_get:icing.lib.PropertyWeight.path)
2147 return _internal_path();
2148 }
2149 template <typename ArgT0, typename... ArgT>
2150 inline PROTOBUF_ALWAYS_INLINE
set_path(ArgT0 && arg0,ArgT...args)2151 void PropertyWeight::set_path(ArgT0&& arg0, ArgT... args) {
2152 _impl_._has_bits_[0] |= 0x00000001u;
2153 _impl_.path_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
2154 // @@protoc_insertion_point(field_set:icing.lib.PropertyWeight.path)
2155 }
mutable_path()2156 inline std::string* PropertyWeight::mutable_path() {
2157 std::string* _s = _internal_mutable_path();
2158 // @@protoc_insertion_point(field_mutable:icing.lib.PropertyWeight.path)
2159 return _s;
2160 }
_internal_path()2161 inline const std::string& PropertyWeight::_internal_path() const {
2162 return _impl_.path_.Get();
2163 }
_internal_set_path(const std::string & value)2164 inline void PropertyWeight::_internal_set_path(const std::string& value) {
2165 _impl_._has_bits_[0] |= 0x00000001u;
2166 _impl_.path_.Set(value, GetArenaForAllocation());
2167 }
_internal_mutable_path()2168 inline std::string* PropertyWeight::_internal_mutable_path() {
2169 _impl_._has_bits_[0] |= 0x00000001u;
2170 return _impl_.path_.Mutable(GetArenaForAllocation());
2171 }
release_path()2172 inline std::string* PropertyWeight::release_path() {
2173 // @@protoc_insertion_point(field_release:icing.lib.PropertyWeight.path)
2174 if (!_internal_has_path()) {
2175 return nullptr;
2176 }
2177 _impl_._has_bits_[0] &= ~0x00000001u;
2178 auto* p = _impl_.path_.Release();
2179 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2180 if (_impl_.path_.IsDefault()) {
2181 _impl_.path_.Set("", GetArenaForAllocation());
2182 }
2183 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2184 return p;
2185 }
set_allocated_path(std::string * path)2186 inline void PropertyWeight::set_allocated_path(std::string* path) {
2187 if (path != nullptr) {
2188 _impl_._has_bits_[0] |= 0x00000001u;
2189 } else {
2190 _impl_._has_bits_[0] &= ~0x00000001u;
2191 }
2192 _impl_.path_.SetAllocated(path, GetArenaForAllocation());
2193 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2194 if (_impl_.path_.IsDefault()) {
2195 _impl_.path_.Set("", GetArenaForAllocation());
2196 }
2197 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2198 // @@protoc_insertion_point(field_set_allocated:icing.lib.PropertyWeight.path)
2199 }
2200
2201 // optional double weight = 2;
_internal_has_weight()2202 inline bool PropertyWeight::_internal_has_weight() const {
2203 bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
2204 return value;
2205 }
has_weight()2206 inline bool PropertyWeight::has_weight() const {
2207 return _internal_has_weight();
2208 }
clear_weight()2209 inline void PropertyWeight::clear_weight() {
2210 _impl_.weight_ = 0;
2211 _impl_._has_bits_[0] &= ~0x00000002u;
2212 }
_internal_weight()2213 inline double PropertyWeight::_internal_weight() const {
2214 return _impl_.weight_;
2215 }
weight()2216 inline double PropertyWeight::weight() const {
2217 // @@protoc_insertion_point(field_get:icing.lib.PropertyWeight.weight)
2218 return _internal_weight();
2219 }
_internal_set_weight(double value)2220 inline void PropertyWeight::_internal_set_weight(double value) {
2221 _impl_._has_bits_[0] |= 0x00000002u;
2222 _impl_.weight_ = value;
2223 }
set_weight(double value)2224 inline void PropertyWeight::set_weight(double value) {
2225 _internal_set_weight(value);
2226 // @@protoc_insertion_point(field_set:icing.lib.PropertyWeight.weight)
2227 }
2228
2229 // -------------------------------------------------------------------
2230
2231 // SchemaTypeAliasMapProto
2232
2233 // optional string alias_schema_type = 1;
_internal_has_alias_schema_type()2234 inline bool SchemaTypeAliasMapProto::_internal_has_alias_schema_type() const {
2235 bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
2236 return value;
2237 }
has_alias_schema_type()2238 inline bool SchemaTypeAliasMapProto::has_alias_schema_type() const {
2239 return _internal_has_alias_schema_type();
2240 }
clear_alias_schema_type()2241 inline void SchemaTypeAliasMapProto::clear_alias_schema_type() {
2242 _impl_.alias_schema_type_.ClearToEmpty();
2243 _impl_._has_bits_[0] &= ~0x00000001u;
2244 }
alias_schema_type()2245 inline const std::string& SchemaTypeAliasMapProto::alias_schema_type() const {
2246 // @@protoc_insertion_point(field_get:icing.lib.SchemaTypeAliasMapProto.alias_schema_type)
2247 return _internal_alias_schema_type();
2248 }
2249 template <typename ArgT0, typename... ArgT>
2250 inline PROTOBUF_ALWAYS_INLINE
set_alias_schema_type(ArgT0 && arg0,ArgT...args)2251 void SchemaTypeAliasMapProto::set_alias_schema_type(ArgT0&& arg0, ArgT... args) {
2252 _impl_._has_bits_[0] |= 0x00000001u;
2253 _impl_.alias_schema_type_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
2254 // @@protoc_insertion_point(field_set:icing.lib.SchemaTypeAliasMapProto.alias_schema_type)
2255 }
mutable_alias_schema_type()2256 inline std::string* SchemaTypeAliasMapProto::mutable_alias_schema_type() {
2257 std::string* _s = _internal_mutable_alias_schema_type();
2258 // @@protoc_insertion_point(field_mutable:icing.lib.SchemaTypeAliasMapProto.alias_schema_type)
2259 return _s;
2260 }
_internal_alias_schema_type()2261 inline const std::string& SchemaTypeAliasMapProto::_internal_alias_schema_type() const {
2262 return _impl_.alias_schema_type_.Get();
2263 }
_internal_set_alias_schema_type(const std::string & value)2264 inline void SchemaTypeAliasMapProto::_internal_set_alias_schema_type(const std::string& value) {
2265 _impl_._has_bits_[0] |= 0x00000001u;
2266 _impl_.alias_schema_type_.Set(value, GetArenaForAllocation());
2267 }
_internal_mutable_alias_schema_type()2268 inline std::string* SchemaTypeAliasMapProto::_internal_mutable_alias_schema_type() {
2269 _impl_._has_bits_[0] |= 0x00000001u;
2270 return _impl_.alias_schema_type_.Mutable(GetArenaForAllocation());
2271 }
release_alias_schema_type()2272 inline std::string* SchemaTypeAliasMapProto::release_alias_schema_type() {
2273 // @@protoc_insertion_point(field_release:icing.lib.SchemaTypeAliasMapProto.alias_schema_type)
2274 if (!_internal_has_alias_schema_type()) {
2275 return nullptr;
2276 }
2277 _impl_._has_bits_[0] &= ~0x00000001u;
2278 auto* p = _impl_.alias_schema_type_.Release();
2279 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2280 if (_impl_.alias_schema_type_.IsDefault()) {
2281 _impl_.alias_schema_type_.Set("", GetArenaForAllocation());
2282 }
2283 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2284 return p;
2285 }
set_allocated_alias_schema_type(std::string * alias_schema_type)2286 inline void SchemaTypeAliasMapProto::set_allocated_alias_schema_type(std::string* alias_schema_type) {
2287 if (alias_schema_type != nullptr) {
2288 _impl_._has_bits_[0] |= 0x00000001u;
2289 } else {
2290 _impl_._has_bits_[0] &= ~0x00000001u;
2291 }
2292 _impl_.alias_schema_type_.SetAllocated(alias_schema_type, GetArenaForAllocation());
2293 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2294 if (_impl_.alias_schema_type_.IsDefault()) {
2295 _impl_.alias_schema_type_.Set("", GetArenaForAllocation());
2296 }
2297 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2298 // @@protoc_insertion_point(field_set_allocated:icing.lib.SchemaTypeAliasMapProto.alias_schema_type)
2299 }
2300
2301 // repeated string schema_types = 2;
_internal_schema_types_size()2302 inline int SchemaTypeAliasMapProto::_internal_schema_types_size() const {
2303 return _impl_.schema_types_.size();
2304 }
schema_types_size()2305 inline int SchemaTypeAliasMapProto::schema_types_size() const {
2306 return _internal_schema_types_size();
2307 }
clear_schema_types()2308 inline void SchemaTypeAliasMapProto::clear_schema_types() {
2309 _impl_.schema_types_.Clear();
2310 }
add_schema_types()2311 inline std::string* SchemaTypeAliasMapProto::add_schema_types() {
2312 std::string* _s = _internal_add_schema_types();
2313 // @@protoc_insertion_point(field_add_mutable:icing.lib.SchemaTypeAliasMapProto.schema_types)
2314 return _s;
2315 }
_internal_schema_types(int index)2316 inline const std::string& SchemaTypeAliasMapProto::_internal_schema_types(int index) const {
2317 return _impl_.schema_types_.Get(index);
2318 }
schema_types(int index)2319 inline const std::string& SchemaTypeAliasMapProto::schema_types(int index) const {
2320 // @@protoc_insertion_point(field_get:icing.lib.SchemaTypeAliasMapProto.schema_types)
2321 return _internal_schema_types(index);
2322 }
mutable_schema_types(int index)2323 inline std::string* SchemaTypeAliasMapProto::mutable_schema_types(int index) {
2324 // @@protoc_insertion_point(field_mutable:icing.lib.SchemaTypeAliasMapProto.schema_types)
2325 return _impl_.schema_types_.Mutable(index);
2326 }
set_schema_types(int index,const std::string & value)2327 inline void SchemaTypeAliasMapProto::set_schema_types(int index, const std::string& value) {
2328 _impl_.schema_types_.Mutable(index)->assign(value);
2329 // @@protoc_insertion_point(field_set:icing.lib.SchemaTypeAliasMapProto.schema_types)
2330 }
set_schema_types(int index,std::string && value)2331 inline void SchemaTypeAliasMapProto::set_schema_types(int index, std::string&& value) {
2332 _impl_.schema_types_.Mutable(index)->assign(std::move(value));
2333 // @@protoc_insertion_point(field_set:icing.lib.SchemaTypeAliasMapProto.schema_types)
2334 }
set_schema_types(int index,const char * value)2335 inline void SchemaTypeAliasMapProto::set_schema_types(int index, const char* value) {
2336 GOOGLE_DCHECK(value != nullptr);
2337 _impl_.schema_types_.Mutable(index)->assign(value);
2338 // @@protoc_insertion_point(field_set_char:icing.lib.SchemaTypeAliasMapProto.schema_types)
2339 }
set_schema_types(int index,const char * value,size_t size)2340 inline void SchemaTypeAliasMapProto::set_schema_types(int index, const char* value, size_t size) {
2341 _impl_.schema_types_.Mutable(index)->assign(
2342 reinterpret_cast<const char*>(value), size);
2343 // @@protoc_insertion_point(field_set_pointer:icing.lib.SchemaTypeAliasMapProto.schema_types)
2344 }
_internal_add_schema_types()2345 inline std::string* SchemaTypeAliasMapProto::_internal_add_schema_types() {
2346 return _impl_.schema_types_.Add();
2347 }
add_schema_types(const std::string & value)2348 inline void SchemaTypeAliasMapProto::add_schema_types(const std::string& value) {
2349 _impl_.schema_types_.Add()->assign(value);
2350 // @@protoc_insertion_point(field_add:icing.lib.SchemaTypeAliasMapProto.schema_types)
2351 }
add_schema_types(std::string && value)2352 inline void SchemaTypeAliasMapProto::add_schema_types(std::string&& value) {
2353 _impl_.schema_types_.Add(std::move(value));
2354 // @@protoc_insertion_point(field_add:icing.lib.SchemaTypeAliasMapProto.schema_types)
2355 }
add_schema_types(const char * value)2356 inline void SchemaTypeAliasMapProto::add_schema_types(const char* value) {
2357 GOOGLE_DCHECK(value != nullptr);
2358 _impl_.schema_types_.Add()->assign(value);
2359 // @@protoc_insertion_point(field_add_char:icing.lib.SchemaTypeAliasMapProto.schema_types)
2360 }
add_schema_types(const char * value,size_t size)2361 inline void SchemaTypeAliasMapProto::add_schema_types(const char* value, size_t size) {
2362 _impl_.schema_types_.Add()->assign(reinterpret_cast<const char*>(value), size);
2363 // @@protoc_insertion_point(field_add_pointer:icing.lib.SchemaTypeAliasMapProto.schema_types)
2364 }
2365 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
schema_types()2366 SchemaTypeAliasMapProto::schema_types() const {
2367 // @@protoc_insertion_point(field_list:icing.lib.SchemaTypeAliasMapProto.schema_types)
2368 return _impl_.schema_types_;
2369 }
2370 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
mutable_schema_types()2371 SchemaTypeAliasMapProto::mutable_schema_types() {
2372 // @@protoc_insertion_point(field_mutable_list:icing.lib.SchemaTypeAliasMapProto.schema_types)
2373 return &_impl_.schema_types_;
2374 }
2375
2376 #ifdef __GNUC__
2377 #pragma GCC diagnostic pop
2378 #endif // __GNUC__
2379 // -------------------------------------------------------------------
2380
2381 // -------------------------------------------------------------------
2382
2383 // -------------------------------------------------------------------
2384
2385 // -------------------------------------------------------------------
2386
2387 // -------------------------------------------------------------------
2388
2389 // -------------------------------------------------------------------
2390
2391 // -------------------------------------------------------------------
2392
2393
2394 // @@protoc_insertion_point(namespace_scope)
2395
2396 } // namespace lib
2397 } // namespace icing
2398
2399 PROTOBUF_NAMESPACE_OPEN
2400
2401 template <> struct is_proto_enum< ::icing::lib::ScoringSpecProto_RankingStrategy_Code> : ::std::true_type {};
2402 template <> struct is_proto_enum< ::icing::lib::ScoringSpecProto_Order_Code> : ::std::true_type {};
2403 template <> struct is_proto_enum< ::icing::lib::SuggestionScoringSpecProto_SuggestionRankingStrategy_Code> : ::std::true_type {};
2404 template <> struct is_proto_enum< ::icing::lib::ScoringFeatureType> : ::std::true_type {};
2405
2406 PROTOBUF_NAMESPACE_CLOSE
2407
2408 // @@protoc_insertion_point(global_scope)
2409
2410 #include <google/protobuf/port_undef.inc>
2411 #endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_icing_2fproto_2fscoring_2eproto
2412