1 // Generated by the protocol buffer compiler. DO NOT EDIT!
2 // source: icing/proto/search.proto
3
4 #ifndef GOOGLE_PROTOBUF_INCLUDED_icing_2fproto_2fsearch_2eproto
5 #define GOOGLE_PROTOBUF_INCLUDED_icing_2fproto_2fsearch_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/document.pb.h"
34 #include "icing/proto/logging.pb.h"
35 #include "icing/proto/scoring.pb.h"
36 #include "icing/proto/status.pb.h"
37 #include "icing/proto/term.pb.h"
38 // @@protoc_insertion_point(includes)
39 #include <google/protobuf/port_def.inc>
40 #define PROTOBUF_INTERNAL_EXPORT_icing_2fproto_2fsearch_2eproto
41 PROTOBUF_NAMESPACE_OPEN
42 namespace internal {
43 class AnyMetadata;
44 } // namespace internal
45 PROTOBUF_NAMESPACE_CLOSE
46
47 // Internal implementation detail -- do not use these members.
48 struct TableStruct_icing_2fproto_2fsearch_2eproto {
49 static const ::uint32_t offsets[];
50 };
51 namespace icing {
52 namespace lib {
53 class GetResultSpecProto;
54 struct GetResultSpecProtoDefaultTypeInternal;
55 extern GetResultSpecProtoDefaultTypeInternal _GetResultSpecProto_default_instance_;
56 class JoinSpecProto;
57 struct JoinSpecProtoDefaultTypeInternal;
58 extern JoinSpecProtoDefaultTypeInternal _JoinSpecProto_default_instance_;
59 class JoinSpecProto_AggregationScoringStrategy;
60 struct JoinSpecProto_AggregationScoringStrategyDefaultTypeInternal;
61 extern JoinSpecProto_AggregationScoringStrategyDefaultTypeInternal _JoinSpecProto_AggregationScoringStrategy_default_instance_;
62 class JoinSpecProto_NestedSpecProto;
63 struct JoinSpecProto_NestedSpecProtoDefaultTypeInternal;
64 extern JoinSpecProto_NestedSpecProtoDefaultTypeInternal _JoinSpecProto_NestedSpecProto_default_instance_;
65 class NamespaceDocumentUriGroup;
66 struct NamespaceDocumentUriGroupDefaultTypeInternal;
67 extern NamespaceDocumentUriGroupDefaultTypeInternal _NamespaceDocumentUriGroup_default_instance_;
68 class ResultSpecProto;
69 struct ResultSpecProtoDefaultTypeInternal;
70 extern ResultSpecProtoDefaultTypeInternal _ResultSpecProto_default_instance_;
71 class ResultSpecProto_ResultGrouping;
72 struct ResultSpecProto_ResultGroupingDefaultTypeInternal;
73 extern ResultSpecProto_ResultGroupingDefaultTypeInternal _ResultSpecProto_ResultGrouping_default_instance_;
74 class ResultSpecProto_ResultGrouping_Entry;
75 struct ResultSpecProto_ResultGrouping_EntryDefaultTypeInternal;
76 extern ResultSpecProto_ResultGrouping_EntryDefaultTypeInternal _ResultSpecProto_ResultGrouping_Entry_default_instance_;
77 class ResultSpecProto_SnippetSpecProto;
78 struct ResultSpecProto_SnippetSpecProtoDefaultTypeInternal;
79 extern ResultSpecProto_SnippetSpecProtoDefaultTypeInternal _ResultSpecProto_SnippetSpecProto_default_instance_;
80 class SearchResultProto;
81 struct SearchResultProtoDefaultTypeInternal;
82 extern SearchResultProtoDefaultTypeInternal _SearchResultProto_default_instance_;
83 class SearchResultProto_DebugInfoProto;
84 struct SearchResultProto_DebugInfoProtoDefaultTypeInternal;
85 extern SearchResultProto_DebugInfoProtoDefaultTypeInternal _SearchResultProto_DebugInfoProto_default_instance_;
86 class SearchResultProto_ResultProto;
87 struct SearchResultProto_ResultProtoDefaultTypeInternal;
88 extern SearchResultProto_ResultProtoDefaultTypeInternal _SearchResultProto_ResultProto_default_instance_;
89 class SearchSpecProto;
90 struct SearchSpecProtoDefaultTypeInternal;
91 extern SearchSpecProtoDefaultTypeInternal _SearchSpecProto_default_instance_;
92 class SearchSpecProto_EmbeddingQueryMetricType;
93 struct SearchSpecProto_EmbeddingQueryMetricTypeDefaultTypeInternal;
94 extern SearchSpecProto_EmbeddingQueryMetricTypeDefaultTypeInternal _SearchSpecProto_EmbeddingQueryMetricType_default_instance_;
95 class SnippetMatchProto;
96 struct SnippetMatchProtoDefaultTypeInternal;
97 extern SnippetMatchProtoDefaultTypeInternal _SnippetMatchProto_default_instance_;
98 class SnippetProto;
99 struct SnippetProtoDefaultTypeInternal;
100 extern SnippetProtoDefaultTypeInternal _SnippetProto_default_instance_;
101 class SnippetProto_EntryProto;
102 struct SnippetProto_EntryProtoDefaultTypeInternal;
103 extern SnippetProto_EntryProtoDefaultTypeInternal _SnippetProto_EntryProto_default_instance_;
104 class SuggestionResponse;
105 struct SuggestionResponseDefaultTypeInternal;
106 extern SuggestionResponseDefaultTypeInternal _SuggestionResponse_default_instance_;
107 class SuggestionResponse_Suggestion;
108 struct SuggestionResponse_SuggestionDefaultTypeInternal;
109 extern SuggestionResponse_SuggestionDefaultTypeInternal _SuggestionResponse_Suggestion_default_instance_;
110 class SuggestionSpecProto;
111 struct SuggestionSpecProtoDefaultTypeInternal;
112 extern SuggestionSpecProtoDefaultTypeInternal _SuggestionSpecProto_default_instance_;
113 class TypePropertyMask;
114 struct TypePropertyMaskDefaultTypeInternal;
115 extern TypePropertyMaskDefaultTypeInternal _TypePropertyMask_default_instance_;
116 } // namespace lib
117 } // namespace icing
118 PROTOBUF_NAMESPACE_OPEN
119 template<> ::icing::lib::GetResultSpecProto* Arena::CreateMaybeMessage<::icing::lib::GetResultSpecProto>(Arena*);
120 template<> ::icing::lib::JoinSpecProto* Arena::CreateMaybeMessage<::icing::lib::JoinSpecProto>(Arena*);
121 template<> ::icing::lib::JoinSpecProto_AggregationScoringStrategy* Arena::CreateMaybeMessage<::icing::lib::JoinSpecProto_AggregationScoringStrategy>(Arena*);
122 template<> ::icing::lib::JoinSpecProto_NestedSpecProto* Arena::CreateMaybeMessage<::icing::lib::JoinSpecProto_NestedSpecProto>(Arena*);
123 template<> ::icing::lib::NamespaceDocumentUriGroup* Arena::CreateMaybeMessage<::icing::lib::NamespaceDocumentUriGroup>(Arena*);
124 template<> ::icing::lib::ResultSpecProto* Arena::CreateMaybeMessage<::icing::lib::ResultSpecProto>(Arena*);
125 template<> ::icing::lib::ResultSpecProto_ResultGrouping* Arena::CreateMaybeMessage<::icing::lib::ResultSpecProto_ResultGrouping>(Arena*);
126 template<> ::icing::lib::ResultSpecProto_ResultGrouping_Entry* Arena::CreateMaybeMessage<::icing::lib::ResultSpecProto_ResultGrouping_Entry>(Arena*);
127 template<> ::icing::lib::ResultSpecProto_SnippetSpecProto* Arena::CreateMaybeMessage<::icing::lib::ResultSpecProto_SnippetSpecProto>(Arena*);
128 template<> ::icing::lib::SearchResultProto* Arena::CreateMaybeMessage<::icing::lib::SearchResultProto>(Arena*);
129 template<> ::icing::lib::SearchResultProto_DebugInfoProto* Arena::CreateMaybeMessage<::icing::lib::SearchResultProto_DebugInfoProto>(Arena*);
130 template<> ::icing::lib::SearchResultProto_ResultProto* Arena::CreateMaybeMessage<::icing::lib::SearchResultProto_ResultProto>(Arena*);
131 template<> ::icing::lib::SearchSpecProto* Arena::CreateMaybeMessage<::icing::lib::SearchSpecProto>(Arena*);
132 template<> ::icing::lib::SearchSpecProto_EmbeddingQueryMetricType* Arena::CreateMaybeMessage<::icing::lib::SearchSpecProto_EmbeddingQueryMetricType>(Arena*);
133 template<> ::icing::lib::SnippetMatchProto* Arena::CreateMaybeMessage<::icing::lib::SnippetMatchProto>(Arena*);
134 template<> ::icing::lib::SnippetProto* Arena::CreateMaybeMessage<::icing::lib::SnippetProto>(Arena*);
135 template<> ::icing::lib::SnippetProto_EntryProto* Arena::CreateMaybeMessage<::icing::lib::SnippetProto_EntryProto>(Arena*);
136 template<> ::icing::lib::SuggestionResponse* Arena::CreateMaybeMessage<::icing::lib::SuggestionResponse>(Arena*);
137 template<> ::icing::lib::SuggestionResponse_Suggestion* Arena::CreateMaybeMessage<::icing::lib::SuggestionResponse_Suggestion>(Arena*);
138 template<> ::icing::lib::SuggestionSpecProto* Arena::CreateMaybeMessage<::icing::lib::SuggestionSpecProto>(Arena*);
139 template<> ::icing::lib::TypePropertyMask* Arena::CreateMaybeMessage<::icing::lib::TypePropertyMask>(Arena*);
140 PROTOBUF_NAMESPACE_CLOSE
141 namespace icing {
142 namespace lib {
143
144 enum SearchSpecProto_EmbeddingQueryMetricType_Code : int {
145 SearchSpecProto_EmbeddingQueryMetricType_Code_UNKNOWN = 0,
146 SearchSpecProto_EmbeddingQueryMetricType_Code_COSINE = 1,
147 SearchSpecProto_EmbeddingQueryMetricType_Code_DOT_PRODUCT = 2,
148 SearchSpecProto_EmbeddingQueryMetricType_Code_EUCLIDEAN = 3
149 };
150 bool SearchSpecProto_EmbeddingQueryMetricType_Code_IsValid(int value);
151 constexpr SearchSpecProto_EmbeddingQueryMetricType_Code SearchSpecProto_EmbeddingQueryMetricType_Code_Code_MIN = SearchSpecProto_EmbeddingQueryMetricType_Code_UNKNOWN;
152 constexpr SearchSpecProto_EmbeddingQueryMetricType_Code SearchSpecProto_EmbeddingQueryMetricType_Code_Code_MAX = SearchSpecProto_EmbeddingQueryMetricType_Code_EUCLIDEAN;
153 constexpr int SearchSpecProto_EmbeddingQueryMetricType_Code_Code_ARRAYSIZE = SearchSpecProto_EmbeddingQueryMetricType_Code_Code_MAX + 1;
154
155 const std::string& SearchSpecProto_EmbeddingQueryMetricType_Code_Name(SearchSpecProto_EmbeddingQueryMetricType_Code value);
156 template<typename T>
SearchSpecProto_EmbeddingQueryMetricType_Code_Name(T enum_t_value)157 inline const std::string& SearchSpecProto_EmbeddingQueryMetricType_Code_Name(T enum_t_value) {
158 static_assert(::std::is_same<T, SearchSpecProto_EmbeddingQueryMetricType_Code>::value ||
159 ::std::is_integral<T>::value,
160 "Incorrect type passed to function SearchSpecProto_EmbeddingQueryMetricType_Code_Name.");
161 return SearchSpecProto_EmbeddingQueryMetricType_Code_Name(static_cast<SearchSpecProto_EmbeddingQueryMetricType_Code>(enum_t_value));
162 }
163 bool SearchSpecProto_EmbeddingQueryMetricType_Code_Parse(
164 ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SearchSpecProto_EmbeddingQueryMetricType_Code* value);
165 enum ResultSpecProto_ResultGroupingType : int {
166 ResultSpecProto_ResultGroupingType_NONE = 0,
167 ResultSpecProto_ResultGroupingType_SCHEMA_TYPE = 1,
168 ResultSpecProto_ResultGroupingType_NAMESPACE = 2,
169 ResultSpecProto_ResultGroupingType_NAMESPACE_AND_SCHEMA_TYPE = 3
170 };
171 bool ResultSpecProto_ResultGroupingType_IsValid(int value);
172 constexpr ResultSpecProto_ResultGroupingType ResultSpecProto_ResultGroupingType_ResultGroupingType_MIN = ResultSpecProto_ResultGroupingType_NONE;
173 constexpr ResultSpecProto_ResultGroupingType ResultSpecProto_ResultGroupingType_ResultGroupingType_MAX = ResultSpecProto_ResultGroupingType_NAMESPACE_AND_SCHEMA_TYPE;
174 constexpr int ResultSpecProto_ResultGroupingType_ResultGroupingType_ARRAYSIZE = ResultSpecProto_ResultGroupingType_ResultGroupingType_MAX + 1;
175
176 const std::string& ResultSpecProto_ResultGroupingType_Name(ResultSpecProto_ResultGroupingType value);
177 template<typename T>
ResultSpecProto_ResultGroupingType_Name(T enum_t_value)178 inline const std::string& ResultSpecProto_ResultGroupingType_Name(T enum_t_value) {
179 static_assert(::std::is_same<T, ResultSpecProto_ResultGroupingType>::value ||
180 ::std::is_integral<T>::value,
181 "Incorrect type passed to function ResultSpecProto_ResultGroupingType_Name.");
182 return ResultSpecProto_ResultGroupingType_Name(static_cast<ResultSpecProto_ResultGroupingType>(enum_t_value));
183 }
184 bool ResultSpecProto_ResultGroupingType_Parse(
185 ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ResultSpecProto_ResultGroupingType* value);
186 enum JoinSpecProto_AggregationScoringStrategy_Code : int {
187 JoinSpecProto_AggregationScoringStrategy_Code_NONE = 0,
188 JoinSpecProto_AggregationScoringStrategy_Code_COUNT = 1,
189 JoinSpecProto_AggregationScoringStrategy_Code_MIN = 2,
190 JoinSpecProto_AggregationScoringStrategy_Code_AVG = 3,
191 JoinSpecProto_AggregationScoringStrategy_Code_MAX = 4,
192 JoinSpecProto_AggregationScoringStrategy_Code_SUM = 5
193 };
194 bool JoinSpecProto_AggregationScoringStrategy_Code_IsValid(int value);
195 constexpr JoinSpecProto_AggregationScoringStrategy_Code JoinSpecProto_AggregationScoringStrategy_Code_Code_MIN = JoinSpecProto_AggregationScoringStrategy_Code_NONE;
196 constexpr JoinSpecProto_AggregationScoringStrategy_Code JoinSpecProto_AggregationScoringStrategy_Code_Code_MAX = JoinSpecProto_AggregationScoringStrategy_Code_SUM;
197 constexpr int JoinSpecProto_AggregationScoringStrategy_Code_Code_ARRAYSIZE = JoinSpecProto_AggregationScoringStrategy_Code_Code_MAX + 1;
198
199 const std::string& JoinSpecProto_AggregationScoringStrategy_Code_Name(JoinSpecProto_AggregationScoringStrategy_Code value);
200 template<typename T>
JoinSpecProto_AggregationScoringStrategy_Code_Name(T enum_t_value)201 inline const std::string& JoinSpecProto_AggregationScoringStrategy_Code_Name(T enum_t_value) {
202 static_assert(::std::is_same<T, JoinSpecProto_AggregationScoringStrategy_Code>::value ||
203 ::std::is_integral<T>::value,
204 "Incorrect type passed to function JoinSpecProto_AggregationScoringStrategy_Code_Name.");
205 return JoinSpecProto_AggregationScoringStrategy_Code_Name(static_cast<JoinSpecProto_AggregationScoringStrategy_Code>(enum_t_value));
206 }
207 bool JoinSpecProto_AggregationScoringStrategy_Code_Parse(
208 ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, JoinSpecProto_AggregationScoringStrategy_Code* value);
209 // ===================================================================
210
211 class SearchSpecProto_EmbeddingQueryMetricType final :
212 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:icing.lib.SearchSpecProto.EmbeddingQueryMetricType) */ {
213 public:
SearchSpecProto_EmbeddingQueryMetricType()214 inline SearchSpecProto_EmbeddingQueryMetricType() : SearchSpecProto_EmbeddingQueryMetricType(nullptr) {}
215 ~SearchSpecProto_EmbeddingQueryMetricType() override;
216 explicit PROTOBUF_CONSTEXPR SearchSpecProto_EmbeddingQueryMetricType(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
217
218 SearchSpecProto_EmbeddingQueryMetricType(const SearchSpecProto_EmbeddingQueryMetricType& from);
SearchSpecProto_EmbeddingQueryMetricType(SearchSpecProto_EmbeddingQueryMetricType && from)219 SearchSpecProto_EmbeddingQueryMetricType(SearchSpecProto_EmbeddingQueryMetricType&& from) noexcept
220 : SearchSpecProto_EmbeddingQueryMetricType() {
221 *this = ::std::move(from);
222 }
223
224 inline SearchSpecProto_EmbeddingQueryMetricType& operator=(const SearchSpecProto_EmbeddingQueryMetricType& from) {
225 if (this == &from) return *this;
226 CopyFrom(from);
227 return *this;
228 }
229 inline SearchSpecProto_EmbeddingQueryMetricType& operator=(SearchSpecProto_EmbeddingQueryMetricType&& from) noexcept {
230 if (this == &from) return *this;
231 if (GetOwningArena() == from.GetOwningArena()
232 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
233 && GetOwningArena() != nullptr
234 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
235 ) {
236 InternalSwap(&from);
237 } else {
238 CopyFrom(from);
239 }
240 return *this;
241 }
242
unknown_fields()243 inline const std::string& unknown_fields() const {
244 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
245 }
mutable_unknown_fields()246 inline std::string* mutable_unknown_fields() {
247 return _internal_metadata_.mutable_unknown_fields<std::string>();
248 }
249
default_instance()250 static const SearchSpecProto_EmbeddingQueryMetricType& default_instance() {
251 return *internal_default_instance();
252 }
internal_default_instance()253 static inline const SearchSpecProto_EmbeddingQueryMetricType* internal_default_instance() {
254 return reinterpret_cast<const SearchSpecProto_EmbeddingQueryMetricType*>(
255 &_SearchSpecProto_EmbeddingQueryMetricType_default_instance_);
256 }
257 static constexpr int kIndexInFileMessages =
258 0;
259
swap(SearchSpecProto_EmbeddingQueryMetricType & a,SearchSpecProto_EmbeddingQueryMetricType & b)260 friend void swap(SearchSpecProto_EmbeddingQueryMetricType& a, SearchSpecProto_EmbeddingQueryMetricType& b) {
261 a.Swap(&b);
262 }
Swap(SearchSpecProto_EmbeddingQueryMetricType * other)263 inline void Swap(SearchSpecProto_EmbeddingQueryMetricType* other) {
264 if (other == this) return;
265 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
266 if (GetOwningArena() != nullptr &&
267 GetOwningArena() == other->GetOwningArena()) {
268 #else // PROTOBUF_FORCE_COPY_IN_SWAP
269 if (GetOwningArena() == other->GetOwningArena()) {
270 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
271 InternalSwap(other);
272 } else {
273 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
274 }
275 }
276 void UnsafeArenaSwap(SearchSpecProto_EmbeddingQueryMetricType* other) {
277 if (other == this) return;
278 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
279 InternalSwap(other);
280 }
281
282 // implements Message ----------------------------------------------
283
284 SearchSpecProto_EmbeddingQueryMetricType* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
285 return CreateMaybeMessage<SearchSpecProto_EmbeddingQueryMetricType>(arena);
286 }
287 SearchSpecProto_EmbeddingQueryMetricType* New() const {
288 return New(nullptr);
289 }
290 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
291 void CopyFrom(const SearchSpecProto_EmbeddingQueryMetricType& from);
292 void MergeFrom(const SearchSpecProto_EmbeddingQueryMetricType& from);
293 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
294 bool IsInitialized() const final;
295
296 size_t ByteSizeLong() const final;
297 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
298 ::uint8_t* _InternalSerialize(
299 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
300 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
301
302 private:
303 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
304 void SharedDtor();
305 void SetCachedSize(int size) const;
306 void InternalSwap(SearchSpecProto_EmbeddingQueryMetricType* other);
307
308 private:
309 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
310 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
311 return "icing.lib.SearchSpecProto.EmbeddingQueryMetricType";
312 }
313 protected:
314 explicit SearchSpecProto_EmbeddingQueryMetricType(::PROTOBUF_NAMESPACE_ID::Arena* arena,
315 bool is_message_owned = false);
316 public:
317
318 std::string GetTypeName() const final;
319
320 // nested types ----------------------------------------------------
321
322 typedef SearchSpecProto_EmbeddingQueryMetricType_Code Code;
323 static constexpr Code UNKNOWN =
324 SearchSpecProto_EmbeddingQueryMetricType_Code_UNKNOWN;
325 static constexpr Code COSINE =
326 SearchSpecProto_EmbeddingQueryMetricType_Code_COSINE;
327 static constexpr Code DOT_PRODUCT =
328 SearchSpecProto_EmbeddingQueryMetricType_Code_DOT_PRODUCT;
329 static constexpr Code EUCLIDEAN =
330 SearchSpecProto_EmbeddingQueryMetricType_Code_EUCLIDEAN;
331 static inline bool Code_IsValid(int value) {
332 return SearchSpecProto_EmbeddingQueryMetricType_Code_IsValid(value);
333 }
334 static constexpr Code Code_MIN =
335 SearchSpecProto_EmbeddingQueryMetricType_Code_Code_MIN;
336 static constexpr Code Code_MAX =
337 SearchSpecProto_EmbeddingQueryMetricType_Code_Code_MAX;
338 static constexpr int Code_ARRAYSIZE =
339 SearchSpecProto_EmbeddingQueryMetricType_Code_Code_ARRAYSIZE;
340 template<typename T>
341 static inline const std::string& Code_Name(T enum_t_value) {
342 static_assert(::std::is_same<T, Code>::value ||
343 ::std::is_integral<T>::value,
344 "Incorrect type passed to function Code_Name.");
345 return SearchSpecProto_EmbeddingQueryMetricType_Code_Name(enum_t_value);
346 }
347 static inline bool Code_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
348 Code* value) {
349 return SearchSpecProto_EmbeddingQueryMetricType_Code_Parse(name, value);
350 }
351
352 // accessors -------------------------------------------------------
353
354 // @@protoc_insertion_point(class_scope:icing.lib.SearchSpecProto.EmbeddingQueryMetricType)
355 private:
356 class _Internal;
357
358 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
359 typedef void InternalArenaConstructable_;
360 typedef void DestructorSkippable_;
361 struct Impl_ {
362 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
363 };
364 union { Impl_ _impl_; };
365 friend struct ::TableStruct_icing_2fproto_2fsearch_2eproto;
366 };
367 // -------------------------------------------------------------------
368
369 class SearchSpecProto final :
370 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:icing.lib.SearchSpecProto) */ {
371 public:
SearchSpecProto()372 inline SearchSpecProto() : SearchSpecProto(nullptr) {}
373 ~SearchSpecProto() override;
374 explicit PROTOBUF_CONSTEXPR SearchSpecProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
375
376 SearchSpecProto(const SearchSpecProto& from);
SearchSpecProto(SearchSpecProto && from)377 SearchSpecProto(SearchSpecProto&& from) noexcept
378 : SearchSpecProto() {
379 *this = ::std::move(from);
380 }
381
382 inline SearchSpecProto& operator=(const SearchSpecProto& from) {
383 if (this == &from) return *this;
384 CopyFrom(from);
385 return *this;
386 }
387 inline SearchSpecProto& operator=(SearchSpecProto&& from) noexcept {
388 if (this == &from) return *this;
389 if (GetOwningArena() == from.GetOwningArena()
390 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
391 && GetOwningArena() != nullptr
392 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
393 ) {
394 InternalSwap(&from);
395 } else {
396 CopyFrom(from);
397 }
398 return *this;
399 }
400
unknown_fields()401 inline const std::string& unknown_fields() const {
402 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
403 }
mutable_unknown_fields()404 inline std::string* mutable_unknown_fields() {
405 return _internal_metadata_.mutable_unknown_fields<std::string>();
406 }
407
default_instance()408 static const SearchSpecProto& default_instance() {
409 return *internal_default_instance();
410 }
internal_default_instance()411 static inline const SearchSpecProto* internal_default_instance() {
412 return reinterpret_cast<const SearchSpecProto*>(
413 &_SearchSpecProto_default_instance_);
414 }
415 static constexpr int kIndexInFileMessages =
416 1;
417
swap(SearchSpecProto & a,SearchSpecProto & b)418 friend void swap(SearchSpecProto& a, SearchSpecProto& b) {
419 a.Swap(&b);
420 }
Swap(SearchSpecProto * other)421 inline void Swap(SearchSpecProto* other) {
422 if (other == this) return;
423 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
424 if (GetOwningArena() != nullptr &&
425 GetOwningArena() == other->GetOwningArena()) {
426 #else // PROTOBUF_FORCE_COPY_IN_SWAP
427 if (GetOwningArena() == other->GetOwningArena()) {
428 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
429 InternalSwap(other);
430 } else {
431 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
432 }
433 }
434 void UnsafeArenaSwap(SearchSpecProto* other) {
435 if (other == this) return;
436 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
437 InternalSwap(other);
438 }
439
440 // implements Message ----------------------------------------------
441
442 SearchSpecProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
443 return CreateMaybeMessage<SearchSpecProto>(arena);
444 }
445 SearchSpecProto* New() const {
446 return New(nullptr);
447 }
448 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
449 void CopyFrom(const SearchSpecProto& from);
450 void MergeFrom(const SearchSpecProto& from);
451 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
452 bool IsInitialized() const final;
453
454 size_t ByteSizeLong() const final;
455 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
456 ::uint8_t* _InternalSerialize(
457 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
458 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
459
460 private:
461 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
462 void SharedDtor();
463 void SetCachedSize(int size) const;
464 void InternalSwap(SearchSpecProto* other);
465
466 private:
467 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
468 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
469 return "icing.lib.SearchSpecProto";
470 }
471 protected:
472 explicit SearchSpecProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
473 bool is_message_owned = false);
474 public:
475
476 std::string GetTypeName() const final;
477
478 // nested types ----------------------------------------------------
479
480 typedef SearchSpecProto_EmbeddingQueryMetricType EmbeddingQueryMetricType;
481
482 // accessors -------------------------------------------------------
483
484 enum : int {
485 kNamespaceFiltersFieldNumber = 3,
486 kSchemaTypeFiltersFieldNumber = 4,
487 kEnabledFeaturesFieldNumber = 8,
488 kTypePropertyFiltersFieldNumber = 10,
489 kEmbeddingQueryVectorsFieldNumber = 11,
490 kQueryParameterStringsFieldNumber = 13,
491 kDocumentUriFiltersFieldNumber = 14,
492 kQueryFieldNumber = 1,
493 kJoinSpecFieldNumber = 7,
494 kJavaToNativeStartTimestampMsFieldNumber = 5,
495 kTermMatchTypeFieldNumber = 2,
496 kEmbeddingQueryMetricTypeFieldNumber = 12,
497 kUseReadOnlySearchFieldNumber = 9,
498 };
499 // repeated string namespace_filters = 3;
500 int namespace_filters_size() const;
501 private:
502 int _internal_namespace_filters_size() const;
503 public:
504 void clear_namespace_filters();
505 const std::string& namespace_filters(int index) const;
506 std::string* mutable_namespace_filters(int index);
507 void set_namespace_filters(int index, const std::string& value);
508 void set_namespace_filters(int index, std::string&& value);
509 void set_namespace_filters(int index, const char* value);
510 void set_namespace_filters(int index, const char* value, size_t size);
511 std::string* add_namespace_filters();
512 void add_namespace_filters(const std::string& value);
513 void add_namespace_filters(std::string&& value);
514 void add_namespace_filters(const char* value);
515 void add_namespace_filters(const char* value, size_t size);
516 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& namespace_filters() const;
517 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_namespace_filters();
518 private:
519 const std::string& _internal_namespace_filters(int index) const;
520 std::string* _internal_add_namespace_filters();
521 public:
522
523 // repeated string schema_type_filters = 4;
524 int schema_type_filters_size() const;
525 private:
526 int _internal_schema_type_filters_size() const;
527 public:
528 void clear_schema_type_filters();
529 const std::string& schema_type_filters(int index) const;
530 std::string* mutable_schema_type_filters(int index);
531 void set_schema_type_filters(int index, const std::string& value);
532 void set_schema_type_filters(int index, std::string&& value);
533 void set_schema_type_filters(int index, const char* value);
534 void set_schema_type_filters(int index, const char* value, size_t size);
535 std::string* add_schema_type_filters();
536 void add_schema_type_filters(const std::string& value);
537 void add_schema_type_filters(std::string&& value);
538 void add_schema_type_filters(const char* value);
539 void add_schema_type_filters(const char* value, size_t size);
540 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& schema_type_filters() const;
541 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_schema_type_filters();
542 private:
543 const std::string& _internal_schema_type_filters(int index) const;
544 std::string* _internal_add_schema_type_filters();
545 public:
546
547 // repeated string enabled_features = 8;
548 int enabled_features_size() const;
549 private:
550 int _internal_enabled_features_size() const;
551 public:
552 void clear_enabled_features();
553 const std::string& enabled_features(int index) const;
554 std::string* mutable_enabled_features(int index);
555 void set_enabled_features(int index, const std::string& value);
556 void set_enabled_features(int index, std::string&& value);
557 void set_enabled_features(int index, const char* value);
558 void set_enabled_features(int index, const char* value, size_t size);
559 std::string* add_enabled_features();
560 void add_enabled_features(const std::string& value);
561 void add_enabled_features(std::string&& value);
562 void add_enabled_features(const char* value);
563 void add_enabled_features(const char* value, size_t size);
564 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& enabled_features() const;
565 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_enabled_features();
566 private:
567 const std::string& _internal_enabled_features(int index) const;
568 std::string* _internal_add_enabled_features();
569 public:
570
571 // repeated .icing.lib.TypePropertyMask type_property_filters = 10;
572 int type_property_filters_size() const;
573 private:
574 int _internal_type_property_filters_size() const;
575 public:
576 void clear_type_property_filters();
577 ::icing::lib::TypePropertyMask* mutable_type_property_filters(int index);
578 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::TypePropertyMask >*
579 mutable_type_property_filters();
580 private:
581 const ::icing::lib::TypePropertyMask& _internal_type_property_filters(int index) const;
582 ::icing::lib::TypePropertyMask* _internal_add_type_property_filters();
583 public:
584 const ::icing::lib::TypePropertyMask& type_property_filters(int index) const;
585 ::icing::lib::TypePropertyMask* add_type_property_filters();
586 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::TypePropertyMask >&
587 type_property_filters() const;
588
589 // repeated .icing.lib.PropertyProto.VectorProto embedding_query_vectors = 11;
590 int embedding_query_vectors_size() const;
591 private:
592 int _internal_embedding_query_vectors_size() const;
593 public:
594 void clear_embedding_query_vectors();
595 ::icing::lib::PropertyProto_VectorProto* mutable_embedding_query_vectors(int index);
596 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::PropertyProto_VectorProto >*
597 mutable_embedding_query_vectors();
598 private:
599 const ::icing::lib::PropertyProto_VectorProto& _internal_embedding_query_vectors(int index) const;
600 ::icing::lib::PropertyProto_VectorProto* _internal_add_embedding_query_vectors();
601 public:
602 const ::icing::lib::PropertyProto_VectorProto& embedding_query_vectors(int index) const;
603 ::icing::lib::PropertyProto_VectorProto* add_embedding_query_vectors();
604 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::PropertyProto_VectorProto >&
605 embedding_query_vectors() const;
606
607 // repeated string query_parameter_strings = 13;
608 int query_parameter_strings_size() const;
609 private:
610 int _internal_query_parameter_strings_size() const;
611 public:
612 void clear_query_parameter_strings();
613 const std::string& query_parameter_strings(int index) const;
614 std::string* mutable_query_parameter_strings(int index);
615 void set_query_parameter_strings(int index, const std::string& value);
616 void set_query_parameter_strings(int index, std::string&& value);
617 void set_query_parameter_strings(int index, const char* value);
618 void set_query_parameter_strings(int index, const char* value, size_t size);
619 std::string* add_query_parameter_strings();
620 void add_query_parameter_strings(const std::string& value);
621 void add_query_parameter_strings(std::string&& value);
622 void add_query_parameter_strings(const char* value);
623 void add_query_parameter_strings(const char* value, size_t size);
624 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& query_parameter_strings() const;
625 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_query_parameter_strings();
626 private:
627 const std::string& _internal_query_parameter_strings(int index) const;
628 std::string* _internal_add_query_parameter_strings();
629 public:
630
631 // repeated .icing.lib.NamespaceDocumentUriGroup document_uri_filters = 14;
632 int document_uri_filters_size() const;
633 private:
634 int _internal_document_uri_filters_size() const;
635 public:
636 void clear_document_uri_filters();
637 ::icing::lib::NamespaceDocumentUriGroup* mutable_document_uri_filters(int index);
638 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::NamespaceDocumentUriGroup >*
639 mutable_document_uri_filters();
640 private:
641 const ::icing::lib::NamespaceDocumentUriGroup& _internal_document_uri_filters(int index) const;
642 ::icing::lib::NamespaceDocumentUriGroup* _internal_add_document_uri_filters();
643 public:
644 const ::icing::lib::NamespaceDocumentUriGroup& document_uri_filters(int index) const;
645 ::icing::lib::NamespaceDocumentUriGroup* add_document_uri_filters();
646 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::NamespaceDocumentUriGroup >&
647 document_uri_filters() const;
648
649 // optional string query = 1;
650 bool has_query() const;
651 private:
652 bool _internal_has_query() const;
653 public:
654 void clear_query();
655 const std::string& query() const;
656 template <typename ArgT0 = const std::string&, typename... ArgT>
657 void set_query(ArgT0&& arg0, ArgT... args);
658 std::string* mutable_query();
659 PROTOBUF_NODISCARD std::string* release_query();
660 void set_allocated_query(std::string* query);
661 private:
662 const std::string& _internal_query() const;
663 inline PROTOBUF_ALWAYS_INLINE void _internal_set_query(const std::string& value);
664 std::string* _internal_mutable_query();
665 public:
666
667 // optional .icing.lib.JoinSpecProto join_spec = 7;
668 bool has_join_spec() const;
669 private:
670 bool _internal_has_join_spec() const;
671 public:
672 void clear_join_spec();
673 const ::icing::lib::JoinSpecProto& join_spec() const;
674 PROTOBUF_NODISCARD ::icing::lib::JoinSpecProto* release_join_spec();
675 ::icing::lib::JoinSpecProto* mutable_join_spec();
676 void set_allocated_join_spec(::icing::lib::JoinSpecProto* join_spec);
677 private:
678 const ::icing::lib::JoinSpecProto& _internal_join_spec() const;
679 ::icing::lib::JoinSpecProto* _internal_mutable_join_spec();
680 public:
681 void unsafe_arena_set_allocated_join_spec(
682 ::icing::lib::JoinSpecProto* join_spec);
683 ::icing::lib::JoinSpecProto* unsafe_arena_release_join_spec();
684
685 // optional int64 java_to_native_start_timestamp_ms = 5;
686 bool has_java_to_native_start_timestamp_ms() const;
687 private:
688 bool _internal_has_java_to_native_start_timestamp_ms() const;
689 public:
690 void clear_java_to_native_start_timestamp_ms();
691 ::int64_t java_to_native_start_timestamp_ms() const;
692 void set_java_to_native_start_timestamp_ms(::int64_t value);
693 private:
694 ::int64_t _internal_java_to_native_start_timestamp_ms() const;
695 void _internal_set_java_to_native_start_timestamp_ms(::int64_t value);
696 public:
697
698 // optional .icing.lib.TermMatchType.Code term_match_type = 2;
699 bool has_term_match_type() const;
700 private:
701 bool _internal_has_term_match_type() const;
702 public:
703 void clear_term_match_type();
704 ::icing::lib::TermMatchType_Code term_match_type() const;
705 void set_term_match_type(::icing::lib::TermMatchType_Code value);
706 private:
707 ::icing::lib::TermMatchType_Code _internal_term_match_type() const;
708 void _internal_set_term_match_type(::icing::lib::TermMatchType_Code value);
709 public:
710
711 // optional .icing.lib.SearchSpecProto.EmbeddingQueryMetricType.Code embedding_query_metric_type = 12;
712 bool has_embedding_query_metric_type() const;
713 private:
714 bool _internal_has_embedding_query_metric_type() const;
715 public:
716 void clear_embedding_query_metric_type();
717 ::icing::lib::SearchSpecProto_EmbeddingQueryMetricType_Code embedding_query_metric_type() const;
718 void set_embedding_query_metric_type(::icing::lib::SearchSpecProto_EmbeddingQueryMetricType_Code value);
719 private:
720 ::icing::lib::SearchSpecProto_EmbeddingQueryMetricType_Code _internal_embedding_query_metric_type() const;
721 void _internal_set_embedding_query_metric_type(::icing::lib::SearchSpecProto_EmbeddingQueryMetricType_Code value);
722 public:
723
724 // optional bool use_read_only_search = 9 [default = true];
725 bool has_use_read_only_search() const;
726 private:
727 bool _internal_has_use_read_only_search() const;
728 public:
729 void clear_use_read_only_search();
730 bool use_read_only_search() const;
731 void set_use_read_only_search(bool value);
732 private:
733 bool _internal_use_read_only_search() const;
734 void _internal_set_use_read_only_search(bool value);
735 public:
736
737 // @@protoc_insertion_point(class_scope:icing.lib.SearchSpecProto)
738 private:
739 class _Internal;
740
741 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
742 typedef void InternalArenaConstructable_;
743 typedef void DestructorSkippable_;
744 struct Impl_ {
745 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
746 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
747 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> namespace_filters_;
748 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> schema_type_filters_;
749 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> enabled_features_;
750 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::TypePropertyMask > type_property_filters_;
751 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::PropertyProto_VectorProto > embedding_query_vectors_;
752 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> query_parameter_strings_;
753 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::NamespaceDocumentUriGroup > document_uri_filters_;
754 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr query_;
755 ::icing::lib::JoinSpecProto* join_spec_;
756 ::int64_t java_to_native_start_timestamp_ms_;
757 int term_match_type_;
758 int embedding_query_metric_type_;
759 bool use_read_only_search_;
760 };
761 union { Impl_ _impl_; };
762 friend struct ::TableStruct_icing_2fproto_2fsearch_2eproto;
763 };
764 // -------------------------------------------------------------------
765
766 class ResultSpecProto_SnippetSpecProto final :
767 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:icing.lib.ResultSpecProto.SnippetSpecProto) */ {
768 public:
ResultSpecProto_SnippetSpecProto()769 inline ResultSpecProto_SnippetSpecProto() : ResultSpecProto_SnippetSpecProto(nullptr) {}
770 ~ResultSpecProto_SnippetSpecProto() override;
771 explicit PROTOBUF_CONSTEXPR ResultSpecProto_SnippetSpecProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
772
773 ResultSpecProto_SnippetSpecProto(const ResultSpecProto_SnippetSpecProto& from);
ResultSpecProto_SnippetSpecProto(ResultSpecProto_SnippetSpecProto && from)774 ResultSpecProto_SnippetSpecProto(ResultSpecProto_SnippetSpecProto&& from) noexcept
775 : ResultSpecProto_SnippetSpecProto() {
776 *this = ::std::move(from);
777 }
778
779 inline ResultSpecProto_SnippetSpecProto& operator=(const ResultSpecProto_SnippetSpecProto& from) {
780 if (this == &from) return *this;
781 CopyFrom(from);
782 return *this;
783 }
784 inline ResultSpecProto_SnippetSpecProto& operator=(ResultSpecProto_SnippetSpecProto&& from) noexcept {
785 if (this == &from) return *this;
786 if (GetOwningArena() == from.GetOwningArena()
787 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
788 && GetOwningArena() != nullptr
789 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
790 ) {
791 InternalSwap(&from);
792 } else {
793 CopyFrom(from);
794 }
795 return *this;
796 }
797
unknown_fields()798 inline const std::string& unknown_fields() const {
799 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
800 }
mutable_unknown_fields()801 inline std::string* mutable_unknown_fields() {
802 return _internal_metadata_.mutable_unknown_fields<std::string>();
803 }
804
default_instance()805 static const ResultSpecProto_SnippetSpecProto& default_instance() {
806 return *internal_default_instance();
807 }
internal_default_instance()808 static inline const ResultSpecProto_SnippetSpecProto* internal_default_instance() {
809 return reinterpret_cast<const ResultSpecProto_SnippetSpecProto*>(
810 &_ResultSpecProto_SnippetSpecProto_default_instance_);
811 }
812 static constexpr int kIndexInFileMessages =
813 2;
814
swap(ResultSpecProto_SnippetSpecProto & a,ResultSpecProto_SnippetSpecProto & b)815 friend void swap(ResultSpecProto_SnippetSpecProto& a, ResultSpecProto_SnippetSpecProto& b) {
816 a.Swap(&b);
817 }
Swap(ResultSpecProto_SnippetSpecProto * other)818 inline void Swap(ResultSpecProto_SnippetSpecProto* other) {
819 if (other == this) return;
820 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
821 if (GetOwningArena() != nullptr &&
822 GetOwningArena() == other->GetOwningArena()) {
823 #else // PROTOBUF_FORCE_COPY_IN_SWAP
824 if (GetOwningArena() == other->GetOwningArena()) {
825 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
826 InternalSwap(other);
827 } else {
828 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
829 }
830 }
831 void UnsafeArenaSwap(ResultSpecProto_SnippetSpecProto* other) {
832 if (other == this) return;
833 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
834 InternalSwap(other);
835 }
836
837 // implements Message ----------------------------------------------
838
839 ResultSpecProto_SnippetSpecProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
840 return CreateMaybeMessage<ResultSpecProto_SnippetSpecProto>(arena);
841 }
842 ResultSpecProto_SnippetSpecProto* New() const {
843 return New(nullptr);
844 }
845 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
846 void CopyFrom(const ResultSpecProto_SnippetSpecProto& from);
847 void MergeFrom(const ResultSpecProto_SnippetSpecProto& from);
848 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
849 bool IsInitialized() const final;
850
851 size_t ByteSizeLong() const final;
852 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
853 ::uint8_t* _InternalSerialize(
854 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
855 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
856
857 private:
858 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
859 void SharedDtor();
860 void SetCachedSize(int size) const;
861 void InternalSwap(ResultSpecProto_SnippetSpecProto* other);
862
863 private:
864 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
865 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
866 return "icing.lib.ResultSpecProto.SnippetSpecProto";
867 }
868 protected:
869 explicit ResultSpecProto_SnippetSpecProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
870 bool is_message_owned = false);
871 public:
872
873 std::string GetTypeName() const final;
874
875 // nested types ----------------------------------------------------
876
877 // accessors -------------------------------------------------------
878
879 enum : int {
880 kNumToSnippetFieldNumber = 1,
881 kNumMatchesPerPropertyFieldNumber = 2,
882 kMaxWindowUtf32LengthFieldNumber = 3,
883 };
884 // optional int32 num_to_snippet = 1;
885 bool has_num_to_snippet() const;
886 private:
887 bool _internal_has_num_to_snippet() const;
888 public:
889 void clear_num_to_snippet();
890 ::int32_t num_to_snippet() const;
891 void set_num_to_snippet(::int32_t value);
892 private:
893 ::int32_t _internal_num_to_snippet() const;
894 void _internal_set_num_to_snippet(::int32_t value);
895 public:
896
897 // optional int32 num_matches_per_property = 2;
898 bool has_num_matches_per_property() const;
899 private:
900 bool _internal_has_num_matches_per_property() const;
901 public:
902 void clear_num_matches_per_property();
903 ::int32_t num_matches_per_property() const;
904 void set_num_matches_per_property(::int32_t value);
905 private:
906 ::int32_t _internal_num_matches_per_property() const;
907 void _internal_set_num_matches_per_property(::int32_t value);
908 public:
909
910 // optional int32 max_window_utf32_length = 3;
911 bool has_max_window_utf32_length() const;
912 private:
913 bool _internal_has_max_window_utf32_length() const;
914 public:
915 void clear_max_window_utf32_length();
916 ::int32_t max_window_utf32_length() const;
917 void set_max_window_utf32_length(::int32_t value);
918 private:
919 ::int32_t _internal_max_window_utf32_length() const;
920 void _internal_set_max_window_utf32_length(::int32_t value);
921 public:
922
923 // @@protoc_insertion_point(class_scope:icing.lib.ResultSpecProto.SnippetSpecProto)
924 private:
925 class _Internal;
926
927 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
928 typedef void InternalArenaConstructable_;
929 typedef void DestructorSkippable_;
930 struct Impl_ {
931 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
932 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
933 ::int32_t num_to_snippet_;
934 ::int32_t num_matches_per_property_;
935 ::int32_t max_window_utf32_length_;
936 };
937 union { Impl_ _impl_; };
938 friend struct ::TableStruct_icing_2fproto_2fsearch_2eproto;
939 };
940 // -------------------------------------------------------------------
941
942 class ResultSpecProto_ResultGrouping_Entry final :
943 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:icing.lib.ResultSpecProto.ResultGrouping.Entry) */ {
944 public:
ResultSpecProto_ResultGrouping_Entry()945 inline ResultSpecProto_ResultGrouping_Entry() : ResultSpecProto_ResultGrouping_Entry(nullptr) {}
946 ~ResultSpecProto_ResultGrouping_Entry() override;
947 explicit PROTOBUF_CONSTEXPR ResultSpecProto_ResultGrouping_Entry(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
948
949 ResultSpecProto_ResultGrouping_Entry(const ResultSpecProto_ResultGrouping_Entry& from);
ResultSpecProto_ResultGrouping_Entry(ResultSpecProto_ResultGrouping_Entry && from)950 ResultSpecProto_ResultGrouping_Entry(ResultSpecProto_ResultGrouping_Entry&& from) noexcept
951 : ResultSpecProto_ResultGrouping_Entry() {
952 *this = ::std::move(from);
953 }
954
955 inline ResultSpecProto_ResultGrouping_Entry& operator=(const ResultSpecProto_ResultGrouping_Entry& from) {
956 if (this == &from) return *this;
957 CopyFrom(from);
958 return *this;
959 }
960 inline ResultSpecProto_ResultGrouping_Entry& operator=(ResultSpecProto_ResultGrouping_Entry&& from) noexcept {
961 if (this == &from) return *this;
962 if (GetOwningArena() == from.GetOwningArena()
963 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
964 && GetOwningArena() != nullptr
965 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
966 ) {
967 InternalSwap(&from);
968 } else {
969 CopyFrom(from);
970 }
971 return *this;
972 }
973
unknown_fields()974 inline const std::string& unknown_fields() const {
975 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
976 }
mutable_unknown_fields()977 inline std::string* mutable_unknown_fields() {
978 return _internal_metadata_.mutable_unknown_fields<std::string>();
979 }
980
default_instance()981 static const ResultSpecProto_ResultGrouping_Entry& default_instance() {
982 return *internal_default_instance();
983 }
internal_default_instance()984 static inline const ResultSpecProto_ResultGrouping_Entry* internal_default_instance() {
985 return reinterpret_cast<const ResultSpecProto_ResultGrouping_Entry*>(
986 &_ResultSpecProto_ResultGrouping_Entry_default_instance_);
987 }
988 static constexpr int kIndexInFileMessages =
989 3;
990
swap(ResultSpecProto_ResultGrouping_Entry & a,ResultSpecProto_ResultGrouping_Entry & b)991 friend void swap(ResultSpecProto_ResultGrouping_Entry& a, ResultSpecProto_ResultGrouping_Entry& b) {
992 a.Swap(&b);
993 }
Swap(ResultSpecProto_ResultGrouping_Entry * other)994 inline void Swap(ResultSpecProto_ResultGrouping_Entry* other) {
995 if (other == this) return;
996 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
997 if (GetOwningArena() != nullptr &&
998 GetOwningArena() == other->GetOwningArena()) {
999 #else // PROTOBUF_FORCE_COPY_IN_SWAP
1000 if (GetOwningArena() == other->GetOwningArena()) {
1001 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
1002 InternalSwap(other);
1003 } else {
1004 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1005 }
1006 }
1007 void UnsafeArenaSwap(ResultSpecProto_ResultGrouping_Entry* other) {
1008 if (other == this) return;
1009 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1010 InternalSwap(other);
1011 }
1012
1013 // implements Message ----------------------------------------------
1014
1015 ResultSpecProto_ResultGrouping_Entry* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1016 return CreateMaybeMessage<ResultSpecProto_ResultGrouping_Entry>(arena);
1017 }
1018 ResultSpecProto_ResultGrouping_Entry* New() const {
1019 return New(nullptr);
1020 }
1021 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
1022 void CopyFrom(const ResultSpecProto_ResultGrouping_Entry& from);
1023 void MergeFrom(const ResultSpecProto_ResultGrouping_Entry& from);
1024 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1025 bool IsInitialized() const final;
1026
1027 size_t ByteSizeLong() const final;
1028 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1029 ::uint8_t* _InternalSerialize(
1030 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1031 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1032
1033 private:
1034 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1035 void SharedDtor();
1036 void SetCachedSize(int size) const;
1037 void InternalSwap(ResultSpecProto_ResultGrouping_Entry* other);
1038
1039 private:
1040 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1041 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1042 return "icing.lib.ResultSpecProto.ResultGrouping.Entry";
1043 }
1044 protected:
1045 explicit ResultSpecProto_ResultGrouping_Entry(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1046 bool is_message_owned = false);
1047 public:
1048
1049 std::string GetTypeName() const final;
1050
1051 // nested types ----------------------------------------------------
1052
1053 // accessors -------------------------------------------------------
1054
1055 enum : int {
1056 kNamespaceFieldNumber = 1,
1057 kSchemaFieldNumber = 2,
1058 };
1059 // optional string namespace = 1;
1060 bool has_namespace_() const;
1061 private:
1062 bool _internal_has_namespace_() const;
1063 public:
1064 void clear_namespace_();
1065 const std::string& namespace_() const;
1066 template <typename ArgT0 = const std::string&, typename... ArgT>
1067 void set_namespace_(ArgT0&& arg0, ArgT... args);
1068 std::string* mutable_namespace_();
1069 PROTOBUF_NODISCARD std::string* release_namespace_();
1070 void set_allocated_namespace_(std::string* namespace_);
1071 private:
1072 const std::string& _internal_namespace_() const;
1073 inline PROTOBUF_ALWAYS_INLINE void _internal_set_namespace_(const std::string& value);
1074 std::string* _internal_mutable_namespace_();
1075 public:
1076
1077 // optional string schema = 2;
1078 bool has_schema() const;
1079 private:
1080 bool _internal_has_schema() const;
1081 public:
1082 void clear_schema();
1083 const std::string& schema() const;
1084 template <typename ArgT0 = const std::string&, typename... ArgT>
1085 void set_schema(ArgT0&& arg0, ArgT... args);
1086 std::string* mutable_schema();
1087 PROTOBUF_NODISCARD std::string* release_schema();
1088 void set_allocated_schema(std::string* schema);
1089 private:
1090 const std::string& _internal_schema() const;
1091 inline PROTOBUF_ALWAYS_INLINE void _internal_set_schema(const std::string& value);
1092 std::string* _internal_mutable_schema();
1093 public:
1094
1095 // @@protoc_insertion_point(class_scope:icing.lib.ResultSpecProto.ResultGrouping.Entry)
1096 private:
1097 class _Internal;
1098
1099 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1100 typedef void InternalArenaConstructable_;
1101 typedef void DestructorSkippable_;
1102 struct Impl_ {
1103 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
1104 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1105 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr namespace__;
1106 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr schema_;
1107 };
1108 union { Impl_ _impl_; };
1109 friend struct ::TableStruct_icing_2fproto_2fsearch_2eproto;
1110 };
1111 // -------------------------------------------------------------------
1112
1113 class ResultSpecProto_ResultGrouping final :
1114 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:icing.lib.ResultSpecProto.ResultGrouping) */ {
1115 public:
ResultSpecProto_ResultGrouping()1116 inline ResultSpecProto_ResultGrouping() : ResultSpecProto_ResultGrouping(nullptr) {}
1117 ~ResultSpecProto_ResultGrouping() override;
1118 explicit PROTOBUF_CONSTEXPR ResultSpecProto_ResultGrouping(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1119
1120 ResultSpecProto_ResultGrouping(const ResultSpecProto_ResultGrouping& from);
ResultSpecProto_ResultGrouping(ResultSpecProto_ResultGrouping && from)1121 ResultSpecProto_ResultGrouping(ResultSpecProto_ResultGrouping&& from) noexcept
1122 : ResultSpecProto_ResultGrouping() {
1123 *this = ::std::move(from);
1124 }
1125
1126 inline ResultSpecProto_ResultGrouping& operator=(const ResultSpecProto_ResultGrouping& from) {
1127 if (this == &from) return *this;
1128 CopyFrom(from);
1129 return *this;
1130 }
1131 inline ResultSpecProto_ResultGrouping& operator=(ResultSpecProto_ResultGrouping&& from) noexcept {
1132 if (this == &from) return *this;
1133 if (GetOwningArena() == from.GetOwningArena()
1134 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1135 && GetOwningArena() != nullptr
1136 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
1137 ) {
1138 InternalSwap(&from);
1139 } else {
1140 CopyFrom(from);
1141 }
1142 return *this;
1143 }
1144
unknown_fields()1145 inline const std::string& unknown_fields() const {
1146 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
1147 }
mutable_unknown_fields()1148 inline std::string* mutable_unknown_fields() {
1149 return _internal_metadata_.mutable_unknown_fields<std::string>();
1150 }
1151
default_instance()1152 static const ResultSpecProto_ResultGrouping& default_instance() {
1153 return *internal_default_instance();
1154 }
internal_default_instance()1155 static inline const ResultSpecProto_ResultGrouping* internal_default_instance() {
1156 return reinterpret_cast<const ResultSpecProto_ResultGrouping*>(
1157 &_ResultSpecProto_ResultGrouping_default_instance_);
1158 }
1159 static constexpr int kIndexInFileMessages =
1160 4;
1161
swap(ResultSpecProto_ResultGrouping & a,ResultSpecProto_ResultGrouping & b)1162 friend void swap(ResultSpecProto_ResultGrouping& a, ResultSpecProto_ResultGrouping& b) {
1163 a.Swap(&b);
1164 }
Swap(ResultSpecProto_ResultGrouping * other)1165 inline void Swap(ResultSpecProto_ResultGrouping* other) {
1166 if (other == this) return;
1167 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1168 if (GetOwningArena() != nullptr &&
1169 GetOwningArena() == other->GetOwningArena()) {
1170 #else // PROTOBUF_FORCE_COPY_IN_SWAP
1171 if (GetOwningArena() == other->GetOwningArena()) {
1172 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
1173 InternalSwap(other);
1174 } else {
1175 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1176 }
1177 }
1178 void UnsafeArenaSwap(ResultSpecProto_ResultGrouping* other) {
1179 if (other == this) return;
1180 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1181 InternalSwap(other);
1182 }
1183
1184 // implements Message ----------------------------------------------
1185
1186 ResultSpecProto_ResultGrouping* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1187 return CreateMaybeMessage<ResultSpecProto_ResultGrouping>(arena);
1188 }
1189 ResultSpecProto_ResultGrouping* New() const {
1190 return New(nullptr);
1191 }
1192 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
1193 void CopyFrom(const ResultSpecProto_ResultGrouping& from);
1194 void MergeFrom(const ResultSpecProto_ResultGrouping& from);
1195 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1196 bool IsInitialized() const final;
1197
1198 size_t ByteSizeLong() const final;
1199 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1200 ::uint8_t* _InternalSerialize(
1201 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1202 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1203
1204 private:
1205 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1206 void SharedDtor();
1207 void SetCachedSize(int size) const;
1208 void InternalSwap(ResultSpecProto_ResultGrouping* other);
1209
1210 private:
1211 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1212 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1213 return "icing.lib.ResultSpecProto.ResultGrouping";
1214 }
1215 protected:
1216 explicit ResultSpecProto_ResultGrouping(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1217 bool is_message_owned = false);
1218 public:
1219
1220 std::string GetTypeName() const final;
1221
1222 // nested types ----------------------------------------------------
1223
1224 typedef ResultSpecProto_ResultGrouping_Entry Entry;
1225
1226 // accessors -------------------------------------------------------
1227
1228 enum : int {
1229 kEntryGroupingsFieldNumber = 1,
1230 kMaxResultsFieldNumber = 2,
1231 };
1232 // repeated .icing.lib.ResultSpecProto.ResultGrouping.Entry entry_groupings = 1;
1233 int entry_groupings_size() const;
1234 private:
1235 int _internal_entry_groupings_size() const;
1236 public:
1237 void clear_entry_groupings();
1238 ::icing::lib::ResultSpecProto_ResultGrouping_Entry* mutable_entry_groupings(int index);
1239 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::ResultSpecProto_ResultGrouping_Entry >*
1240 mutable_entry_groupings();
1241 private:
1242 const ::icing::lib::ResultSpecProto_ResultGrouping_Entry& _internal_entry_groupings(int index) const;
1243 ::icing::lib::ResultSpecProto_ResultGrouping_Entry* _internal_add_entry_groupings();
1244 public:
1245 const ::icing::lib::ResultSpecProto_ResultGrouping_Entry& entry_groupings(int index) const;
1246 ::icing::lib::ResultSpecProto_ResultGrouping_Entry* add_entry_groupings();
1247 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::ResultSpecProto_ResultGrouping_Entry >&
1248 entry_groupings() const;
1249
1250 // optional int32 max_results = 2;
1251 bool has_max_results() const;
1252 private:
1253 bool _internal_has_max_results() const;
1254 public:
1255 void clear_max_results();
1256 ::int32_t max_results() const;
1257 void set_max_results(::int32_t value);
1258 private:
1259 ::int32_t _internal_max_results() const;
1260 void _internal_set_max_results(::int32_t value);
1261 public:
1262
1263 // @@protoc_insertion_point(class_scope:icing.lib.ResultSpecProto.ResultGrouping)
1264 private:
1265 class _Internal;
1266
1267 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1268 typedef void InternalArenaConstructable_;
1269 typedef void DestructorSkippable_;
1270 struct Impl_ {
1271 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
1272 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1273 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::ResultSpecProto_ResultGrouping_Entry > entry_groupings_;
1274 ::int32_t max_results_;
1275 };
1276 union { Impl_ _impl_; };
1277 friend struct ::TableStruct_icing_2fproto_2fsearch_2eproto;
1278 };
1279 // -------------------------------------------------------------------
1280
1281 class ResultSpecProto final :
1282 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:icing.lib.ResultSpecProto) */ {
1283 public:
ResultSpecProto()1284 inline ResultSpecProto() : ResultSpecProto(nullptr) {}
1285 ~ResultSpecProto() override;
1286 explicit PROTOBUF_CONSTEXPR ResultSpecProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1287
1288 ResultSpecProto(const ResultSpecProto& from);
ResultSpecProto(ResultSpecProto && from)1289 ResultSpecProto(ResultSpecProto&& from) noexcept
1290 : ResultSpecProto() {
1291 *this = ::std::move(from);
1292 }
1293
1294 inline ResultSpecProto& operator=(const ResultSpecProto& from) {
1295 if (this == &from) return *this;
1296 CopyFrom(from);
1297 return *this;
1298 }
1299 inline ResultSpecProto& operator=(ResultSpecProto&& from) noexcept {
1300 if (this == &from) return *this;
1301 if (GetOwningArena() == from.GetOwningArena()
1302 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1303 && GetOwningArena() != nullptr
1304 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
1305 ) {
1306 InternalSwap(&from);
1307 } else {
1308 CopyFrom(from);
1309 }
1310 return *this;
1311 }
1312
unknown_fields()1313 inline const std::string& unknown_fields() const {
1314 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
1315 }
mutable_unknown_fields()1316 inline std::string* mutable_unknown_fields() {
1317 return _internal_metadata_.mutable_unknown_fields<std::string>();
1318 }
1319
default_instance()1320 static const ResultSpecProto& default_instance() {
1321 return *internal_default_instance();
1322 }
internal_default_instance()1323 static inline const ResultSpecProto* internal_default_instance() {
1324 return reinterpret_cast<const ResultSpecProto*>(
1325 &_ResultSpecProto_default_instance_);
1326 }
1327 static constexpr int kIndexInFileMessages =
1328 5;
1329
swap(ResultSpecProto & a,ResultSpecProto & b)1330 friend void swap(ResultSpecProto& a, ResultSpecProto& b) {
1331 a.Swap(&b);
1332 }
Swap(ResultSpecProto * other)1333 inline void Swap(ResultSpecProto* other) {
1334 if (other == this) return;
1335 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1336 if (GetOwningArena() != nullptr &&
1337 GetOwningArena() == other->GetOwningArena()) {
1338 #else // PROTOBUF_FORCE_COPY_IN_SWAP
1339 if (GetOwningArena() == other->GetOwningArena()) {
1340 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
1341 InternalSwap(other);
1342 } else {
1343 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1344 }
1345 }
1346 void UnsafeArenaSwap(ResultSpecProto* other) {
1347 if (other == this) return;
1348 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1349 InternalSwap(other);
1350 }
1351
1352 // implements Message ----------------------------------------------
1353
1354 ResultSpecProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1355 return CreateMaybeMessage<ResultSpecProto>(arena);
1356 }
1357 ResultSpecProto* New() const {
1358 return New(nullptr);
1359 }
1360 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
1361 void CopyFrom(const ResultSpecProto& from);
1362 void MergeFrom(const ResultSpecProto& from);
1363 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1364 bool IsInitialized() const final;
1365
1366 size_t ByteSizeLong() const final;
1367 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1368 ::uint8_t* _InternalSerialize(
1369 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1370 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1371
1372 private:
1373 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1374 void SharedDtor();
1375 void SetCachedSize(int size) const;
1376 void InternalSwap(ResultSpecProto* other);
1377
1378 private:
1379 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1380 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1381 return "icing.lib.ResultSpecProto";
1382 }
1383 protected:
1384 explicit ResultSpecProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1385 bool is_message_owned = false);
1386 public:
1387
1388 std::string GetTypeName() const final;
1389
1390 // nested types ----------------------------------------------------
1391
1392 typedef ResultSpecProto_SnippetSpecProto SnippetSpecProto;
1393 typedef ResultSpecProto_ResultGrouping ResultGrouping;
1394
1395 typedef ResultSpecProto_ResultGroupingType ResultGroupingType;
1396 static constexpr ResultGroupingType NONE =
1397 ResultSpecProto_ResultGroupingType_NONE;
1398 static constexpr ResultGroupingType SCHEMA_TYPE =
1399 ResultSpecProto_ResultGroupingType_SCHEMA_TYPE;
1400 static constexpr ResultGroupingType NAMESPACE =
1401 ResultSpecProto_ResultGroupingType_NAMESPACE;
1402 static constexpr ResultGroupingType NAMESPACE_AND_SCHEMA_TYPE =
1403 ResultSpecProto_ResultGroupingType_NAMESPACE_AND_SCHEMA_TYPE;
1404 static inline bool ResultGroupingType_IsValid(int value) {
1405 return ResultSpecProto_ResultGroupingType_IsValid(value);
1406 }
1407 static constexpr ResultGroupingType ResultGroupingType_MIN =
1408 ResultSpecProto_ResultGroupingType_ResultGroupingType_MIN;
1409 static constexpr ResultGroupingType ResultGroupingType_MAX =
1410 ResultSpecProto_ResultGroupingType_ResultGroupingType_MAX;
1411 static constexpr int ResultGroupingType_ARRAYSIZE =
1412 ResultSpecProto_ResultGroupingType_ResultGroupingType_ARRAYSIZE;
1413 template<typename T>
1414 static inline const std::string& ResultGroupingType_Name(T enum_t_value) {
1415 static_assert(::std::is_same<T, ResultGroupingType>::value ||
1416 ::std::is_integral<T>::value,
1417 "Incorrect type passed to function ResultGroupingType_Name.");
1418 return ResultSpecProto_ResultGroupingType_Name(enum_t_value);
1419 }
1420 static inline bool ResultGroupingType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
1421 ResultGroupingType* value) {
1422 return ResultSpecProto_ResultGroupingType_Parse(name, value);
1423 }
1424
1425 // accessors -------------------------------------------------------
1426
1427 enum : int {
1428 kTypePropertyMasksFieldNumber = 4,
1429 kResultGroupingsFieldNumber = 5,
1430 kSnippetSpecFieldNumber = 3,
1431 kDebugInfoFieldNumber = 2,
1432 kResultGroupTypeFieldNumber = 7,
1433 kMaxJoinedChildrenPerParentToReturnFieldNumber = 8,
1434 kNumToScoreFieldNumber = 9,
1435 kNumPerPageFieldNumber = 1,
1436 kNumTotalBytesPerPageThresholdFieldNumber = 6,
1437 };
1438 // repeated .icing.lib.TypePropertyMask type_property_masks = 4;
1439 int type_property_masks_size() const;
1440 private:
1441 int _internal_type_property_masks_size() const;
1442 public:
1443 void clear_type_property_masks();
1444 ::icing::lib::TypePropertyMask* mutable_type_property_masks(int index);
1445 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::TypePropertyMask >*
1446 mutable_type_property_masks();
1447 private:
1448 const ::icing::lib::TypePropertyMask& _internal_type_property_masks(int index) const;
1449 ::icing::lib::TypePropertyMask* _internal_add_type_property_masks();
1450 public:
1451 const ::icing::lib::TypePropertyMask& type_property_masks(int index) const;
1452 ::icing::lib::TypePropertyMask* add_type_property_masks();
1453 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::TypePropertyMask >&
1454 type_property_masks() const;
1455
1456 // repeated .icing.lib.ResultSpecProto.ResultGrouping result_groupings = 5;
1457 int result_groupings_size() const;
1458 private:
1459 int _internal_result_groupings_size() const;
1460 public:
1461 void clear_result_groupings();
1462 ::icing::lib::ResultSpecProto_ResultGrouping* mutable_result_groupings(int index);
1463 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::ResultSpecProto_ResultGrouping >*
1464 mutable_result_groupings();
1465 private:
1466 const ::icing::lib::ResultSpecProto_ResultGrouping& _internal_result_groupings(int index) const;
1467 ::icing::lib::ResultSpecProto_ResultGrouping* _internal_add_result_groupings();
1468 public:
1469 const ::icing::lib::ResultSpecProto_ResultGrouping& result_groupings(int index) const;
1470 ::icing::lib::ResultSpecProto_ResultGrouping* add_result_groupings();
1471 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::ResultSpecProto_ResultGrouping >&
1472 result_groupings() const;
1473
1474 // optional .icing.lib.ResultSpecProto.SnippetSpecProto snippet_spec = 3;
1475 bool has_snippet_spec() const;
1476 private:
1477 bool _internal_has_snippet_spec() const;
1478 public:
1479 void clear_snippet_spec();
1480 const ::icing::lib::ResultSpecProto_SnippetSpecProto& snippet_spec() const;
1481 PROTOBUF_NODISCARD ::icing::lib::ResultSpecProto_SnippetSpecProto* release_snippet_spec();
1482 ::icing::lib::ResultSpecProto_SnippetSpecProto* mutable_snippet_spec();
1483 void set_allocated_snippet_spec(::icing::lib::ResultSpecProto_SnippetSpecProto* snippet_spec);
1484 private:
1485 const ::icing::lib::ResultSpecProto_SnippetSpecProto& _internal_snippet_spec() const;
1486 ::icing::lib::ResultSpecProto_SnippetSpecProto* _internal_mutable_snippet_spec();
1487 public:
1488 void unsafe_arena_set_allocated_snippet_spec(
1489 ::icing::lib::ResultSpecProto_SnippetSpecProto* snippet_spec);
1490 ::icing::lib::ResultSpecProto_SnippetSpecProto* unsafe_arena_release_snippet_spec();
1491
1492 // optional bool debug_info = 2;
1493 bool has_debug_info() const;
1494 private:
1495 bool _internal_has_debug_info() const;
1496 public:
1497 void clear_debug_info();
1498 bool debug_info() const;
1499 void set_debug_info(bool value);
1500 private:
1501 bool _internal_debug_info() const;
1502 void _internal_set_debug_info(bool value);
1503 public:
1504
1505 // optional .icing.lib.ResultSpecProto.ResultGroupingType result_group_type = 7;
1506 bool has_result_group_type() const;
1507 private:
1508 bool _internal_has_result_group_type() const;
1509 public:
1510 void clear_result_group_type();
1511 ::icing::lib::ResultSpecProto_ResultGroupingType result_group_type() const;
1512 void set_result_group_type(::icing::lib::ResultSpecProto_ResultGroupingType value);
1513 private:
1514 ::icing::lib::ResultSpecProto_ResultGroupingType _internal_result_group_type() const;
1515 void _internal_set_result_group_type(::icing::lib::ResultSpecProto_ResultGroupingType value);
1516 public:
1517
1518 // optional int32 max_joined_children_per_parent_to_return = 8;
1519 bool has_max_joined_children_per_parent_to_return() const;
1520 private:
1521 bool _internal_has_max_joined_children_per_parent_to_return() const;
1522 public:
1523 void clear_max_joined_children_per_parent_to_return();
1524 ::int32_t max_joined_children_per_parent_to_return() const;
1525 void set_max_joined_children_per_parent_to_return(::int32_t value);
1526 private:
1527 ::int32_t _internal_max_joined_children_per_parent_to_return() const;
1528 void _internal_set_max_joined_children_per_parent_to_return(::int32_t value);
1529 public:
1530
1531 // optional int32 num_to_score = 9 [default = 30000];
1532 bool has_num_to_score() const;
1533 private:
1534 bool _internal_has_num_to_score() const;
1535 public:
1536 void clear_num_to_score();
1537 ::int32_t num_to_score() const;
1538 void set_num_to_score(::int32_t value);
1539 private:
1540 ::int32_t _internal_num_to_score() const;
1541 void _internal_set_num_to_score(::int32_t value);
1542 public:
1543
1544 // optional int32 num_per_page = 1 [default = 10];
1545 bool has_num_per_page() const;
1546 private:
1547 bool _internal_has_num_per_page() const;
1548 public:
1549 void clear_num_per_page();
1550 ::int32_t num_per_page() const;
1551 void set_num_per_page(::int32_t value);
1552 private:
1553 ::int32_t _internal_num_per_page() const;
1554 void _internal_set_num_per_page(::int32_t value);
1555 public:
1556
1557 // optional int32 num_total_bytes_per_page_threshold = 6 [default = 2147483647];
1558 bool has_num_total_bytes_per_page_threshold() const;
1559 private:
1560 bool _internal_has_num_total_bytes_per_page_threshold() const;
1561 public:
1562 void clear_num_total_bytes_per_page_threshold();
1563 ::int32_t num_total_bytes_per_page_threshold() const;
1564 void set_num_total_bytes_per_page_threshold(::int32_t value);
1565 private:
1566 ::int32_t _internal_num_total_bytes_per_page_threshold() const;
1567 void _internal_set_num_total_bytes_per_page_threshold(::int32_t value);
1568 public:
1569
1570 // @@protoc_insertion_point(class_scope:icing.lib.ResultSpecProto)
1571 private:
1572 class _Internal;
1573
1574 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1575 typedef void InternalArenaConstructable_;
1576 typedef void DestructorSkippable_;
1577 struct Impl_ {
1578 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
1579 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1580 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::TypePropertyMask > type_property_masks_;
1581 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::ResultSpecProto_ResultGrouping > result_groupings_;
1582 ::icing::lib::ResultSpecProto_SnippetSpecProto* snippet_spec_;
1583 bool debug_info_;
1584 int result_group_type_;
1585 ::int32_t max_joined_children_per_parent_to_return_;
1586 ::int32_t num_to_score_;
1587 ::int32_t num_per_page_;
1588 ::int32_t num_total_bytes_per_page_threshold_;
1589 };
1590 union { Impl_ _impl_; };
1591 friend struct ::TableStruct_icing_2fproto_2fsearch_2eproto;
1592 };
1593 // -------------------------------------------------------------------
1594
1595 class SnippetMatchProto final :
1596 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:icing.lib.SnippetMatchProto) */ {
1597 public:
SnippetMatchProto()1598 inline SnippetMatchProto() : SnippetMatchProto(nullptr) {}
1599 ~SnippetMatchProto() override;
1600 explicit PROTOBUF_CONSTEXPR SnippetMatchProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1601
1602 SnippetMatchProto(const SnippetMatchProto& from);
SnippetMatchProto(SnippetMatchProto && from)1603 SnippetMatchProto(SnippetMatchProto&& from) noexcept
1604 : SnippetMatchProto() {
1605 *this = ::std::move(from);
1606 }
1607
1608 inline SnippetMatchProto& operator=(const SnippetMatchProto& from) {
1609 if (this == &from) return *this;
1610 CopyFrom(from);
1611 return *this;
1612 }
1613 inline SnippetMatchProto& operator=(SnippetMatchProto&& from) noexcept {
1614 if (this == &from) return *this;
1615 if (GetOwningArena() == from.GetOwningArena()
1616 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1617 && GetOwningArena() != nullptr
1618 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
1619 ) {
1620 InternalSwap(&from);
1621 } else {
1622 CopyFrom(from);
1623 }
1624 return *this;
1625 }
1626
unknown_fields()1627 inline const std::string& unknown_fields() const {
1628 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
1629 }
mutable_unknown_fields()1630 inline std::string* mutable_unknown_fields() {
1631 return _internal_metadata_.mutable_unknown_fields<std::string>();
1632 }
1633
default_instance()1634 static const SnippetMatchProto& default_instance() {
1635 return *internal_default_instance();
1636 }
internal_default_instance()1637 static inline const SnippetMatchProto* internal_default_instance() {
1638 return reinterpret_cast<const SnippetMatchProto*>(
1639 &_SnippetMatchProto_default_instance_);
1640 }
1641 static constexpr int kIndexInFileMessages =
1642 6;
1643
swap(SnippetMatchProto & a,SnippetMatchProto & b)1644 friend void swap(SnippetMatchProto& a, SnippetMatchProto& b) {
1645 a.Swap(&b);
1646 }
Swap(SnippetMatchProto * other)1647 inline void Swap(SnippetMatchProto* other) {
1648 if (other == this) return;
1649 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1650 if (GetOwningArena() != nullptr &&
1651 GetOwningArena() == other->GetOwningArena()) {
1652 #else // PROTOBUF_FORCE_COPY_IN_SWAP
1653 if (GetOwningArena() == other->GetOwningArena()) {
1654 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
1655 InternalSwap(other);
1656 } else {
1657 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1658 }
1659 }
1660 void UnsafeArenaSwap(SnippetMatchProto* other) {
1661 if (other == this) return;
1662 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1663 InternalSwap(other);
1664 }
1665
1666 // implements Message ----------------------------------------------
1667
1668 SnippetMatchProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1669 return CreateMaybeMessage<SnippetMatchProto>(arena);
1670 }
1671 SnippetMatchProto* New() const {
1672 return New(nullptr);
1673 }
1674 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
1675 void CopyFrom(const SnippetMatchProto& from);
1676 void MergeFrom(const SnippetMatchProto& from);
1677 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1678 bool IsInitialized() const final;
1679
1680 size_t ByteSizeLong() const final;
1681 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1682 ::uint8_t* _InternalSerialize(
1683 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1684 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1685
1686 private:
1687 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1688 void SharedDtor();
1689 void SetCachedSize(int size) const;
1690 void InternalSwap(SnippetMatchProto* other);
1691
1692 private:
1693 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1694 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1695 return "icing.lib.SnippetMatchProto";
1696 }
1697 protected:
1698 explicit SnippetMatchProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1699 bool is_message_owned = false);
1700 public:
1701
1702 std::string GetTypeName() const final;
1703
1704 // nested types ----------------------------------------------------
1705
1706 // accessors -------------------------------------------------------
1707
1708 enum : int {
1709 kExactMatchBytePositionFieldNumber = 2,
1710 kExactMatchByteLengthFieldNumber = 3,
1711 kWindowBytePositionFieldNumber = 4,
1712 kWindowByteLengthFieldNumber = 5,
1713 kExactMatchUtf16PositionFieldNumber = 6,
1714 kExactMatchUtf16LengthFieldNumber = 7,
1715 kWindowUtf16PositionFieldNumber = 8,
1716 kWindowUtf16LengthFieldNumber = 9,
1717 kSubmatchByteLengthFieldNumber = 10,
1718 kSubmatchUtf16LengthFieldNumber = 11,
1719 };
1720 // optional int32 exact_match_byte_position = 2;
1721 bool has_exact_match_byte_position() const;
1722 private:
1723 bool _internal_has_exact_match_byte_position() const;
1724 public:
1725 void clear_exact_match_byte_position();
1726 ::int32_t exact_match_byte_position() const;
1727 void set_exact_match_byte_position(::int32_t value);
1728 private:
1729 ::int32_t _internal_exact_match_byte_position() const;
1730 void _internal_set_exact_match_byte_position(::int32_t value);
1731 public:
1732
1733 // optional int32 exact_match_byte_length = 3;
1734 bool has_exact_match_byte_length() const;
1735 private:
1736 bool _internal_has_exact_match_byte_length() const;
1737 public:
1738 void clear_exact_match_byte_length();
1739 ::int32_t exact_match_byte_length() const;
1740 void set_exact_match_byte_length(::int32_t value);
1741 private:
1742 ::int32_t _internal_exact_match_byte_length() const;
1743 void _internal_set_exact_match_byte_length(::int32_t value);
1744 public:
1745
1746 // optional int32 window_byte_position = 4;
1747 bool has_window_byte_position() const;
1748 private:
1749 bool _internal_has_window_byte_position() const;
1750 public:
1751 void clear_window_byte_position();
1752 ::int32_t window_byte_position() const;
1753 void set_window_byte_position(::int32_t value);
1754 private:
1755 ::int32_t _internal_window_byte_position() const;
1756 void _internal_set_window_byte_position(::int32_t value);
1757 public:
1758
1759 // optional int32 window_byte_length = 5;
1760 bool has_window_byte_length() const;
1761 private:
1762 bool _internal_has_window_byte_length() const;
1763 public:
1764 void clear_window_byte_length();
1765 ::int32_t window_byte_length() const;
1766 void set_window_byte_length(::int32_t value);
1767 private:
1768 ::int32_t _internal_window_byte_length() const;
1769 void _internal_set_window_byte_length(::int32_t value);
1770 public:
1771
1772 // optional int32 exact_match_utf16_position = 6;
1773 bool has_exact_match_utf16_position() const;
1774 private:
1775 bool _internal_has_exact_match_utf16_position() const;
1776 public:
1777 void clear_exact_match_utf16_position();
1778 ::int32_t exact_match_utf16_position() const;
1779 void set_exact_match_utf16_position(::int32_t value);
1780 private:
1781 ::int32_t _internal_exact_match_utf16_position() const;
1782 void _internal_set_exact_match_utf16_position(::int32_t value);
1783 public:
1784
1785 // optional int32 exact_match_utf16_length = 7;
1786 bool has_exact_match_utf16_length() const;
1787 private:
1788 bool _internal_has_exact_match_utf16_length() const;
1789 public:
1790 void clear_exact_match_utf16_length();
1791 ::int32_t exact_match_utf16_length() const;
1792 void set_exact_match_utf16_length(::int32_t value);
1793 private:
1794 ::int32_t _internal_exact_match_utf16_length() const;
1795 void _internal_set_exact_match_utf16_length(::int32_t value);
1796 public:
1797
1798 // optional int32 window_utf16_position = 8;
1799 bool has_window_utf16_position() const;
1800 private:
1801 bool _internal_has_window_utf16_position() const;
1802 public:
1803 void clear_window_utf16_position();
1804 ::int32_t window_utf16_position() const;
1805 void set_window_utf16_position(::int32_t value);
1806 private:
1807 ::int32_t _internal_window_utf16_position() const;
1808 void _internal_set_window_utf16_position(::int32_t value);
1809 public:
1810
1811 // optional int32 window_utf16_length = 9;
1812 bool has_window_utf16_length() const;
1813 private:
1814 bool _internal_has_window_utf16_length() const;
1815 public:
1816 void clear_window_utf16_length();
1817 ::int32_t window_utf16_length() const;
1818 void set_window_utf16_length(::int32_t value);
1819 private:
1820 ::int32_t _internal_window_utf16_length() const;
1821 void _internal_set_window_utf16_length(::int32_t value);
1822 public:
1823
1824 // optional int32 submatch_byte_length = 10;
1825 bool has_submatch_byte_length() const;
1826 private:
1827 bool _internal_has_submatch_byte_length() const;
1828 public:
1829 void clear_submatch_byte_length();
1830 ::int32_t submatch_byte_length() const;
1831 void set_submatch_byte_length(::int32_t value);
1832 private:
1833 ::int32_t _internal_submatch_byte_length() const;
1834 void _internal_set_submatch_byte_length(::int32_t value);
1835 public:
1836
1837 // optional int32 submatch_utf16_length = 11;
1838 bool has_submatch_utf16_length() const;
1839 private:
1840 bool _internal_has_submatch_utf16_length() const;
1841 public:
1842 void clear_submatch_utf16_length();
1843 ::int32_t submatch_utf16_length() const;
1844 void set_submatch_utf16_length(::int32_t value);
1845 private:
1846 ::int32_t _internal_submatch_utf16_length() const;
1847 void _internal_set_submatch_utf16_length(::int32_t value);
1848 public:
1849
1850 // @@protoc_insertion_point(class_scope:icing.lib.SnippetMatchProto)
1851 private:
1852 class _Internal;
1853
1854 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1855 typedef void InternalArenaConstructable_;
1856 typedef void DestructorSkippable_;
1857 struct Impl_ {
1858 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
1859 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1860 ::int32_t exact_match_byte_position_;
1861 ::int32_t exact_match_byte_length_;
1862 ::int32_t window_byte_position_;
1863 ::int32_t window_byte_length_;
1864 ::int32_t exact_match_utf16_position_;
1865 ::int32_t exact_match_utf16_length_;
1866 ::int32_t window_utf16_position_;
1867 ::int32_t window_utf16_length_;
1868 ::int32_t submatch_byte_length_;
1869 ::int32_t submatch_utf16_length_;
1870 };
1871 union { Impl_ _impl_; };
1872 friend struct ::TableStruct_icing_2fproto_2fsearch_2eproto;
1873 };
1874 // -------------------------------------------------------------------
1875
1876 class SnippetProto_EntryProto final :
1877 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:icing.lib.SnippetProto.EntryProto) */ {
1878 public:
SnippetProto_EntryProto()1879 inline SnippetProto_EntryProto() : SnippetProto_EntryProto(nullptr) {}
1880 ~SnippetProto_EntryProto() override;
1881 explicit PROTOBUF_CONSTEXPR SnippetProto_EntryProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1882
1883 SnippetProto_EntryProto(const SnippetProto_EntryProto& from);
SnippetProto_EntryProto(SnippetProto_EntryProto && from)1884 SnippetProto_EntryProto(SnippetProto_EntryProto&& from) noexcept
1885 : SnippetProto_EntryProto() {
1886 *this = ::std::move(from);
1887 }
1888
1889 inline SnippetProto_EntryProto& operator=(const SnippetProto_EntryProto& from) {
1890 if (this == &from) return *this;
1891 CopyFrom(from);
1892 return *this;
1893 }
1894 inline SnippetProto_EntryProto& operator=(SnippetProto_EntryProto&& from) noexcept {
1895 if (this == &from) return *this;
1896 if (GetOwningArena() == from.GetOwningArena()
1897 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1898 && GetOwningArena() != nullptr
1899 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
1900 ) {
1901 InternalSwap(&from);
1902 } else {
1903 CopyFrom(from);
1904 }
1905 return *this;
1906 }
1907
unknown_fields()1908 inline const std::string& unknown_fields() const {
1909 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
1910 }
mutable_unknown_fields()1911 inline std::string* mutable_unknown_fields() {
1912 return _internal_metadata_.mutable_unknown_fields<std::string>();
1913 }
1914
default_instance()1915 static const SnippetProto_EntryProto& default_instance() {
1916 return *internal_default_instance();
1917 }
internal_default_instance()1918 static inline const SnippetProto_EntryProto* internal_default_instance() {
1919 return reinterpret_cast<const SnippetProto_EntryProto*>(
1920 &_SnippetProto_EntryProto_default_instance_);
1921 }
1922 static constexpr int kIndexInFileMessages =
1923 7;
1924
swap(SnippetProto_EntryProto & a,SnippetProto_EntryProto & b)1925 friend void swap(SnippetProto_EntryProto& a, SnippetProto_EntryProto& b) {
1926 a.Swap(&b);
1927 }
Swap(SnippetProto_EntryProto * other)1928 inline void Swap(SnippetProto_EntryProto* other) {
1929 if (other == this) return;
1930 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1931 if (GetOwningArena() != nullptr &&
1932 GetOwningArena() == other->GetOwningArena()) {
1933 #else // PROTOBUF_FORCE_COPY_IN_SWAP
1934 if (GetOwningArena() == other->GetOwningArena()) {
1935 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
1936 InternalSwap(other);
1937 } else {
1938 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1939 }
1940 }
1941 void UnsafeArenaSwap(SnippetProto_EntryProto* other) {
1942 if (other == this) return;
1943 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1944 InternalSwap(other);
1945 }
1946
1947 // implements Message ----------------------------------------------
1948
1949 SnippetProto_EntryProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1950 return CreateMaybeMessage<SnippetProto_EntryProto>(arena);
1951 }
1952 SnippetProto_EntryProto* New() const {
1953 return New(nullptr);
1954 }
1955 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
1956 void CopyFrom(const SnippetProto_EntryProto& from);
1957 void MergeFrom(const SnippetProto_EntryProto& from);
1958 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1959 bool IsInitialized() const final;
1960
1961 size_t ByteSizeLong() const final;
1962 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1963 ::uint8_t* _InternalSerialize(
1964 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1965 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1966
1967 private:
1968 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1969 void SharedDtor();
1970 void SetCachedSize(int size) const;
1971 void InternalSwap(SnippetProto_EntryProto* other);
1972
1973 private:
1974 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1975 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1976 return "icing.lib.SnippetProto.EntryProto";
1977 }
1978 protected:
1979 explicit SnippetProto_EntryProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1980 bool is_message_owned = false);
1981 public:
1982
1983 std::string GetTypeName() const final;
1984
1985 // nested types ----------------------------------------------------
1986
1987 // accessors -------------------------------------------------------
1988
1989 enum : int {
1990 kSnippetMatchesFieldNumber = 2,
1991 kPropertyNameFieldNumber = 1,
1992 };
1993 // repeated .icing.lib.SnippetMatchProto snippet_matches = 2;
1994 int snippet_matches_size() const;
1995 private:
1996 int _internal_snippet_matches_size() const;
1997 public:
1998 void clear_snippet_matches();
1999 ::icing::lib::SnippetMatchProto* mutable_snippet_matches(int index);
2000 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::SnippetMatchProto >*
2001 mutable_snippet_matches();
2002 private:
2003 const ::icing::lib::SnippetMatchProto& _internal_snippet_matches(int index) const;
2004 ::icing::lib::SnippetMatchProto* _internal_add_snippet_matches();
2005 public:
2006 const ::icing::lib::SnippetMatchProto& snippet_matches(int index) const;
2007 ::icing::lib::SnippetMatchProto* add_snippet_matches();
2008 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::SnippetMatchProto >&
2009 snippet_matches() const;
2010
2011 // optional string property_name = 1;
2012 bool has_property_name() const;
2013 private:
2014 bool _internal_has_property_name() const;
2015 public:
2016 void clear_property_name();
2017 const std::string& property_name() const;
2018 template <typename ArgT0 = const std::string&, typename... ArgT>
2019 void set_property_name(ArgT0&& arg0, ArgT... args);
2020 std::string* mutable_property_name();
2021 PROTOBUF_NODISCARD std::string* release_property_name();
2022 void set_allocated_property_name(std::string* property_name);
2023 private:
2024 const std::string& _internal_property_name() const;
2025 inline PROTOBUF_ALWAYS_INLINE void _internal_set_property_name(const std::string& value);
2026 std::string* _internal_mutable_property_name();
2027 public:
2028
2029 // @@protoc_insertion_point(class_scope:icing.lib.SnippetProto.EntryProto)
2030 private:
2031 class _Internal;
2032
2033 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
2034 typedef void InternalArenaConstructable_;
2035 typedef void DestructorSkippable_;
2036 struct Impl_ {
2037 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
2038 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2039 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::SnippetMatchProto > snippet_matches_;
2040 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr property_name_;
2041 };
2042 union { Impl_ _impl_; };
2043 friend struct ::TableStruct_icing_2fproto_2fsearch_2eproto;
2044 };
2045 // -------------------------------------------------------------------
2046
2047 class SnippetProto final :
2048 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:icing.lib.SnippetProto) */ {
2049 public:
SnippetProto()2050 inline SnippetProto() : SnippetProto(nullptr) {}
2051 ~SnippetProto() override;
2052 explicit PROTOBUF_CONSTEXPR SnippetProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
2053
2054 SnippetProto(const SnippetProto& from);
SnippetProto(SnippetProto && from)2055 SnippetProto(SnippetProto&& from) noexcept
2056 : SnippetProto() {
2057 *this = ::std::move(from);
2058 }
2059
2060 inline SnippetProto& operator=(const SnippetProto& from) {
2061 if (this == &from) return *this;
2062 CopyFrom(from);
2063 return *this;
2064 }
2065 inline SnippetProto& operator=(SnippetProto&& from) noexcept {
2066 if (this == &from) return *this;
2067 if (GetOwningArena() == from.GetOwningArena()
2068 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
2069 && GetOwningArena() != nullptr
2070 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
2071 ) {
2072 InternalSwap(&from);
2073 } else {
2074 CopyFrom(from);
2075 }
2076 return *this;
2077 }
2078
unknown_fields()2079 inline const std::string& unknown_fields() const {
2080 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
2081 }
mutable_unknown_fields()2082 inline std::string* mutable_unknown_fields() {
2083 return _internal_metadata_.mutable_unknown_fields<std::string>();
2084 }
2085
default_instance()2086 static const SnippetProto& default_instance() {
2087 return *internal_default_instance();
2088 }
internal_default_instance()2089 static inline const SnippetProto* internal_default_instance() {
2090 return reinterpret_cast<const SnippetProto*>(
2091 &_SnippetProto_default_instance_);
2092 }
2093 static constexpr int kIndexInFileMessages =
2094 8;
2095
swap(SnippetProto & a,SnippetProto & b)2096 friend void swap(SnippetProto& a, SnippetProto& b) {
2097 a.Swap(&b);
2098 }
Swap(SnippetProto * other)2099 inline void Swap(SnippetProto* other) {
2100 if (other == this) return;
2101 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
2102 if (GetOwningArena() != nullptr &&
2103 GetOwningArena() == other->GetOwningArena()) {
2104 #else // PROTOBUF_FORCE_COPY_IN_SWAP
2105 if (GetOwningArena() == other->GetOwningArena()) {
2106 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
2107 InternalSwap(other);
2108 } else {
2109 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
2110 }
2111 }
2112 void UnsafeArenaSwap(SnippetProto* other) {
2113 if (other == this) return;
2114 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
2115 InternalSwap(other);
2116 }
2117
2118 // implements Message ----------------------------------------------
2119
2120 SnippetProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
2121 return CreateMaybeMessage<SnippetProto>(arena);
2122 }
2123 SnippetProto* New() const {
2124 return New(nullptr);
2125 }
2126 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
2127 void CopyFrom(const SnippetProto& from);
2128 void MergeFrom(const SnippetProto& from);
2129 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
2130 bool IsInitialized() const final;
2131
2132 size_t ByteSizeLong() const final;
2133 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
2134 ::uint8_t* _InternalSerialize(
2135 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
2136 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
2137
2138 private:
2139 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
2140 void SharedDtor();
2141 void SetCachedSize(int size) const;
2142 void InternalSwap(SnippetProto* other);
2143
2144 private:
2145 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
2146 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
2147 return "icing.lib.SnippetProto";
2148 }
2149 protected:
2150 explicit SnippetProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2151 bool is_message_owned = false);
2152 public:
2153
2154 std::string GetTypeName() const final;
2155
2156 // nested types ----------------------------------------------------
2157
2158 typedef SnippetProto_EntryProto EntryProto;
2159
2160 // accessors -------------------------------------------------------
2161
2162 enum : int {
2163 kEntriesFieldNumber = 1,
2164 };
2165 // repeated .icing.lib.SnippetProto.EntryProto entries = 1;
2166 int entries_size() const;
2167 private:
2168 int _internal_entries_size() const;
2169 public:
2170 void clear_entries();
2171 ::icing::lib::SnippetProto_EntryProto* mutable_entries(int index);
2172 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::SnippetProto_EntryProto >*
2173 mutable_entries();
2174 private:
2175 const ::icing::lib::SnippetProto_EntryProto& _internal_entries(int index) const;
2176 ::icing::lib::SnippetProto_EntryProto* _internal_add_entries();
2177 public:
2178 const ::icing::lib::SnippetProto_EntryProto& entries(int index) const;
2179 ::icing::lib::SnippetProto_EntryProto* add_entries();
2180 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::SnippetProto_EntryProto >&
2181 entries() const;
2182
2183 // @@protoc_insertion_point(class_scope:icing.lib.SnippetProto)
2184 private:
2185 class _Internal;
2186
2187 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
2188 typedef void InternalArenaConstructable_;
2189 typedef void DestructorSkippable_;
2190 struct Impl_ {
2191 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::SnippetProto_EntryProto > entries_;
2192 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2193 };
2194 union { Impl_ _impl_; };
2195 friend struct ::TableStruct_icing_2fproto_2fsearch_2eproto;
2196 };
2197 // -------------------------------------------------------------------
2198
2199 class SearchResultProto_ResultProto final :
2200 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:icing.lib.SearchResultProto.ResultProto) */ {
2201 public:
SearchResultProto_ResultProto()2202 inline SearchResultProto_ResultProto() : SearchResultProto_ResultProto(nullptr) {}
2203 ~SearchResultProto_ResultProto() override;
2204 explicit PROTOBUF_CONSTEXPR SearchResultProto_ResultProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
2205
2206 SearchResultProto_ResultProto(const SearchResultProto_ResultProto& from);
SearchResultProto_ResultProto(SearchResultProto_ResultProto && from)2207 SearchResultProto_ResultProto(SearchResultProto_ResultProto&& from) noexcept
2208 : SearchResultProto_ResultProto() {
2209 *this = ::std::move(from);
2210 }
2211
2212 inline SearchResultProto_ResultProto& operator=(const SearchResultProto_ResultProto& from) {
2213 if (this == &from) return *this;
2214 CopyFrom(from);
2215 return *this;
2216 }
2217 inline SearchResultProto_ResultProto& operator=(SearchResultProto_ResultProto&& from) noexcept {
2218 if (this == &from) return *this;
2219 if (GetOwningArena() == from.GetOwningArena()
2220 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
2221 && GetOwningArena() != nullptr
2222 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
2223 ) {
2224 InternalSwap(&from);
2225 } else {
2226 CopyFrom(from);
2227 }
2228 return *this;
2229 }
2230
unknown_fields()2231 inline const std::string& unknown_fields() const {
2232 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
2233 }
mutable_unknown_fields()2234 inline std::string* mutable_unknown_fields() {
2235 return _internal_metadata_.mutable_unknown_fields<std::string>();
2236 }
2237
default_instance()2238 static const SearchResultProto_ResultProto& default_instance() {
2239 return *internal_default_instance();
2240 }
internal_default_instance()2241 static inline const SearchResultProto_ResultProto* internal_default_instance() {
2242 return reinterpret_cast<const SearchResultProto_ResultProto*>(
2243 &_SearchResultProto_ResultProto_default_instance_);
2244 }
2245 static constexpr int kIndexInFileMessages =
2246 9;
2247
swap(SearchResultProto_ResultProto & a,SearchResultProto_ResultProto & b)2248 friend void swap(SearchResultProto_ResultProto& a, SearchResultProto_ResultProto& b) {
2249 a.Swap(&b);
2250 }
Swap(SearchResultProto_ResultProto * other)2251 inline void Swap(SearchResultProto_ResultProto* other) {
2252 if (other == this) return;
2253 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
2254 if (GetOwningArena() != nullptr &&
2255 GetOwningArena() == other->GetOwningArena()) {
2256 #else // PROTOBUF_FORCE_COPY_IN_SWAP
2257 if (GetOwningArena() == other->GetOwningArena()) {
2258 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
2259 InternalSwap(other);
2260 } else {
2261 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
2262 }
2263 }
2264 void UnsafeArenaSwap(SearchResultProto_ResultProto* other) {
2265 if (other == this) return;
2266 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
2267 InternalSwap(other);
2268 }
2269
2270 // implements Message ----------------------------------------------
2271
2272 SearchResultProto_ResultProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
2273 return CreateMaybeMessage<SearchResultProto_ResultProto>(arena);
2274 }
2275 SearchResultProto_ResultProto* New() const {
2276 return New(nullptr);
2277 }
2278 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
2279 void CopyFrom(const SearchResultProto_ResultProto& from);
2280 void MergeFrom(const SearchResultProto_ResultProto& from);
2281 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
2282 bool IsInitialized() const final;
2283
2284 size_t ByteSizeLong() const final;
2285 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
2286 ::uint8_t* _InternalSerialize(
2287 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
2288 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
2289
2290 private:
2291 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
2292 void SharedDtor();
2293 void SetCachedSize(int size) const;
2294 void InternalSwap(SearchResultProto_ResultProto* other);
2295
2296 private:
2297 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
2298 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
2299 return "icing.lib.SearchResultProto.ResultProto";
2300 }
2301 protected:
2302 explicit SearchResultProto_ResultProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2303 bool is_message_owned = false);
2304 public:
2305
2306 std::string GetTypeName() const final;
2307
2308 // nested types ----------------------------------------------------
2309
2310 // accessors -------------------------------------------------------
2311
2312 enum : int {
2313 kJoinedResultsFieldNumber = 4,
2314 kAdditionalScoresFieldNumber = 5,
2315 kDocumentFieldNumber = 1,
2316 kSnippetFieldNumber = 2,
2317 kScoreFieldNumber = 3,
2318 };
2319 // repeated .icing.lib.SearchResultProto.ResultProto joined_results = 4;
2320 int joined_results_size() const;
2321 private:
2322 int _internal_joined_results_size() const;
2323 public:
2324 void clear_joined_results();
2325 ::icing::lib::SearchResultProto_ResultProto* mutable_joined_results(int index);
2326 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::SearchResultProto_ResultProto >*
2327 mutable_joined_results();
2328 private:
2329 const ::icing::lib::SearchResultProto_ResultProto& _internal_joined_results(int index) const;
2330 ::icing::lib::SearchResultProto_ResultProto* _internal_add_joined_results();
2331 public:
2332 const ::icing::lib::SearchResultProto_ResultProto& joined_results(int index) const;
2333 ::icing::lib::SearchResultProto_ResultProto* add_joined_results();
2334 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::SearchResultProto_ResultProto >&
2335 joined_results() const;
2336
2337 // repeated double additional_scores = 5 [packed = true];
2338 int additional_scores_size() const;
2339 private:
2340 int _internal_additional_scores_size() const;
2341 public:
2342 void clear_additional_scores();
2343 private:
2344 double _internal_additional_scores(int index) const;
2345 const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
2346 _internal_additional_scores() const;
2347 void _internal_add_additional_scores(double value);
2348 ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
2349 _internal_mutable_additional_scores();
2350 public:
2351 double additional_scores(int index) const;
2352 void set_additional_scores(int index, double value);
2353 void add_additional_scores(double value);
2354 const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
2355 additional_scores() const;
2356 ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
2357 mutable_additional_scores();
2358
2359 // optional .icing.lib.DocumentProto document = 1;
2360 bool has_document() const;
2361 private:
2362 bool _internal_has_document() const;
2363 public:
2364 void clear_document();
2365 const ::icing::lib::DocumentProto& document() const;
2366 PROTOBUF_NODISCARD ::icing::lib::DocumentProto* release_document();
2367 ::icing::lib::DocumentProto* mutable_document();
2368 void set_allocated_document(::icing::lib::DocumentProto* document);
2369 private:
2370 const ::icing::lib::DocumentProto& _internal_document() const;
2371 ::icing::lib::DocumentProto* _internal_mutable_document();
2372 public:
2373 void unsafe_arena_set_allocated_document(
2374 ::icing::lib::DocumentProto* document);
2375 ::icing::lib::DocumentProto* unsafe_arena_release_document();
2376
2377 // optional .icing.lib.SnippetProto snippet = 2;
2378 bool has_snippet() const;
2379 private:
2380 bool _internal_has_snippet() const;
2381 public:
2382 void clear_snippet();
2383 const ::icing::lib::SnippetProto& snippet() const;
2384 PROTOBUF_NODISCARD ::icing::lib::SnippetProto* release_snippet();
2385 ::icing::lib::SnippetProto* mutable_snippet();
2386 void set_allocated_snippet(::icing::lib::SnippetProto* snippet);
2387 private:
2388 const ::icing::lib::SnippetProto& _internal_snippet() const;
2389 ::icing::lib::SnippetProto* _internal_mutable_snippet();
2390 public:
2391 void unsafe_arena_set_allocated_snippet(
2392 ::icing::lib::SnippetProto* snippet);
2393 ::icing::lib::SnippetProto* unsafe_arena_release_snippet();
2394
2395 // optional double score = 3;
2396 bool has_score() const;
2397 private:
2398 bool _internal_has_score() const;
2399 public:
2400 void clear_score();
2401 double score() const;
2402 void set_score(double value);
2403 private:
2404 double _internal_score() const;
2405 void _internal_set_score(double value);
2406 public:
2407
2408 // @@protoc_insertion_point(class_scope:icing.lib.SearchResultProto.ResultProto)
2409 private:
2410 class _Internal;
2411
2412 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
2413 typedef void InternalArenaConstructable_;
2414 typedef void DestructorSkippable_;
2415 struct Impl_ {
2416 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
2417 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2418 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::SearchResultProto_ResultProto > joined_results_;
2419 ::PROTOBUF_NAMESPACE_ID::RepeatedField< double > additional_scores_;
2420 ::icing::lib::DocumentProto* document_;
2421 ::icing::lib::SnippetProto* snippet_;
2422 double score_;
2423 };
2424 union { Impl_ _impl_; };
2425 friend struct ::TableStruct_icing_2fproto_2fsearch_2eproto;
2426 };
2427 // -------------------------------------------------------------------
2428
2429 class SearchResultProto_DebugInfoProto final :
2430 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:icing.lib.SearchResultProto.DebugInfoProto) */ {
2431 public:
SearchResultProto_DebugInfoProto()2432 inline SearchResultProto_DebugInfoProto() : SearchResultProto_DebugInfoProto(nullptr) {}
2433 ~SearchResultProto_DebugInfoProto() override;
2434 explicit PROTOBUF_CONSTEXPR SearchResultProto_DebugInfoProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
2435
2436 SearchResultProto_DebugInfoProto(const SearchResultProto_DebugInfoProto& from);
SearchResultProto_DebugInfoProto(SearchResultProto_DebugInfoProto && from)2437 SearchResultProto_DebugInfoProto(SearchResultProto_DebugInfoProto&& from) noexcept
2438 : SearchResultProto_DebugInfoProto() {
2439 *this = ::std::move(from);
2440 }
2441
2442 inline SearchResultProto_DebugInfoProto& operator=(const SearchResultProto_DebugInfoProto& from) {
2443 if (this == &from) return *this;
2444 CopyFrom(from);
2445 return *this;
2446 }
2447 inline SearchResultProto_DebugInfoProto& operator=(SearchResultProto_DebugInfoProto&& from) noexcept {
2448 if (this == &from) return *this;
2449 if (GetOwningArena() == from.GetOwningArena()
2450 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
2451 && GetOwningArena() != nullptr
2452 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
2453 ) {
2454 InternalSwap(&from);
2455 } else {
2456 CopyFrom(from);
2457 }
2458 return *this;
2459 }
2460
unknown_fields()2461 inline const std::string& unknown_fields() const {
2462 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
2463 }
mutable_unknown_fields()2464 inline std::string* mutable_unknown_fields() {
2465 return _internal_metadata_.mutable_unknown_fields<std::string>();
2466 }
2467
default_instance()2468 static const SearchResultProto_DebugInfoProto& default_instance() {
2469 return *internal_default_instance();
2470 }
internal_default_instance()2471 static inline const SearchResultProto_DebugInfoProto* internal_default_instance() {
2472 return reinterpret_cast<const SearchResultProto_DebugInfoProto*>(
2473 &_SearchResultProto_DebugInfoProto_default_instance_);
2474 }
2475 static constexpr int kIndexInFileMessages =
2476 10;
2477
swap(SearchResultProto_DebugInfoProto & a,SearchResultProto_DebugInfoProto & b)2478 friend void swap(SearchResultProto_DebugInfoProto& a, SearchResultProto_DebugInfoProto& b) {
2479 a.Swap(&b);
2480 }
Swap(SearchResultProto_DebugInfoProto * other)2481 inline void Swap(SearchResultProto_DebugInfoProto* other) {
2482 if (other == this) return;
2483 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
2484 if (GetOwningArena() != nullptr &&
2485 GetOwningArena() == other->GetOwningArena()) {
2486 #else // PROTOBUF_FORCE_COPY_IN_SWAP
2487 if (GetOwningArena() == other->GetOwningArena()) {
2488 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
2489 InternalSwap(other);
2490 } else {
2491 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
2492 }
2493 }
2494 void UnsafeArenaSwap(SearchResultProto_DebugInfoProto* other) {
2495 if (other == this) return;
2496 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
2497 InternalSwap(other);
2498 }
2499
2500 // implements Message ----------------------------------------------
2501
2502 SearchResultProto_DebugInfoProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
2503 return CreateMaybeMessage<SearchResultProto_DebugInfoProto>(arena);
2504 }
2505 SearchResultProto_DebugInfoProto* New() const {
2506 return New(nullptr);
2507 }
2508 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
2509 void CopyFrom(const SearchResultProto_DebugInfoProto& from);
2510 void MergeFrom(const SearchResultProto_DebugInfoProto& from);
2511 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
2512 bool IsInitialized() const final;
2513
2514 size_t ByteSizeLong() const final;
2515 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
2516 ::uint8_t* _InternalSerialize(
2517 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
2518 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
2519
2520 private:
2521 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
2522 void SharedDtor();
2523 void SetCachedSize(int size) const;
2524 void InternalSwap(SearchResultProto_DebugInfoProto* other);
2525
2526 private:
2527 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
2528 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
2529 return "icing.lib.SearchResultProto.DebugInfoProto";
2530 }
2531 protected:
2532 explicit SearchResultProto_DebugInfoProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2533 bool is_message_owned = false);
2534 public:
2535
2536 std::string GetTypeName() const final;
2537
2538 // nested types ----------------------------------------------------
2539
2540 // accessors -------------------------------------------------------
2541
2542 enum : int {
2543 kExecutedQueryFieldNumber = 3,
2544 };
2545 // optional string executed_query = 3;
2546 bool has_executed_query() const;
2547 private:
2548 bool _internal_has_executed_query() const;
2549 public:
2550 void clear_executed_query();
2551 const std::string& executed_query() const;
2552 template <typename ArgT0 = const std::string&, typename... ArgT>
2553 void set_executed_query(ArgT0&& arg0, ArgT... args);
2554 std::string* mutable_executed_query();
2555 PROTOBUF_NODISCARD std::string* release_executed_query();
2556 void set_allocated_executed_query(std::string* executed_query);
2557 private:
2558 const std::string& _internal_executed_query() const;
2559 inline PROTOBUF_ALWAYS_INLINE void _internal_set_executed_query(const std::string& value);
2560 std::string* _internal_mutable_executed_query();
2561 public:
2562
2563 // @@protoc_insertion_point(class_scope:icing.lib.SearchResultProto.DebugInfoProto)
2564 private:
2565 class _Internal;
2566
2567 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
2568 typedef void InternalArenaConstructable_;
2569 typedef void DestructorSkippable_;
2570 struct Impl_ {
2571 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
2572 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2573 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr executed_query_;
2574 };
2575 union { Impl_ _impl_; };
2576 friend struct ::TableStruct_icing_2fproto_2fsearch_2eproto;
2577 };
2578 // -------------------------------------------------------------------
2579
2580 class SearchResultProto final :
2581 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:icing.lib.SearchResultProto) */ {
2582 public:
SearchResultProto()2583 inline SearchResultProto() : SearchResultProto(nullptr) {}
2584 ~SearchResultProto() override;
2585 explicit PROTOBUF_CONSTEXPR SearchResultProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
2586
2587 SearchResultProto(const SearchResultProto& from);
SearchResultProto(SearchResultProto && from)2588 SearchResultProto(SearchResultProto&& from) noexcept
2589 : SearchResultProto() {
2590 *this = ::std::move(from);
2591 }
2592
2593 inline SearchResultProto& operator=(const SearchResultProto& from) {
2594 if (this == &from) return *this;
2595 CopyFrom(from);
2596 return *this;
2597 }
2598 inline SearchResultProto& operator=(SearchResultProto&& from) noexcept {
2599 if (this == &from) return *this;
2600 if (GetOwningArena() == from.GetOwningArena()
2601 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
2602 && GetOwningArena() != nullptr
2603 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
2604 ) {
2605 InternalSwap(&from);
2606 } else {
2607 CopyFrom(from);
2608 }
2609 return *this;
2610 }
2611
unknown_fields()2612 inline const std::string& unknown_fields() const {
2613 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
2614 }
mutable_unknown_fields()2615 inline std::string* mutable_unknown_fields() {
2616 return _internal_metadata_.mutable_unknown_fields<std::string>();
2617 }
2618
default_instance()2619 static const SearchResultProto& default_instance() {
2620 return *internal_default_instance();
2621 }
internal_default_instance()2622 static inline const SearchResultProto* internal_default_instance() {
2623 return reinterpret_cast<const SearchResultProto*>(
2624 &_SearchResultProto_default_instance_);
2625 }
2626 static constexpr int kIndexInFileMessages =
2627 11;
2628
swap(SearchResultProto & a,SearchResultProto & b)2629 friend void swap(SearchResultProto& a, SearchResultProto& b) {
2630 a.Swap(&b);
2631 }
Swap(SearchResultProto * other)2632 inline void Swap(SearchResultProto* other) {
2633 if (other == this) return;
2634 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
2635 if (GetOwningArena() != nullptr &&
2636 GetOwningArena() == other->GetOwningArena()) {
2637 #else // PROTOBUF_FORCE_COPY_IN_SWAP
2638 if (GetOwningArena() == other->GetOwningArena()) {
2639 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
2640 InternalSwap(other);
2641 } else {
2642 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
2643 }
2644 }
2645 void UnsafeArenaSwap(SearchResultProto* other) {
2646 if (other == this) return;
2647 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
2648 InternalSwap(other);
2649 }
2650
2651 // implements Message ----------------------------------------------
2652
2653 SearchResultProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
2654 return CreateMaybeMessage<SearchResultProto>(arena);
2655 }
2656 SearchResultProto* New() const {
2657 return New(nullptr);
2658 }
2659 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
2660 void CopyFrom(const SearchResultProto& from);
2661 void MergeFrom(const SearchResultProto& from);
2662 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
2663 bool IsInitialized() const final;
2664
2665 size_t ByteSizeLong() const final;
2666 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
2667 ::uint8_t* _InternalSerialize(
2668 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
2669 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
2670
2671 private:
2672 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
2673 void SharedDtor();
2674 void SetCachedSize(int size) const;
2675 void InternalSwap(SearchResultProto* other);
2676
2677 private:
2678 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
2679 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
2680 return "icing.lib.SearchResultProto";
2681 }
2682 protected:
2683 explicit SearchResultProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2684 bool is_message_owned = false);
2685 public:
2686
2687 std::string GetTypeName() const final;
2688
2689 // nested types ----------------------------------------------------
2690
2691 typedef SearchResultProto_ResultProto ResultProto;
2692 typedef SearchResultProto_DebugInfoProto DebugInfoProto;
2693
2694 // accessors -------------------------------------------------------
2695
2696 enum : int {
2697 kResultsFieldNumber = 2,
2698 kStatusFieldNumber = 1,
2699 kDebugInfoFieldNumber = 3,
2700 kQueryStatsFieldNumber = 5,
2701 kNextPageTokenFieldNumber = 4,
2702 };
2703 // repeated .icing.lib.SearchResultProto.ResultProto results = 2;
2704 int results_size() const;
2705 private:
2706 int _internal_results_size() const;
2707 public:
2708 void clear_results();
2709 ::icing::lib::SearchResultProto_ResultProto* mutable_results(int index);
2710 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::SearchResultProto_ResultProto >*
2711 mutable_results();
2712 private:
2713 const ::icing::lib::SearchResultProto_ResultProto& _internal_results(int index) const;
2714 ::icing::lib::SearchResultProto_ResultProto* _internal_add_results();
2715 public:
2716 const ::icing::lib::SearchResultProto_ResultProto& results(int index) const;
2717 ::icing::lib::SearchResultProto_ResultProto* add_results();
2718 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::SearchResultProto_ResultProto >&
2719 results() const;
2720
2721 // optional .icing.lib.StatusProto status = 1;
2722 bool has_status() const;
2723 private:
2724 bool _internal_has_status() const;
2725 public:
2726 void clear_status();
2727 const ::icing::lib::StatusProto& status() const;
2728 PROTOBUF_NODISCARD ::icing::lib::StatusProto* release_status();
2729 ::icing::lib::StatusProto* mutable_status();
2730 void set_allocated_status(::icing::lib::StatusProto* status);
2731 private:
2732 const ::icing::lib::StatusProto& _internal_status() const;
2733 ::icing::lib::StatusProto* _internal_mutable_status();
2734 public:
2735 void unsafe_arena_set_allocated_status(
2736 ::icing::lib::StatusProto* status);
2737 ::icing::lib::StatusProto* unsafe_arena_release_status();
2738
2739 // optional .icing.lib.SearchResultProto.DebugInfoProto debug_info = 3;
2740 bool has_debug_info() const;
2741 private:
2742 bool _internal_has_debug_info() const;
2743 public:
2744 void clear_debug_info();
2745 const ::icing::lib::SearchResultProto_DebugInfoProto& debug_info() const;
2746 PROTOBUF_NODISCARD ::icing::lib::SearchResultProto_DebugInfoProto* release_debug_info();
2747 ::icing::lib::SearchResultProto_DebugInfoProto* mutable_debug_info();
2748 void set_allocated_debug_info(::icing::lib::SearchResultProto_DebugInfoProto* debug_info);
2749 private:
2750 const ::icing::lib::SearchResultProto_DebugInfoProto& _internal_debug_info() const;
2751 ::icing::lib::SearchResultProto_DebugInfoProto* _internal_mutable_debug_info();
2752 public:
2753 void unsafe_arena_set_allocated_debug_info(
2754 ::icing::lib::SearchResultProto_DebugInfoProto* debug_info);
2755 ::icing::lib::SearchResultProto_DebugInfoProto* unsafe_arena_release_debug_info();
2756
2757 // optional .icing.lib.QueryStatsProto query_stats = 5;
2758 bool has_query_stats() const;
2759 private:
2760 bool _internal_has_query_stats() const;
2761 public:
2762 void clear_query_stats();
2763 const ::icing::lib::QueryStatsProto& query_stats() const;
2764 PROTOBUF_NODISCARD ::icing::lib::QueryStatsProto* release_query_stats();
2765 ::icing::lib::QueryStatsProto* mutable_query_stats();
2766 void set_allocated_query_stats(::icing::lib::QueryStatsProto* query_stats);
2767 private:
2768 const ::icing::lib::QueryStatsProto& _internal_query_stats() const;
2769 ::icing::lib::QueryStatsProto* _internal_mutable_query_stats();
2770 public:
2771 void unsafe_arena_set_allocated_query_stats(
2772 ::icing::lib::QueryStatsProto* query_stats);
2773 ::icing::lib::QueryStatsProto* unsafe_arena_release_query_stats();
2774
2775 // optional uint64 next_page_token = 4;
2776 bool has_next_page_token() const;
2777 private:
2778 bool _internal_has_next_page_token() const;
2779 public:
2780 void clear_next_page_token();
2781 ::uint64_t next_page_token() const;
2782 void set_next_page_token(::uint64_t value);
2783 private:
2784 ::uint64_t _internal_next_page_token() const;
2785 void _internal_set_next_page_token(::uint64_t value);
2786 public:
2787
2788 // @@protoc_insertion_point(class_scope:icing.lib.SearchResultProto)
2789 private:
2790 class _Internal;
2791
2792 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
2793 typedef void InternalArenaConstructable_;
2794 typedef void DestructorSkippable_;
2795 struct Impl_ {
2796 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
2797 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2798 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::SearchResultProto_ResultProto > results_;
2799 ::icing::lib::StatusProto* status_;
2800 ::icing::lib::SearchResultProto_DebugInfoProto* debug_info_;
2801 ::icing::lib::QueryStatsProto* query_stats_;
2802 ::uint64_t next_page_token_;
2803 };
2804 union { Impl_ _impl_; };
2805 friend struct ::TableStruct_icing_2fproto_2fsearch_2eproto;
2806 };
2807 // -------------------------------------------------------------------
2808
2809 class TypePropertyMask final :
2810 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:icing.lib.TypePropertyMask) */ {
2811 public:
TypePropertyMask()2812 inline TypePropertyMask() : TypePropertyMask(nullptr) {}
2813 ~TypePropertyMask() override;
2814 explicit PROTOBUF_CONSTEXPR TypePropertyMask(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
2815
2816 TypePropertyMask(const TypePropertyMask& from);
TypePropertyMask(TypePropertyMask && from)2817 TypePropertyMask(TypePropertyMask&& from) noexcept
2818 : TypePropertyMask() {
2819 *this = ::std::move(from);
2820 }
2821
2822 inline TypePropertyMask& operator=(const TypePropertyMask& from) {
2823 if (this == &from) return *this;
2824 CopyFrom(from);
2825 return *this;
2826 }
2827 inline TypePropertyMask& operator=(TypePropertyMask&& from) noexcept {
2828 if (this == &from) return *this;
2829 if (GetOwningArena() == from.GetOwningArena()
2830 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
2831 && GetOwningArena() != nullptr
2832 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
2833 ) {
2834 InternalSwap(&from);
2835 } else {
2836 CopyFrom(from);
2837 }
2838 return *this;
2839 }
2840
unknown_fields()2841 inline const std::string& unknown_fields() const {
2842 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
2843 }
mutable_unknown_fields()2844 inline std::string* mutable_unknown_fields() {
2845 return _internal_metadata_.mutable_unknown_fields<std::string>();
2846 }
2847
default_instance()2848 static const TypePropertyMask& default_instance() {
2849 return *internal_default_instance();
2850 }
internal_default_instance()2851 static inline const TypePropertyMask* internal_default_instance() {
2852 return reinterpret_cast<const TypePropertyMask*>(
2853 &_TypePropertyMask_default_instance_);
2854 }
2855 static constexpr int kIndexInFileMessages =
2856 12;
2857
swap(TypePropertyMask & a,TypePropertyMask & b)2858 friend void swap(TypePropertyMask& a, TypePropertyMask& b) {
2859 a.Swap(&b);
2860 }
Swap(TypePropertyMask * other)2861 inline void Swap(TypePropertyMask* other) {
2862 if (other == this) return;
2863 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
2864 if (GetOwningArena() != nullptr &&
2865 GetOwningArena() == other->GetOwningArena()) {
2866 #else // PROTOBUF_FORCE_COPY_IN_SWAP
2867 if (GetOwningArena() == other->GetOwningArena()) {
2868 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
2869 InternalSwap(other);
2870 } else {
2871 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
2872 }
2873 }
2874 void UnsafeArenaSwap(TypePropertyMask* other) {
2875 if (other == this) return;
2876 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
2877 InternalSwap(other);
2878 }
2879
2880 // implements Message ----------------------------------------------
2881
2882 TypePropertyMask* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
2883 return CreateMaybeMessage<TypePropertyMask>(arena);
2884 }
2885 TypePropertyMask* New() const {
2886 return New(nullptr);
2887 }
2888 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
2889 void CopyFrom(const TypePropertyMask& from);
2890 void MergeFrom(const TypePropertyMask& from);
2891 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
2892 bool IsInitialized() const final;
2893
2894 size_t ByteSizeLong() const final;
2895 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
2896 ::uint8_t* _InternalSerialize(
2897 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
2898 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
2899
2900 private:
2901 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
2902 void SharedDtor();
2903 void SetCachedSize(int size) const;
2904 void InternalSwap(TypePropertyMask* other);
2905
2906 private:
2907 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
2908 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
2909 return "icing.lib.TypePropertyMask";
2910 }
2911 protected:
2912 explicit TypePropertyMask(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2913 bool is_message_owned = false);
2914 public:
2915
2916 std::string GetTypeName() const final;
2917
2918 // nested types ----------------------------------------------------
2919
2920 // accessors -------------------------------------------------------
2921
2922 enum : int {
2923 kPathsFieldNumber = 2,
2924 kSchemaTypeFieldNumber = 1,
2925 };
2926 // repeated string paths = 2;
2927 int paths_size() const;
2928 private:
2929 int _internal_paths_size() const;
2930 public:
2931 void clear_paths();
2932 const std::string& paths(int index) const;
2933 std::string* mutable_paths(int index);
2934 void set_paths(int index, const std::string& value);
2935 void set_paths(int index, std::string&& value);
2936 void set_paths(int index, const char* value);
2937 void set_paths(int index, const char* value, size_t size);
2938 std::string* add_paths();
2939 void add_paths(const std::string& value);
2940 void add_paths(std::string&& value);
2941 void add_paths(const char* value);
2942 void add_paths(const char* value, size_t size);
2943 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& paths() const;
2944 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_paths();
2945 private:
2946 const std::string& _internal_paths(int index) const;
2947 std::string* _internal_add_paths();
2948 public:
2949
2950 // optional string schema_type = 1;
2951 bool has_schema_type() const;
2952 private:
2953 bool _internal_has_schema_type() const;
2954 public:
2955 void clear_schema_type();
2956 const std::string& schema_type() const;
2957 template <typename ArgT0 = const std::string&, typename... ArgT>
2958 void set_schema_type(ArgT0&& arg0, ArgT... args);
2959 std::string* mutable_schema_type();
2960 PROTOBUF_NODISCARD std::string* release_schema_type();
2961 void set_allocated_schema_type(std::string* schema_type);
2962 private:
2963 const std::string& _internal_schema_type() const;
2964 inline PROTOBUF_ALWAYS_INLINE void _internal_set_schema_type(const std::string& value);
2965 std::string* _internal_mutable_schema_type();
2966 public:
2967
2968 // @@protoc_insertion_point(class_scope:icing.lib.TypePropertyMask)
2969 private:
2970 class _Internal;
2971
2972 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
2973 typedef void InternalArenaConstructable_;
2974 typedef void DestructorSkippable_;
2975 struct Impl_ {
2976 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
2977 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2978 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> paths_;
2979 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr schema_type_;
2980 };
2981 union { Impl_ _impl_; };
2982 friend struct ::TableStruct_icing_2fproto_2fsearch_2eproto;
2983 };
2984 // -------------------------------------------------------------------
2985
2986 class GetResultSpecProto final :
2987 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:icing.lib.GetResultSpecProto) */ {
2988 public:
GetResultSpecProto()2989 inline GetResultSpecProto() : GetResultSpecProto(nullptr) {}
2990 ~GetResultSpecProto() override;
2991 explicit PROTOBUF_CONSTEXPR GetResultSpecProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
2992
2993 GetResultSpecProto(const GetResultSpecProto& from);
GetResultSpecProto(GetResultSpecProto && from)2994 GetResultSpecProto(GetResultSpecProto&& from) noexcept
2995 : GetResultSpecProto() {
2996 *this = ::std::move(from);
2997 }
2998
2999 inline GetResultSpecProto& operator=(const GetResultSpecProto& from) {
3000 if (this == &from) return *this;
3001 CopyFrom(from);
3002 return *this;
3003 }
3004 inline GetResultSpecProto& operator=(GetResultSpecProto&& from) noexcept {
3005 if (this == &from) return *this;
3006 if (GetOwningArena() == from.GetOwningArena()
3007 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
3008 && GetOwningArena() != nullptr
3009 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
3010 ) {
3011 InternalSwap(&from);
3012 } else {
3013 CopyFrom(from);
3014 }
3015 return *this;
3016 }
3017
unknown_fields()3018 inline const std::string& unknown_fields() const {
3019 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
3020 }
mutable_unknown_fields()3021 inline std::string* mutable_unknown_fields() {
3022 return _internal_metadata_.mutable_unknown_fields<std::string>();
3023 }
3024
default_instance()3025 static const GetResultSpecProto& default_instance() {
3026 return *internal_default_instance();
3027 }
internal_default_instance()3028 static inline const GetResultSpecProto* internal_default_instance() {
3029 return reinterpret_cast<const GetResultSpecProto*>(
3030 &_GetResultSpecProto_default_instance_);
3031 }
3032 static constexpr int kIndexInFileMessages =
3033 13;
3034
swap(GetResultSpecProto & a,GetResultSpecProto & b)3035 friend void swap(GetResultSpecProto& a, GetResultSpecProto& b) {
3036 a.Swap(&b);
3037 }
Swap(GetResultSpecProto * other)3038 inline void Swap(GetResultSpecProto* other) {
3039 if (other == this) return;
3040 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
3041 if (GetOwningArena() != nullptr &&
3042 GetOwningArena() == other->GetOwningArena()) {
3043 #else // PROTOBUF_FORCE_COPY_IN_SWAP
3044 if (GetOwningArena() == other->GetOwningArena()) {
3045 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
3046 InternalSwap(other);
3047 } else {
3048 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
3049 }
3050 }
3051 void UnsafeArenaSwap(GetResultSpecProto* other) {
3052 if (other == this) return;
3053 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
3054 InternalSwap(other);
3055 }
3056
3057 // implements Message ----------------------------------------------
3058
3059 GetResultSpecProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
3060 return CreateMaybeMessage<GetResultSpecProto>(arena);
3061 }
3062 GetResultSpecProto* New() const {
3063 return New(nullptr);
3064 }
3065 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
3066 void CopyFrom(const GetResultSpecProto& from);
3067 void MergeFrom(const GetResultSpecProto& from);
3068 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
3069 bool IsInitialized() const final;
3070
3071 size_t ByteSizeLong() const final;
3072 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
3073 ::uint8_t* _InternalSerialize(
3074 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
3075 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
3076
3077 private:
3078 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
3079 void SharedDtor();
3080 void SetCachedSize(int size) const;
3081 void InternalSwap(GetResultSpecProto* other);
3082
3083 private:
3084 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
3085 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
3086 return "icing.lib.GetResultSpecProto";
3087 }
3088 protected:
3089 explicit GetResultSpecProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
3090 bool is_message_owned = false);
3091 public:
3092
3093 std::string GetTypeName() const final;
3094
3095 // nested types ----------------------------------------------------
3096
3097 // accessors -------------------------------------------------------
3098
3099 enum : int {
3100 kTypePropertyMasksFieldNumber = 1,
3101 };
3102 // repeated .icing.lib.TypePropertyMask type_property_masks = 1;
3103 int type_property_masks_size() const;
3104 private:
3105 int _internal_type_property_masks_size() const;
3106 public:
3107 void clear_type_property_masks();
3108 ::icing::lib::TypePropertyMask* mutable_type_property_masks(int index);
3109 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::TypePropertyMask >*
3110 mutable_type_property_masks();
3111 private:
3112 const ::icing::lib::TypePropertyMask& _internal_type_property_masks(int index) const;
3113 ::icing::lib::TypePropertyMask* _internal_add_type_property_masks();
3114 public:
3115 const ::icing::lib::TypePropertyMask& type_property_masks(int index) const;
3116 ::icing::lib::TypePropertyMask* add_type_property_masks();
3117 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::TypePropertyMask >&
3118 type_property_masks() const;
3119
3120 // @@protoc_insertion_point(class_scope:icing.lib.GetResultSpecProto)
3121 private:
3122 class _Internal;
3123
3124 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
3125 typedef void InternalArenaConstructable_;
3126 typedef void DestructorSkippable_;
3127 struct Impl_ {
3128 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::TypePropertyMask > type_property_masks_;
3129 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
3130 };
3131 union { Impl_ _impl_; };
3132 friend struct ::TableStruct_icing_2fproto_2fsearch_2eproto;
3133 };
3134 // -------------------------------------------------------------------
3135
3136 class SuggestionSpecProto final :
3137 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:icing.lib.SuggestionSpecProto) */ {
3138 public:
SuggestionSpecProto()3139 inline SuggestionSpecProto() : SuggestionSpecProto(nullptr) {}
3140 ~SuggestionSpecProto() override;
3141 explicit PROTOBUF_CONSTEXPR SuggestionSpecProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
3142
3143 SuggestionSpecProto(const SuggestionSpecProto& from);
SuggestionSpecProto(SuggestionSpecProto && from)3144 SuggestionSpecProto(SuggestionSpecProto&& from) noexcept
3145 : SuggestionSpecProto() {
3146 *this = ::std::move(from);
3147 }
3148
3149 inline SuggestionSpecProto& operator=(const SuggestionSpecProto& from) {
3150 if (this == &from) return *this;
3151 CopyFrom(from);
3152 return *this;
3153 }
3154 inline SuggestionSpecProto& operator=(SuggestionSpecProto&& from) noexcept {
3155 if (this == &from) return *this;
3156 if (GetOwningArena() == from.GetOwningArena()
3157 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
3158 && GetOwningArena() != nullptr
3159 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
3160 ) {
3161 InternalSwap(&from);
3162 } else {
3163 CopyFrom(from);
3164 }
3165 return *this;
3166 }
3167
unknown_fields()3168 inline const std::string& unknown_fields() const {
3169 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
3170 }
mutable_unknown_fields()3171 inline std::string* mutable_unknown_fields() {
3172 return _internal_metadata_.mutable_unknown_fields<std::string>();
3173 }
3174
default_instance()3175 static const SuggestionSpecProto& default_instance() {
3176 return *internal_default_instance();
3177 }
internal_default_instance()3178 static inline const SuggestionSpecProto* internal_default_instance() {
3179 return reinterpret_cast<const SuggestionSpecProto*>(
3180 &_SuggestionSpecProto_default_instance_);
3181 }
3182 static constexpr int kIndexInFileMessages =
3183 14;
3184
swap(SuggestionSpecProto & a,SuggestionSpecProto & b)3185 friend void swap(SuggestionSpecProto& a, SuggestionSpecProto& b) {
3186 a.Swap(&b);
3187 }
Swap(SuggestionSpecProto * other)3188 inline void Swap(SuggestionSpecProto* other) {
3189 if (other == this) return;
3190 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
3191 if (GetOwningArena() != nullptr &&
3192 GetOwningArena() == other->GetOwningArena()) {
3193 #else // PROTOBUF_FORCE_COPY_IN_SWAP
3194 if (GetOwningArena() == other->GetOwningArena()) {
3195 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
3196 InternalSwap(other);
3197 } else {
3198 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
3199 }
3200 }
3201 void UnsafeArenaSwap(SuggestionSpecProto* other) {
3202 if (other == this) return;
3203 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
3204 InternalSwap(other);
3205 }
3206
3207 // implements Message ----------------------------------------------
3208
3209 SuggestionSpecProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
3210 return CreateMaybeMessage<SuggestionSpecProto>(arena);
3211 }
3212 SuggestionSpecProto* New() const {
3213 return New(nullptr);
3214 }
3215 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
3216 void CopyFrom(const SuggestionSpecProto& from);
3217 void MergeFrom(const SuggestionSpecProto& from);
3218 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
3219 bool IsInitialized() const final;
3220
3221 size_t ByteSizeLong() const final;
3222 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
3223 ::uint8_t* _InternalSerialize(
3224 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
3225 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
3226
3227 private:
3228 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
3229 void SharedDtor();
3230 void SetCachedSize(int size) const;
3231 void InternalSwap(SuggestionSpecProto* other);
3232
3233 private:
3234 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
3235 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
3236 return "icing.lib.SuggestionSpecProto";
3237 }
3238 protected:
3239 explicit SuggestionSpecProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
3240 bool is_message_owned = false);
3241 public:
3242
3243 std::string GetTypeName() const final;
3244
3245 // nested types ----------------------------------------------------
3246
3247 // accessors -------------------------------------------------------
3248
3249 enum : int {
3250 kNamespaceFiltersFieldNumber = 2,
3251 kDocumentUriFiltersFieldNumber = 5,
3252 kSchemaTypeFiltersFieldNumber = 6,
3253 kTypePropertyFiltersFieldNumber = 7,
3254 kEmbeddingQueryVectorsFieldNumber = 8,
3255 kQueryParameterStringsFieldNumber = 10,
3256 kEnabledFeaturesFieldNumber = 11,
3257 kPrefixFieldNumber = 1,
3258 kScoringSpecFieldNumber = 4,
3259 kNumToReturnFieldNumber = 3,
3260 kEmbeddingQueryMetricTypeFieldNumber = 9,
3261 };
3262 // repeated string namespace_filters = 2;
3263 int namespace_filters_size() const;
3264 private:
3265 int _internal_namespace_filters_size() const;
3266 public:
3267 void clear_namespace_filters();
3268 const std::string& namespace_filters(int index) const;
3269 std::string* mutable_namespace_filters(int index);
3270 void set_namespace_filters(int index, const std::string& value);
3271 void set_namespace_filters(int index, std::string&& value);
3272 void set_namespace_filters(int index, const char* value);
3273 void set_namespace_filters(int index, const char* value, size_t size);
3274 std::string* add_namespace_filters();
3275 void add_namespace_filters(const std::string& value);
3276 void add_namespace_filters(std::string&& value);
3277 void add_namespace_filters(const char* value);
3278 void add_namespace_filters(const char* value, size_t size);
3279 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& namespace_filters() const;
3280 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_namespace_filters();
3281 private:
3282 const std::string& _internal_namespace_filters(int index) const;
3283 std::string* _internal_add_namespace_filters();
3284 public:
3285
3286 // repeated .icing.lib.NamespaceDocumentUriGroup document_uri_filters = 5;
3287 int document_uri_filters_size() const;
3288 private:
3289 int _internal_document_uri_filters_size() const;
3290 public:
3291 void clear_document_uri_filters();
3292 ::icing::lib::NamespaceDocumentUriGroup* mutable_document_uri_filters(int index);
3293 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::NamespaceDocumentUriGroup >*
3294 mutable_document_uri_filters();
3295 private:
3296 const ::icing::lib::NamespaceDocumentUriGroup& _internal_document_uri_filters(int index) const;
3297 ::icing::lib::NamespaceDocumentUriGroup* _internal_add_document_uri_filters();
3298 public:
3299 const ::icing::lib::NamespaceDocumentUriGroup& document_uri_filters(int index) const;
3300 ::icing::lib::NamespaceDocumentUriGroup* add_document_uri_filters();
3301 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::NamespaceDocumentUriGroup >&
3302 document_uri_filters() const;
3303
3304 // repeated string schema_type_filters = 6;
3305 int schema_type_filters_size() const;
3306 private:
3307 int _internal_schema_type_filters_size() const;
3308 public:
3309 void clear_schema_type_filters();
3310 const std::string& schema_type_filters(int index) const;
3311 std::string* mutable_schema_type_filters(int index);
3312 void set_schema_type_filters(int index, const std::string& value);
3313 void set_schema_type_filters(int index, std::string&& value);
3314 void set_schema_type_filters(int index, const char* value);
3315 void set_schema_type_filters(int index, const char* value, size_t size);
3316 std::string* add_schema_type_filters();
3317 void add_schema_type_filters(const std::string& value);
3318 void add_schema_type_filters(std::string&& value);
3319 void add_schema_type_filters(const char* value);
3320 void add_schema_type_filters(const char* value, size_t size);
3321 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& schema_type_filters() const;
3322 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_schema_type_filters();
3323 private:
3324 const std::string& _internal_schema_type_filters(int index) const;
3325 std::string* _internal_add_schema_type_filters();
3326 public:
3327
3328 // repeated .icing.lib.TypePropertyMask type_property_filters = 7;
3329 int type_property_filters_size() const;
3330 private:
3331 int _internal_type_property_filters_size() const;
3332 public:
3333 void clear_type_property_filters();
3334 ::icing::lib::TypePropertyMask* mutable_type_property_filters(int index);
3335 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::TypePropertyMask >*
3336 mutable_type_property_filters();
3337 private:
3338 const ::icing::lib::TypePropertyMask& _internal_type_property_filters(int index) const;
3339 ::icing::lib::TypePropertyMask* _internal_add_type_property_filters();
3340 public:
3341 const ::icing::lib::TypePropertyMask& type_property_filters(int index) const;
3342 ::icing::lib::TypePropertyMask* add_type_property_filters();
3343 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::TypePropertyMask >&
3344 type_property_filters() const;
3345
3346 // repeated .icing.lib.PropertyProto.VectorProto embedding_query_vectors = 8;
3347 int embedding_query_vectors_size() const;
3348 private:
3349 int _internal_embedding_query_vectors_size() const;
3350 public:
3351 void clear_embedding_query_vectors();
3352 ::icing::lib::PropertyProto_VectorProto* mutable_embedding_query_vectors(int index);
3353 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::PropertyProto_VectorProto >*
3354 mutable_embedding_query_vectors();
3355 private:
3356 const ::icing::lib::PropertyProto_VectorProto& _internal_embedding_query_vectors(int index) const;
3357 ::icing::lib::PropertyProto_VectorProto* _internal_add_embedding_query_vectors();
3358 public:
3359 const ::icing::lib::PropertyProto_VectorProto& embedding_query_vectors(int index) const;
3360 ::icing::lib::PropertyProto_VectorProto* add_embedding_query_vectors();
3361 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::PropertyProto_VectorProto >&
3362 embedding_query_vectors() const;
3363
3364 // repeated string query_parameter_strings = 10;
3365 int query_parameter_strings_size() const;
3366 private:
3367 int _internal_query_parameter_strings_size() const;
3368 public:
3369 void clear_query_parameter_strings();
3370 const std::string& query_parameter_strings(int index) const;
3371 std::string* mutable_query_parameter_strings(int index);
3372 void set_query_parameter_strings(int index, const std::string& value);
3373 void set_query_parameter_strings(int index, std::string&& value);
3374 void set_query_parameter_strings(int index, const char* value);
3375 void set_query_parameter_strings(int index, const char* value, size_t size);
3376 std::string* add_query_parameter_strings();
3377 void add_query_parameter_strings(const std::string& value);
3378 void add_query_parameter_strings(std::string&& value);
3379 void add_query_parameter_strings(const char* value);
3380 void add_query_parameter_strings(const char* value, size_t size);
3381 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& query_parameter_strings() const;
3382 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_query_parameter_strings();
3383 private:
3384 const std::string& _internal_query_parameter_strings(int index) const;
3385 std::string* _internal_add_query_parameter_strings();
3386 public:
3387
3388 // repeated string enabled_features = 11;
3389 int enabled_features_size() const;
3390 private:
3391 int _internal_enabled_features_size() const;
3392 public:
3393 void clear_enabled_features();
3394 const std::string& enabled_features(int index) const;
3395 std::string* mutable_enabled_features(int index);
3396 void set_enabled_features(int index, const std::string& value);
3397 void set_enabled_features(int index, std::string&& value);
3398 void set_enabled_features(int index, const char* value);
3399 void set_enabled_features(int index, const char* value, size_t size);
3400 std::string* add_enabled_features();
3401 void add_enabled_features(const std::string& value);
3402 void add_enabled_features(std::string&& value);
3403 void add_enabled_features(const char* value);
3404 void add_enabled_features(const char* value, size_t size);
3405 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& enabled_features() const;
3406 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_enabled_features();
3407 private:
3408 const std::string& _internal_enabled_features(int index) const;
3409 std::string* _internal_add_enabled_features();
3410 public:
3411
3412 // optional string prefix = 1;
3413 bool has_prefix() const;
3414 private:
3415 bool _internal_has_prefix() const;
3416 public:
3417 void clear_prefix();
3418 const std::string& prefix() const;
3419 template <typename ArgT0 = const std::string&, typename... ArgT>
3420 void set_prefix(ArgT0&& arg0, ArgT... args);
3421 std::string* mutable_prefix();
3422 PROTOBUF_NODISCARD std::string* release_prefix();
3423 void set_allocated_prefix(std::string* prefix);
3424 private:
3425 const std::string& _internal_prefix() const;
3426 inline PROTOBUF_ALWAYS_INLINE void _internal_set_prefix(const std::string& value);
3427 std::string* _internal_mutable_prefix();
3428 public:
3429
3430 // optional .icing.lib.SuggestionScoringSpecProto scoring_spec = 4;
3431 bool has_scoring_spec() const;
3432 private:
3433 bool _internal_has_scoring_spec() const;
3434 public:
3435 void clear_scoring_spec();
3436 const ::icing::lib::SuggestionScoringSpecProto& scoring_spec() const;
3437 PROTOBUF_NODISCARD ::icing::lib::SuggestionScoringSpecProto* release_scoring_spec();
3438 ::icing::lib::SuggestionScoringSpecProto* mutable_scoring_spec();
3439 void set_allocated_scoring_spec(::icing::lib::SuggestionScoringSpecProto* scoring_spec);
3440 private:
3441 const ::icing::lib::SuggestionScoringSpecProto& _internal_scoring_spec() const;
3442 ::icing::lib::SuggestionScoringSpecProto* _internal_mutable_scoring_spec();
3443 public:
3444 void unsafe_arena_set_allocated_scoring_spec(
3445 ::icing::lib::SuggestionScoringSpecProto* scoring_spec);
3446 ::icing::lib::SuggestionScoringSpecProto* unsafe_arena_release_scoring_spec();
3447
3448 // optional int32 num_to_return = 3;
3449 bool has_num_to_return() const;
3450 private:
3451 bool _internal_has_num_to_return() const;
3452 public:
3453 void clear_num_to_return();
3454 ::int32_t num_to_return() const;
3455 void set_num_to_return(::int32_t value);
3456 private:
3457 ::int32_t _internal_num_to_return() const;
3458 void _internal_set_num_to_return(::int32_t value);
3459 public:
3460
3461 // optional .icing.lib.SearchSpecProto.EmbeddingQueryMetricType.Code embedding_query_metric_type = 9;
3462 bool has_embedding_query_metric_type() const;
3463 private:
3464 bool _internal_has_embedding_query_metric_type() const;
3465 public:
3466 void clear_embedding_query_metric_type();
3467 ::icing::lib::SearchSpecProto_EmbeddingQueryMetricType_Code embedding_query_metric_type() const;
3468 void set_embedding_query_metric_type(::icing::lib::SearchSpecProto_EmbeddingQueryMetricType_Code value);
3469 private:
3470 ::icing::lib::SearchSpecProto_EmbeddingQueryMetricType_Code _internal_embedding_query_metric_type() const;
3471 void _internal_set_embedding_query_metric_type(::icing::lib::SearchSpecProto_EmbeddingQueryMetricType_Code value);
3472 public:
3473
3474 // @@protoc_insertion_point(class_scope:icing.lib.SuggestionSpecProto)
3475 private:
3476 class _Internal;
3477
3478 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
3479 typedef void InternalArenaConstructable_;
3480 typedef void DestructorSkippable_;
3481 struct Impl_ {
3482 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
3483 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
3484 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> namespace_filters_;
3485 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::NamespaceDocumentUriGroup > document_uri_filters_;
3486 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> schema_type_filters_;
3487 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::TypePropertyMask > type_property_filters_;
3488 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::PropertyProto_VectorProto > embedding_query_vectors_;
3489 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> query_parameter_strings_;
3490 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> enabled_features_;
3491 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr prefix_;
3492 ::icing::lib::SuggestionScoringSpecProto* scoring_spec_;
3493 ::int32_t num_to_return_;
3494 int embedding_query_metric_type_;
3495 };
3496 union { Impl_ _impl_; };
3497 friend struct ::TableStruct_icing_2fproto_2fsearch_2eproto;
3498 };
3499 // -------------------------------------------------------------------
3500
3501 class NamespaceDocumentUriGroup final :
3502 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:icing.lib.NamespaceDocumentUriGroup) */ {
3503 public:
NamespaceDocumentUriGroup()3504 inline NamespaceDocumentUriGroup() : NamespaceDocumentUriGroup(nullptr) {}
3505 ~NamespaceDocumentUriGroup() override;
3506 explicit PROTOBUF_CONSTEXPR NamespaceDocumentUriGroup(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
3507
3508 NamespaceDocumentUriGroup(const NamespaceDocumentUriGroup& from);
NamespaceDocumentUriGroup(NamespaceDocumentUriGroup && from)3509 NamespaceDocumentUriGroup(NamespaceDocumentUriGroup&& from) noexcept
3510 : NamespaceDocumentUriGroup() {
3511 *this = ::std::move(from);
3512 }
3513
3514 inline NamespaceDocumentUriGroup& operator=(const NamespaceDocumentUriGroup& from) {
3515 if (this == &from) return *this;
3516 CopyFrom(from);
3517 return *this;
3518 }
3519 inline NamespaceDocumentUriGroup& operator=(NamespaceDocumentUriGroup&& from) noexcept {
3520 if (this == &from) return *this;
3521 if (GetOwningArena() == from.GetOwningArena()
3522 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
3523 && GetOwningArena() != nullptr
3524 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
3525 ) {
3526 InternalSwap(&from);
3527 } else {
3528 CopyFrom(from);
3529 }
3530 return *this;
3531 }
3532
unknown_fields()3533 inline const std::string& unknown_fields() const {
3534 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
3535 }
mutable_unknown_fields()3536 inline std::string* mutable_unknown_fields() {
3537 return _internal_metadata_.mutable_unknown_fields<std::string>();
3538 }
3539
default_instance()3540 static const NamespaceDocumentUriGroup& default_instance() {
3541 return *internal_default_instance();
3542 }
internal_default_instance()3543 static inline const NamespaceDocumentUriGroup* internal_default_instance() {
3544 return reinterpret_cast<const NamespaceDocumentUriGroup*>(
3545 &_NamespaceDocumentUriGroup_default_instance_);
3546 }
3547 static constexpr int kIndexInFileMessages =
3548 15;
3549
swap(NamespaceDocumentUriGroup & a,NamespaceDocumentUriGroup & b)3550 friend void swap(NamespaceDocumentUriGroup& a, NamespaceDocumentUriGroup& b) {
3551 a.Swap(&b);
3552 }
Swap(NamespaceDocumentUriGroup * other)3553 inline void Swap(NamespaceDocumentUriGroup* other) {
3554 if (other == this) return;
3555 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
3556 if (GetOwningArena() != nullptr &&
3557 GetOwningArena() == other->GetOwningArena()) {
3558 #else // PROTOBUF_FORCE_COPY_IN_SWAP
3559 if (GetOwningArena() == other->GetOwningArena()) {
3560 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
3561 InternalSwap(other);
3562 } else {
3563 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
3564 }
3565 }
3566 void UnsafeArenaSwap(NamespaceDocumentUriGroup* other) {
3567 if (other == this) return;
3568 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
3569 InternalSwap(other);
3570 }
3571
3572 // implements Message ----------------------------------------------
3573
3574 NamespaceDocumentUriGroup* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
3575 return CreateMaybeMessage<NamespaceDocumentUriGroup>(arena);
3576 }
3577 NamespaceDocumentUriGroup* New() const {
3578 return New(nullptr);
3579 }
3580 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
3581 void CopyFrom(const NamespaceDocumentUriGroup& from);
3582 void MergeFrom(const NamespaceDocumentUriGroup& from);
3583 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
3584 bool IsInitialized() const final;
3585
3586 size_t ByteSizeLong() const final;
3587 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
3588 ::uint8_t* _InternalSerialize(
3589 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
3590 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
3591
3592 private:
3593 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
3594 void SharedDtor();
3595 void SetCachedSize(int size) const;
3596 void InternalSwap(NamespaceDocumentUriGroup* other);
3597
3598 private:
3599 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
3600 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
3601 return "icing.lib.NamespaceDocumentUriGroup";
3602 }
3603 protected:
3604 explicit NamespaceDocumentUriGroup(::PROTOBUF_NAMESPACE_ID::Arena* arena,
3605 bool is_message_owned = false);
3606 public:
3607
3608 std::string GetTypeName() const final;
3609
3610 // nested types ----------------------------------------------------
3611
3612 // accessors -------------------------------------------------------
3613
3614 enum : int {
3615 kDocumentUrisFieldNumber = 2,
3616 kNamespaceFieldNumber = 1,
3617 };
3618 // repeated string document_uris = 2;
3619 int document_uris_size() const;
3620 private:
3621 int _internal_document_uris_size() const;
3622 public:
3623 void clear_document_uris();
3624 const std::string& document_uris(int index) const;
3625 std::string* mutable_document_uris(int index);
3626 void set_document_uris(int index, const std::string& value);
3627 void set_document_uris(int index, std::string&& value);
3628 void set_document_uris(int index, const char* value);
3629 void set_document_uris(int index, const char* value, size_t size);
3630 std::string* add_document_uris();
3631 void add_document_uris(const std::string& value);
3632 void add_document_uris(std::string&& value);
3633 void add_document_uris(const char* value);
3634 void add_document_uris(const char* value, size_t size);
3635 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& document_uris() const;
3636 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_document_uris();
3637 private:
3638 const std::string& _internal_document_uris(int index) const;
3639 std::string* _internal_add_document_uris();
3640 public:
3641
3642 // optional string namespace_ = 1;
3643 bool has_namespace_() const;
3644 private:
3645 bool _internal_has_namespace_() const;
3646 public:
3647 void clear_namespace_();
3648 const std::string& namespace_() const;
3649 template <typename ArgT0 = const std::string&, typename... ArgT>
3650 void set_namespace_(ArgT0&& arg0, ArgT... args);
3651 std::string* mutable_namespace_();
3652 PROTOBUF_NODISCARD std::string* release_namespace_();
3653 void set_allocated_namespace_(std::string* namespace_);
3654 private:
3655 const std::string& _internal_namespace_() const;
3656 inline PROTOBUF_ALWAYS_INLINE void _internal_set_namespace_(const std::string& value);
3657 std::string* _internal_mutable_namespace_();
3658 public:
3659
3660 // @@protoc_insertion_point(class_scope:icing.lib.NamespaceDocumentUriGroup)
3661 private:
3662 class _Internal;
3663
3664 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
3665 typedef void InternalArenaConstructable_;
3666 typedef void DestructorSkippable_;
3667 struct Impl_ {
3668 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
3669 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
3670 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> document_uris_;
3671 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr namespace__;
3672 };
3673 union { Impl_ _impl_; };
3674 friend struct ::TableStruct_icing_2fproto_2fsearch_2eproto;
3675 };
3676 // -------------------------------------------------------------------
3677
3678 class SuggestionResponse_Suggestion final :
3679 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:icing.lib.SuggestionResponse.Suggestion) */ {
3680 public:
SuggestionResponse_Suggestion()3681 inline SuggestionResponse_Suggestion() : SuggestionResponse_Suggestion(nullptr) {}
3682 ~SuggestionResponse_Suggestion() override;
3683 explicit PROTOBUF_CONSTEXPR SuggestionResponse_Suggestion(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
3684
3685 SuggestionResponse_Suggestion(const SuggestionResponse_Suggestion& from);
SuggestionResponse_Suggestion(SuggestionResponse_Suggestion && from)3686 SuggestionResponse_Suggestion(SuggestionResponse_Suggestion&& from) noexcept
3687 : SuggestionResponse_Suggestion() {
3688 *this = ::std::move(from);
3689 }
3690
3691 inline SuggestionResponse_Suggestion& operator=(const SuggestionResponse_Suggestion& from) {
3692 if (this == &from) return *this;
3693 CopyFrom(from);
3694 return *this;
3695 }
3696 inline SuggestionResponse_Suggestion& operator=(SuggestionResponse_Suggestion&& from) noexcept {
3697 if (this == &from) return *this;
3698 if (GetOwningArena() == from.GetOwningArena()
3699 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
3700 && GetOwningArena() != nullptr
3701 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
3702 ) {
3703 InternalSwap(&from);
3704 } else {
3705 CopyFrom(from);
3706 }
3707 return *this;
3708 }
3709
unknown_fields()3710 inline const std::string& unknown_fields() const {
3711 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
3712 }
mutable_unknown_fields()3713 inline std::string* mutable_unknown_fields() {
3714 return _internal_metadata_.mutable_unknown_fields<std::string>();
3715 }
3716
default_instance()3717 static const SuggestionResponse_Suggestion& default_instance() {
3718 return *internal_default_instance();
3719 }
internal_default_instance()3720 static inline const SuggestionResponse_Suggestion* internal_default_instance() {
3721 return reinterpret_cast<const SuggestionResponse_Suggestion*>(
3722 &_SuggestionResponse_Suggestion_default_instance_);
3723 }
3724 static constexpr int kIndexInFileMessages =
3725 16;
3726
swap(SuggestionResponse_Suggestion & a,SuggestionResponse_Suggestion & b)3727 friend void swap(SuggestionResponse_Suggestion& a, SuggestionResponse_Suggestion& b) {
3728 a.Swap(&b);
3729 }
Swap(SuggestionResponse_Suggestion * other)3730 inline void Swap(SuggestionResponse_Suggestion* other) {
3731 if (other == this) return;
3732 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
3733 if (GetOwningArena() != nullptr &&
3734 GetOwningArena() == other->GetOwningArena()) {
3735 #else // PROTOBUF_FORCE_COPY_IN_SWAP
3736 if (GetOwningArena() == other->GetOwningArena()) {
3737 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
3738 InternalSwap(other);
3739 } else {
3740 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
3741 }
3742 }
3743 void UnsafeArenaSwap(SuggestionResponse_Suggestion* other) {
3744 if (other == this) return;
3745 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
3746 InternalSwap(other);
3747 }
3748
3749 // implements Message ----------------------------------------------
3750
3751 SuggestionResponse_Suggestion* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
3752 return CreateMaybeMessage<SuggestionResponse_Suggestion>(arena);
3753 }
3754 SuggestionResponse_Suggestion* New() const {
3755 return New(nullptr);
3756 }
3757 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
3758 void CopyFrom(const SuggestionResponse_Suggestion& from);
3759 void MergeFrom(const SuggestionResponse_Suggestion& from);
3760 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
3761 bool IsInitialized() const final;
3762
3763 size_t ByteSizeLong() const final;
3764 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
3765 ::uint8_t* _InternalSerialize(
3766 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
3767 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
3768
3769 private:
3770 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
3771 void SharedDtor();
3772 void SetCachedSize(int size) const;
3773 void InternalSwap(SuggestionResponse_Suggestion* other);
3774
3775 private:
3776 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
3777 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
3778 return "icing.lib.SuggestionResponse.Suggestion";
3779 }
3780 protected:
3781 explicit SuggestionResponse_Suggestion(::PROTOBUF_NAMESPACE_ID::Arena* arena,
3782 bool is_message_owned = false);
3783 public:
3784
3785 std::string GetTypeName() const final;
3786
3787 // nested types ----------------------------------------------------
3788
3789 // accessors -------------------------------------------------------
3790
3791 enum : int {
3792 kQueryFieldNumber = 1,
3793 };
3794 // optional string query = 1;
3795 bool has_query() const;
3796 private:
3797 bool _internal_has_query() const;
3798 public:
3799 void clear_query();
3800 const std::string& query() const;
3801 template <typename ArgT0 = const std::string&, typename... ArgT>
3802 void set_query(ArgT0&& arg0, ArgT... args);
3803 std::string* mutable_query();
3804 PROTOBUF_NODISCARD std::string* release_query();
3805 void set_allocated_query(std::string* query);
3806 private:
3807 const std::string& _internal_query() const;
3808 inline PROTOBUF_ALWAYS_INLINE void _internal_set_query(const std::string& value);
3809 std::string* _internal_mutable_query();
3810 public:
3811
3812 // @@protoc_insertion_point(class_scope:icing.lib.SuggestionResponse.Suggestion)
3813 private:
3814 class _Internal;
3815
3816 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
3817 typedef void InternalArenaConstructable_;
3818 typedef void DestructorSkippable_;
3819 struct Impl_ {
3820 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
3821 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
3822 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr query_;
3823 };
3824 union { Impl_ _impl_; };
3825 friend struct ::TableStruct_icing_2fproto_2fsearch_2eproto;
3826 };
3827 // -------------------------------------------------------------------
3828
3829 class SuggestionResponse final :
3830 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:icing.lib.SuggestionResponse) */ {
3831 public:
SuggestionResponse()3832 inline SuggestionResponse() : SuggestionResponse(nullptr) {}
3833 ~SuggestionResponse() override;
3834 explicit PROTOBUF_CONSTEXPR SuggestionResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
3835
3836 SuggestionResponse(const SuggestionResponse& from);
SuggestionResponse(SuggestionResponse && from)3837 SuggestionResponse(SuggestionResponse&& from) noexcept
3838 : SuggestionResponse() {
3839 *this = ::std::move(from);
3840 }
3841
3842 inline SuggestionResponse& operator=(const SuggestionResponse& from) {
3843 if (this == &from) return *this;
3844 CopyFrom(from);
3845 return *this;
3846 }
3847 inline SuggestionResponse& operator=(SuggestionResponse&& from) noexcept {
3848 if (this == &from) return *this;
3849 if (GetOwningArena() == from.GetOwningArena()
3850 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
3851 && GetOwningArena() != nullptr
3852 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
3853 ) {
3854 InternalSwap(&from);
3855 } else {
3856 CopyFrom(from);
3857 }
3858 return *this;
3859 }
3860
unknown_fields()3861 inline const std::string& unknown_fields() const {
3862 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
3863 }
mutable_unknown_fields()3864 inline std::string* mutable_unknown_fields() {
3865 return _internal_metadata_.mutable_unknown_fields<std::string>();
3866 }
3867
default_instance()3868 static const SuggestionResponse& default_instance() {
3869 return *internal_default_instance();
3870 }
internal_default_instance()3871 static inline const SuggestionResponse* internal_default_instance() {
3872 return reinterpret_cast<const SuggestionResponse*>(
3873 &_SuggestionResponse_default_instance_);
3874 }
3875 static constexpr int kIndexInFileMessages =
3876 17;
3877
swap(SuggestionResponse & a,SuggestionResponse & b)3878 friend void swap(SuggestionResponse& a, SuggestionResponse& b) {
3879 a.Swap(&b);
3880 }
Swap(SuggestionResponse * other)3881 inline void Swap(SuggestionResponse* other) {
3882 if (other == this) return;
3883 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
3884 if (GetOwningArena() != nullptr &&
3885 GetOwningArena() == other->GetOwningArena()) {
3886 #else // PROTOBUF_FORCE_COPY_IN_SWAP
3887 if (GetOwningArena() == other->GetOwningArena()) {
3888 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
3889 InternalSwap(other);
3890 } else {
3891 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
3892 }
3893 }
3894 void UnsafeArenaSwap(SuggestionResponse* other) {
3895 if (other == this) return;
3896 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
3897 InternalSwap(other);
3898 }
3899
3900 // implements Message ----------------------------------------------
3901
3902 SuggestionResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
3903 return CreateMaybeMessage<SuggestionResponse>(arena);
3904 }
3905 SuggestionResponse* New() const {
3906 return New(nullptr);
3907 }
3908 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
3909 void CopyFrom(const SuggestionResponse& from);
3910 void MergeFrom(const SuggestionResponse& from);
3911 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
3912 bool IsInitialized() const final;
3913
3914 size_t ByteSizeLong() const final;
3915 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
3916 ::uint8_t* _InternalSerialize(
3917 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
3918 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
3919
3920 private:
3921 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
3922 void SharedDtor();
3923 void SetCachedSize(int size) const;
3924 void InternalSwap(SuggestionResponse* other);
3925
3926 private:
3927 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
3928 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
3929 return "icing.lib.SuggestionResponse";
3930 }
3931 protected:
3932 explicit SuggestionResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
3933 bool is_message_owned = false);
3934 public:
3935
3936 std::string GetTypeName() const final;
3937
3938 // nested types ----------------------------------------------------
3939
3940 typedef SuggestionResponse_Suggestion Suggestion;
3941
3942 // accessors -------------------------------------------------------
3943
3944 enum : int {
3945 kSuggestionsFieldNumber = 2,
3946 kStatusFieldNumber = 1,
3947 };
3948 // repeated .icing.lib.SuggestionResponse.Suggestion suggestions = 2;
3949 int suggestions_size() const;
3950 private:
3951 int _internal_suggestions_size() const;
3952 public:
3953 void clear_suggestions();
3954 ::icing::lib::SuggestionResponse_Suggestion* mutable_suggestions(int index);
3955 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::SuggestionResponse_Suggestion >*
3956 mutable_suggestions();
3957 private:
3958 const ::icing::lib::SuggestionResponse_Suggestion& _internal_suggestions(int index) const;
3959 ::icing::lib::SuggestionResponse_Suggestion* _internal_add_suggestions();
3960 public:
3961 const ::icing::lib::SuggestionResponse_Suggestion& suggestions(int index) const;
3962 ::icing::lib::SuggestionResponse_Suggestion* add_suggestions();
3963 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::SuggestionResponse_Suggestion >&
3964 suggestions() const;
3965
3966 // optional .icing.lib.StatusProto status = 1;
3967 bool has_status() const;
3968 private:
3969 bool _internal_has_status() const;
3970 public:
3971 void clear_status();
3972 const ::icing::lib::StatusProto& status() const;
3973 PROTOBUF_NODISCARD ::icing::lib::StatusProto* release_status();
3974 ::icing::lib::StatusProto* mutable_status();
3975 void set_allocated_status(::icing::lib::StatusProto* status);
3976 private:
3977 const ::icing::lib::StatusProto& _internal_status() const;
3978 ::icing::lib::StatusProto* _internal_mutable_status();
3979 public:
3980 void unsafe_arena_set_allocated_status(
3981 ::icing::lib::StatusProto* status);
3982 ::icing::lib::StatusProto* unsafe_arena_release_status();
3983
3984 // @@protoc_insertion_point(class_scope:icing.lib.SuggestionResponse)
3985 private:
3986 class _Internal;
3987
3988 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
3989 typedef void InternalArenaConstructable_;
3990 typedef void DestructorSkippable_;
3991 struct Impl_ {
3992 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
3993 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
3994 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::SuggestionResponse_Suggestion > suggestions_;
3995 ::icing::lib::StatusProto* status_;
3996 };
3997 union { Impl_ _impl_; };
3998 friend struct ::TableStruct_icing_2fproto_2fsearch_2eproto;
3999 };
4000 // -------------------------------------------------------------------
4001
4002 class JoinSpecProto_NestedSpecProto final :
4003 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:icing.lib.JoinSpecProto.NestedSpecProto) */ {
4004 public:
JoinSpecProto_NestedSpecProto()4005 inline JoinSpecProto_NestedSpecProto() : JoinSpecProto_NestedSpecProto(nullptr) {}
4006 ~JoinSpecProto_NestedSpecProto() override;
4007 explicit PROTOBUF_CONSTEXPR JoinSpecProto_NestedSpecProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
4008
4009 JoinSpecProto_NestedSpecProto(const JoinSpecProto_NestedSpecProto& from);
JoinSpecProto_NestedSpecProto(JoinSpecProto_NestedSpecProto && from)4010 JoinSpecProto_NestedSpecProto(JoinSpecProto_NestedSpecProto&& from) noexcept
4011 : JoinSpecProto_NestedSpecProto() {
4012 *this = ::std::move(from);
4013 }
4014
4015 inline JoinSpecProto_NestedSpecProto& operator=(const JoinSpecProto_NestedSpecProto& from) {
4016 if (this == &from) return *this;
4017 CopyFrom(from);
4018 return *this;
4019 }
4020 inline JoinSpecProto_NestedSpecProto& operator=(JoinSpecProto_NestedSpecProto&& from) noexcept {
4021 if (this == &from) return *this;
4022 if (GetOwningArena() == from.GetOwningArena()
4023 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
4024 && GetOwningArena() != nullptr
4025 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
4026 ) {
4027 InternalSwap(&from);
4028 } else {
4029 CopyFrom(from);
4030 }
4031 return *this;
4032 }
4033
unknown_fields()4034 inline const std::string& unknown_fields() const {
4035 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
4036 }
mutable_unknown_fields()4037 inline std::string* mutable_unknown_fields() {
4038 return _internal_metadata_.mutable_unknown_fields<std::string>();
4039 }
4040
default_instance()4041 static const JoinSpecProto_NestedSpecProto& default_instance() {
4042 return *internal_default_instance();
4043 }
internal_default_instance()4044 static inline const JoinSpecProto_NestedSpecProto* internal_default_instance() {
4045 return reinterpret_cast<const JoinSpecProto_NestedSpecProto*>(
4046 &_JoinSpecProto_NestedSpecProto_default_instance_);
4047 }
4048 static constexpr int kIndexInFileMessages =
4049 18;
4050
swap(JoinSpecProto_NestedSpecProto & a,JoinSpecProto_NestedSpecProto & b)4051 friend void swap(JoinSpecProto_NestedSpecProto& a, JoinSpecProto_NestedSpecProto& b) {
4052 a.Swap(&b);
4053 }
Swap(JoinSpecProto_NestedSpecProto * other)4054 inline void Swap(JoinSpecProto_NestedSpecProto* other) {
4055 if (other == this) return;
4056 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
4057 if (GetOwningArena() != nullptr &&
4058 GetOwningArena() == other->GetOwningArena()) {
4059 #else // PROTOBUF_FORCE_COPY_IN_SWAP
4060 if (GetOwningArena() == other->GetOwningArena()) {
4061 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
4062 InternalSwap(other);
4063 } else {
4064 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
4065 }
4066 }
4067 void UnsafeArenaSwap(JoinSpecProto_NestedSpecProto* other) {
4068 if (other == this) return;
4069 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
4070 InternalSwap(other);
4071 }
4072
4073 // implements Message ----------------------------------------------
4074
4075 JoinSpecProto_NestedSpecProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
4076 return CreateMaybeMessage<JoinSpecProto_NestedSpecProto>(arena);
4077 }
4078 JoinSpecProto_NestedSpecProto* New() const {
4079 return New(nullptr);
4080 }
4081 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
4082 void CopyFrom(const JoinSpecProto_NestedSpecProto& from);
4083 void MergeFrom(const JoinSpecProto_NestedSpecProto& from);
4084 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
4085 bool IsInitialized() const final;
4086
4087 size_t ByteSizeLong() const final;
4088 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
4089 ::uint8_t* _InternalSerialize(
4090 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
4091 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
4092
4093 private:
4094 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
4095 void SharedDtor();
4096 void SetCachedSize(int size) const;
4097 void InternalSwap(JoinSpecProto_NestedSpecProto* other);
4098
4099 private:
4100 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
4101 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
4102 return "icing.lib.JoinSpecProto.NestedSpecProto";
4103 }
4104 protected:
4105 explicit JoinSpecProto_NestedSpecProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
4106 bool is_message_owned = false);
4107 public:
4108
4109 std::string GetTypeName() const final;
4110
4111 // nested types ----------------------------------------------------
4112
4113 // accessors -------------------------------------------------------
4114
4115 enum : int {
4116 kSearchSpecFieldNumber = 1,
4117 kScoringSpecFieldNumber = 2,
4118 kResultSpecFieldNumber = 3,
4119 };
4120 // optional .icing.lib.SearchSpecProto search_spec = 1;
4121 bool has_search_spec() const;
4122 private:
4123 bool _internal_has_search_spec() const;
4124 public:
4125 void clear_search_spec();
4126 const ::icing::lib::SearchSpecProto& search_spec() const;
4127 PROTOBUF_NODISCARD ::icing::lib::SearchSpecProto* release_search_spec();
4128 ::icing::lib::SearchSpecProto* mutable_search_spec();
4129 void set_allocated_search_spec(::icing::lib::SearchSpecProto* search_spec);
4130 private:
4131 const ::icing::lib::SearchSpecProto& _internal_search_spec() const;
4132 ::icing::lib::SearchSpecProto* _internal_mutable_search_spec();
4133 public:
4134 void unsafe_arena_set_allocated_search_spec(
4135 ::icing::lib::SearchSpecProto* search_spec);
4136 ::icing::lib::SearchSpecProto* unsafe_arena_release_search_spec();
4137
4138 // optional .icing.lib.ScoringSpecProto scoring_spec = 2;
4139 bool has_scoring_spec() const;
4140 private:
4141 bool _internal_has_scoring_spec() const;
4142 public:
4143 void clear_scoring_spec();
4144 const ::icing::lib::ScoringSpecProto& scoring_spec() const;
4145 PROTOBUF_NODISCARD ::icing::lib::ScoringSpecProto* release_scoring_spec();
4146 ::icing::lib::ScoringSpecProto* mutable_scoring_spec();
4147 void set_allocated_scoring_spec(::icing::lib::ScoringSpecProto* scoring_spec);
4148 private:
4149 const ::icing::lib::ScoringSpecProto& _internal_scoring_spec() const;
4150 ::icing::lib::ScoringSpecProto* _internal_mutable_scoring_spec();
4151 public:
4152 void unsafe_arena_set_allocated_scoring_spec(
4153 ::icing::lib::ScoringSpecProto* scoring_spec);
4154 ::icing::lib::ScoringSpecProto* unsafe_arena_release_scoring_spec();
4155
4156 // optional .icing.lib.ResultSpecProto result_spec = 3;
4157 bool has_result_spec() const;
4158 private:
4159 bool _internal_has_result_spec() const;
4160 public:
4161 void clear_result_spec();
4162 const ::icing::lib::ResultSpecProto& result_spec() const;
4163 PROTOBUF_NODISCARD ::icing::lib::ResultSpecProto* release_result_spec();
4164 ::icing::lib::ResultSpecProto* mutable_result_spec();
4165 void set_allocated_result_spec(::icing::lib::ResultSpecProto* result_spec);
4166 private:
4167 const ::icing::lib::ResultSpecProto& _internal_result_spec() const;
4168 ::icing::lib::ResultSpecProto* _internal_mutable_result_spec();
4169 public:
4170 void unsafe_arena_set_allocated_result_spec(
4171 ::icing::lib::ResultSpecProto* result_spec);
4172 ::icing::lib::ResultSpecProto* unsafe_arena_release_result_spec();
4173
4174 // @@protoc_insertion_point(class_scope:icing.lib.JoinSpecProto.NestedSpecProto)
4175 private:
4176 class _Internal;
4177
4178 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
4179 typedef void InternalArenaConstructable_;
4180 typedef void DestructorSkippable_;
4181 struct Impl_ {
4182 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
4183 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
4184 ::icing::lib::SearchSpecProto* search_spec_;
4185 ::icing::lib::ScoringSpecProto* scoring_spec_;
4186 ::icing::lib::ResultSpecProto* result_spec_;
4187 };
4188 union { Impl_ _impl_; };
4189 friend struct ::TableStruct_icing_2fproto_2fsearch_2eproto;
4190 };
4191 // -------------------------------------------------------------------
4192
4193 class JoinSpecProto_AggregationScoringStrategy final :
4194 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:icing.lib.JoinSpecProto.AggregationScoringStrategy) */ {
4195 public:
JoinSpecProto_AggregationScoringStrategy()4196 inline JoinSpecProto_AggregationScoringStrategy() : JoinSpecProto_AggregationScoringStrategy(nullptr) {}
4197 ~JoinSpecProto_AggregationScoringStrategy() override;
4198 explicit PROTOBUF_CONSTEXPR JoinSpecProto_AggregationScoringStrategy(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
4199
4200 JoinSpecProto_AggregationScoringStrategy(const JoinSpecProto_AggregationScoringStrategy& from);
JoinSpecProto_AggregationScoringStrategy(JoinSpecProto_AggregationScoringStrategy && from)4201 JoinSpecProto_AggregationScoringStrategy(JoinSpecProto_AggregationScoringStrategy&& from) noexcept
4202 : JoinSpecProto_AggregationScoringStrategy() {
4203 *this = ::std::move(from);
4204 }
4205
4206 inline JoinSpecProto_AggregationScoringStrategy& operator=(const JoinSpecProto_AggregationScoringStrategy& from) {
4207 if (this == &from) return *this;
4208 CopyFrom(from);
4209 return *this;
4210 }
4211 inline JoinSpecProto_AggregationScoringStrategy& operator=(JoinSpecProto_AggregationScoringStrategy&& from) noexcept {
4212 if (this == &from) return *this;
4213 if (GetOwningArena() == from.GetOwningArena()
4214 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
4215 && GetOwningArena() != nullptr
4216 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
4217 ) {
4218 InternalSwap(&from);
4219 } else {
4220 CopyFrom(from);
4221 }
4222 return *this;
4223 }
4224
unknown_fields()4225 inline const std::string& unknown_fields() const {
4226 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
4227 }
mutable_unknown_fields()4228 inline std::string* mutable_unknown_fields() {
4229 return _internal_metadata_.mutable_unknown_fields<std::string>();
4230 }
4231
default_instance()4232 static const JoinSpecProto_AggregationScoringStrategy& default_instance() {
4233 return *internal_default_instance();
4234 }
internal_default_instance()4235 static inline const JoinSpecProto_AggregationScoringStrategy* internal_default_instance() {
4236 return reinterpret_cast<const JoinSpecProto_AggregationScoringStrategy*>(
4237 &_JoinSpecProto_AggregationScoringStrategy_default_instance_);
4238 }
4239 static constexpr int kIndexInFileMessages =
4240 19;
4241
swap(JoinSpecProto_AggregationScoringStrategy & a,JoinSpecProto_AggregationScoringStrategy & b)4242 friend void swap(JoinSpecProto_AggregationScoringStrategy& a, JoinSpecProto_AggregationScoringStrategy& b) {
4243 a.Swap(&b);
4244 }
Swap(JoinSpecProto_AggregationScoringStrategy * other)4245 inline void Swap(JoinSpecProto_AggregationScoringStrategy* other) {
4246 if (other == this) return;
4247 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
4248 if (GetOwningArena() != nullptr &&
4249 GetOwningArena() == other->GetOwningArena()) {
4250 #else // PROTOBUF_FORCE_COPY_IN_SWAP
4251 if (GetOwningArena() == other->GetOwningArena()) {
4252 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
4253 InternalSwap(other);
4254 } else {
4255 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
4256 }
4257 }
4258 void UnsafeArenaSwap(JoinSpecProto_AggregationScoringStrategy* other) {
4259 if (other == this) return;
4260 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
4261 InternalSwap(other);
4262 }
4263
4264 // implements Message ----------------------------------------------
4265
4266 JoinSpecProto_AggregationScoringStrategy* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
4267 return CreateMaybeMessage<JoinSpecProto_AggregationScoringStrategy>(arena);
4268 }
4269 JoinSpecProto_AggregationScoringStrategy* New() const {
4270 return New(nullptr);
4271 }
4272 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
4273 void CopyFrom(const JoinSpecProto_AggregationScoringStrategy& from);
4274 void MergeFrom(const JoinSpecProto_AggregationScoringStrategy& from);
4275 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
4276 bool IsInitialized() const final;
4277
4278 size_t ByteSizeLong() const final;
4279 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
4280 ::uint8_t* _InternalSerialize(
4281 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
4282 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
4283
4284 private:
4285 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
4286 void SharedDtor();
4287 void SetCachedSize(int size) const;
4288 void InternalSwap(JoinSpecProto_AggregationScoringStrategy* other);
4289
4290 private:
4291 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
4292 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
4293 return "icing.lib.JoinSpecProto.AggregationScoringStrategy";
4294 }
4295 protected:
4296 explicit JoinSpecProto_AggregationScoringStrategy(::PROTOBUF_NAMESPACE_ID::Arena* arena,
4297 bool is_message_owned = false);
4298 public:
4299
4300 std::string GetTypeName() const final;
4301
4302 // nested types ----------------------------------------------------
4303
4304 typedef JoinSpecProto_AggregationScoringStrategy_Code Code;
4305 static constexpr Code NONE =
4306 JoinSpecProto_AggregationScoringStrategy_Code_NONE;
4307 static constexpr Code COUNT =
4308 JoinSpecProto_AggregationScoringStrategy_Code_COUNT;
4309 static constexpr Code MIN =
4310 JoinSpecProto_AggregationScoringStrategy_Code_MIN;
4311 static constexpr Code AVG =
4312 JoinSpecProto_AggregationScoringStrategy_Code_AVG;
4313 static constexpr Code MAX =
4314 JoinSpecProto_AggregationScoringStrategy_Code_MAX;
4315 static constexpr Code SUM =
4316 JoinSpecProto_AggregationScoringStrategy_Code_SUM;
4317 static inline bool Code_IsValid(int value) {
4318 return JoinSpecProto_AggregationScoringStrategy_Code_IsValid(value);
4319 }
4320 static constexpr Code Code_MIN =
4321 JoinSpecProto_AggregationScoringStrategy_Code_Code_MIN;
4322 static constexpr Code Code_MAX =
4323 JoinSpecProto_AggregationScoringStrategy_Code_Code_MAX;
4324 static constexpr int Code_ARRAYSIZE =
4325 JoinSpecProto_AggregationScoringStrategy_Code_Code_ARRAYSIZE;
4326 template<typename T>
4327 static inline const std::string& Code_Name(T enum_t_value) {
4328 static_assert(::std::is_same<T, Code>::value ||
4329 ::std::is_integral<T>::value,
4330 "Incorrect type passed to function Code_Name.");
4331 return JoinSpecProto_AggregationScoringStrategy_Code_Name(enum_t_value);
4332 }
4333 static inline bool Code_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
4334 Code* value) {
4335 return JoinSpecProto_AggregationScoringStrategy_Code_Parse(name, value);
4336 }
4337
4338 // accessors -------------------------------------------------------
4339
4340 // @@protoc_insertion_point(class_scope:icing.lib.JoinSpecProto.AggregationScoringStrategy)
4341 private:
4342 class _Internal;
4343
4344 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
4345 typedef void InternalArenaConstructable_;
4346 typedef void DestructorSkippable_;
4347 struct Impl_ {
4348 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
4349 };
4350 union { Impl_ _impl_; };
4351 friend struct ::TableStruct_icing_2fproto_2fsearch_2eproto;
4352 };
4353 // -------------------------------------------------------------------
4354
4355 class JoinSpecProto final :
4356 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:icing.lib.JoinSpecProto) */ {
4357 public:
JoinSpecProto()4358 inline JoinSpecProto() : JoinSpecProto(nullptr) {}
4359 ~JoinSpecProto() override;
4360 explicit PROTOBUF_CONSTEXPR JoinSpecProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
4361
4362 JoinSpecProto(const JoinSpecProto& from);
JoinSpecProto(JoinSpecProto && from)4363 JoinSpecProto(JoinSpecProto&& from) noexcept
4364 : JoinSpecProto() {
4365 *this = ::std::move(from);
4366 }
4367
4368 inline JoinSpecProto& operator=(const JoinSpecProto& from) {
4369 if (this == &from) return *this;
4370 CopyFrom(from);
4371 return *this;
4372 }
4373 inline JoinSpecProto& operator=(JoinSpecProto&& from) noexcept {
4374 if (this == &from) return *this;
4375 if (GetOwningArena() == from.GetOwningArena()
4376 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
4377 && GetOwningArena() != nullptr
4378 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
4379 ) {
4380 InternalSwap(&from);
4381 } else {
4382 CopyFrom(from);
4383 }
4384 return *this;
4385 }
4386
unknown_fields()4387 inline const std::string& unknown_fields() const {
4388 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
4389 }
mutable_unknown_fields()4390 inline std::string* mutable_unknown_fields() {
4391 return _internal_metadata_.mutable_unknown_fields<std::string>();
4392 }
4393
default_instance()4394 static const JoinSpecProto& default_instance() {
4395 return *internal_default_instance();
4396 }
internal_default_instance()4397 static inline const JoinSpecProto* internal_default_instance() {
4398 return reinterpret_cast<const JoinSpecProto*>(
4399 &_JoinSpecProto_default_instance_);
4400 }
4401 static constexpr int kIndexInFileMessages =
4402 20;
4403
swap(JoinSpecProto & a,JoinSpecProto & b)4404 friend void swap(JoinSpecProto& a, JoinSpecProto& b) {
4405 a.Swap(&b);
4406 }
Swap(JoinSpecProto * other)4407 inline void Swap(JoinSpecProto* other) {
4408 if (other == this) return;
4409 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
4410 if (GetOwningArena() != nullptr &&
4411 GetOwningArena() == other->GetOwningArena()) {
4412 #else // PROTOBUF_FORCE_COPY_IN_SWAP
4413 if (GetOwningArena() == other->GetOwningArena()) {
4414 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
4415 InternalSwap(other);
4416 } else {
4417 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
4418 }
4419 }
4420 void UnsafeArenaSwap(JoinSpecProto* other) {
4421 if (other == this) return;
4422 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
4423 InternalSwap(other);
4424 }
4425
4426 // implements Message ----------------------------------------------
4427
4428 JoinSpecProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
4429 return CreateMaybeMessage<JoinSpecProto>(arena);
4430 }
4431 JoinSpecProto* New() const {
4432 return New(nullptr);
4433 }
4434 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
4435 void CopyFrom(const JoinSpecProto& from);
4436 void MergeFrom(const JoinSpecProto& from);
4437 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
4438 bool IsInitialized() const final;
4439
4440 size_t ByteSizeLong() const final;
4441 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
4442 ::uint8_t* _InternalSerialize(
4443 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
4444 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
4445
4446 private:
4447 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
4448 void SharedDtor();
4449 void SetCachedSize(int size) const;
4450 void InternalSwap(JoinSpecProto* other);
4451
4452 private:
4453 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
4454 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
4455 return "icing.lib.JoinSpecProto";
4456 }
4457 protected:
4458 explicit JoinSpecProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
4459 bool is_message_owned = false);
4460 public:
4461
4462 std::string GetTypeName() const final;
4463
4464 // nested types ----------------------------------------------------
4465
4466 typedef JoinSpecProto_NestedSpecProto NestedSpecProto;
4467 typedef JoinSpecProto_AggregationScoringStrategy AggregationScoringStrategy;
4468
4469 // accessors -------------------------------------------------------
4470
4471 enum : int {
4472 kParentPropertyExpressionFieldNumber = 2,
4473 kChildPropertyExpressionFieldNumber = 3,
4474 kNestedSpecFieldNumber = 1,
4475 kMaxJoinedChildCountFieldNumber = 4,
4476 kAggregationScoringStrategyFieldNumber = 5,
4477 };
4478 // optional string parent_property_expression = 2;
4479 bool has_parent_property_expression() const;
4480 private:
4481 bool _internal_has_parent_property_expression() const;
4482 public:
4483 void clear_parent_property_expression();
4484 const std::string& parent_property_expression() const;
4485 template <typename ArgT0 = const std::string&, typename... ArgT>
4486 void set_parent_property_expression(ArgT0&& arg0, ArgT... args);
4487 std::string* mutable_parent_property_expression();
4488 PROTOBUF_NODISCARD std::string* release_parent_property_expression();
4489 void set_allocated_parent_property_expression(std::string* parent_property_expression);
4490 private:
4491 const std::string& _internal_parent_property_expression() const;
4492 inline PROTOBUF_ALWAYS_INLINE void _internal_set_parent_property_expression(const std::string& value);
4493 std::string* _internal_mutable_parent_property_expression();
4494 public:
4495
4496 // optional string child_property_expression = 3;
4497 bool has_child_property_expression() const;
4498 private:
4499 bool _internal_has_child_property_expression() const;
4500 public:
4501 void clear_child_property_expression();
4502 const std::string& child_property_expression() const;
4503 template <typename ArgT0 = const std::string&, typename... ArgT>
4504 void set_child_property_expression(ArgT0&& arg0, ArgT... args);
4505 std::string* mutable_child_property_expression();
4506 PROTOBUF_NODISCARD std::string* release_child_property_expression();
4507 void set_allocated_child_property_expression(std::string* child_property_expression);
4508 private:
4509 const std::string& _internal_child_property_expression() const;
4510 inline PROTOBUF_ALWAYS_INLINE void _internal_set_child_property_expression(const std::string& value);
4511 std::string* _internal_mutable_child_property_expression();
4512 public:
4513
4514 // optional .icing.lib.JoinSpecProto.NestedSpecProto nested_spec = 1;
4515 bool has_nested_spec() const;
4516 private:
4517 bool _internal_has_nested_spec() const;
4518 public:
4519 void clear_nested_spec();
4520 const ::icing::lib::JoinSpecProto_NestedSpecProto& nested_spec() const;
4521 PROTOBUF_NODISCARD ::icing::lib::JoinSpecProto_NestedSpecProto* release_nested_spec();
4522 ::icing::lib::JoinSpecProto_NestedSpecProto* mutable_nested_spec();
4523 void set_allocated_nested_spec(::icing::lib::JoinSpecProto_NestedSpecProto* nested_spec);
4524 private:
4525 const ::icing::lib::JoinSpecProto_NestedSpecProto& _internal_nested_spec() const;
4526 ::icing::lib::JoinSpecProto_NestedSpecProto* _internal_mutable_nested_spec();
4527 public:
4528 void unsafe_arena_set_allocated_nested_spec(
4529 ::icing::lib::JoinSpecProto_NestedSpecProto* nested_spec);
4530 ::icing::lib::JoinSpecProto_NestedSpecProto* unsafe_arena_release_nested_spec();
4531
4532 // optional int32 max_joined_child_count = 4 [deprecated = true];
4533 PROTOBUF_DEPRECATED bool has_max_joined_child_count() const;
4534 private:
4535 bool _internal_has_max_joined_child_count() const;
4536 public:
4537 PROTOBUF_DEPRECATED void clear_max_joined_child_count();
4538 PROTOBUF_DEPRECATED ::int32_t max_joined_child_count() const;
4539 PROTOBUF_DEPRECATED void set_max_joined_child_count(::int32_t value);
4540 private:
4541 ::int32_t _internal_max_joined_child_count() const;
4542 void _internal_set_max_joined_child_count(::int32_t value);
4543 public:
4544
4545 // optional .icing.lib.JoinSpecProto.AggregationScoringStrategy.Code aggregation_scoring_strategy = 5;
4546 bool has_aggregation_scoring_strategy() const;
4547 private:
4548 bool _internal_has_aggregation_scoring_strategy() const;
4549 public:
4550 void clear_aggregation_scoring_strategy();
4551 ::icing::lib::JoinSpecProto_AggregationScoringStrategy_Code aggregation_scoring_strategy() const;
4552 void set_aggregation_scoring_strategy(::icing::lib::JoinSpecProto_AggregationScoringStrategy_Code value);
4553 private:
4554 ::icing::lib::JoinSpecProto_AggregationScoringStrategy_Code _internal_aggregation_scoring_strategy() const;
4555 void _internal_set_aggregation_scoring_strategy(::icing::lib::JoinSpecProto_AggregationScoringStrategy_Code value);
4556 public:
4557
4558 // @@protoc_insertion_point(class_scope:icing.lib.JoinSpecProto)
4559 private:
4560 class _Internal;
4561
4562 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
4563 typedef void InternalArenaConstructable_;
4564 typedef void DestructorSkippable_;
4565 struct Impl_ {
4566 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
4567 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
4568 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr parent_property_expression_;
4569 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr child_property_expression_;
4570 ::icing::lib::JoinSpecProto_NestedSpecProto* nested_spec_;
4571 ::int32_t max_joined_child_count_;
4572 int aggregation_scoring_strategy_;
4573 };
4574 union { Impl_ _impl_; };
4575 friend struct ::TableStruct_icing_2fproto_2fsearch_2eproto;
4576 };
4577 // ===================================================================
4578
4579
4580 // ===================================================================
4581
4582 #ifdef __GNUC__
4583 #pragma GCC diagnostic push
4584 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
4585 #endif // __GNUC__
4586 // SearchSpecProto_EmbeddingQueryMetricType
4587
4588 // -------------------------------------------------------------------
4589
4590 // SearchSpecProto
4591
4592 // optional string query = 1;
_internal_has_query()4593 inline bool SearchSpecProto::_internal_has_query() const {
4594 bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
4595 return value;
4596 }
has_query()4597 inline bool SearchSpecProto::has_query() const {
4598 return _internal_has_query();
4599 }
clear_query()4600 inline void SearchSpecProto::clear_query() {
4601 _impl_.query_.ClearToEmpty();
4602 _impl_._has_bits_[0] &= ~0x00000001u;
4603 }
query()4604 inline const std::string& SearchSpecProto::query() const {
4605 // @@protoc_insertion_point(field_get:icing.lib.SearchSpecProto.query)
4606 return _internal_query();
4607 }
4608 template <typename ArgT0, typename... ArgT>
4609 inline PROTOBUF_ALWAYS_INLINE
set_query(ArgT0 && arg0,ArgT...args)4610 void SearchSpecProto::set_query(ArgT0&& arg0, ArgT... args) {
4611 _impl_._has_bits_[0] |= 0x00000001u;
4612 _impl_.query_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
4613 // @@protoc_insertion_point(field_set:icing.lib.SearchSpecProto.query)
4614 }
mutable_query()4615 inline std::string* SearchSpecProto::mutable_query() {
4616 std::string* _s = _internal_mutable_query();
4617 // @@protoc_insertion_point(field_mutable:icing.lib.SearchSpecProto.query)
4618 return _s;
4619 }
_internal_query()4620 inline const std::string& SearchSpecProto::_internal_query() const {
4621 return _impl_.query_.Get();
4622 }
_internal_set_query(const std::string & value)4623 inline void SearchSpecProto::_internal_set_query(const std::string& value) {
4624 _impl_._has_bits_[0] |= 0x00000001u;
4625 _impl_.query_.Set(value, GetArenaForAllocation());
4626 }
_internal_mutable_query()4627 inline std::string* SearchSpecProto::_internal_mutable_query() {
4628 _impl_._has_bits_[0] |= 0x00000001u;
4629 return _impl_.query_.Mutable(GetArenaForAllocation());
4630 }
release_query()4631 inline std::string* SearchSpecProto::release_query() {
4632 // @@protoc_insertion_point(field_release:icing.lib.SearchSpecProto.query)
4633 if (!_internal_has_query()) {
4634 return nullptr;
4635 }
4636 _impl_._has_bits_[0] &= ~0x00000001u;
4637 auto* p = _impl_.query_.Release();
4638 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4639 if (_impl_.query_.IsDefault()) {
4640 _impl_.query_.Set("", GetArenaForAllocation());
4641 }
4642 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4643 return p;
4644 }
set_allocated_query(std::string * query)4645 inline void SearchSpecProto::set_allocated_query(std::string* query) {
4646 if (query != nullptr) {
4647 _impl_._has_bits_[0] |= 0x00000001u;
4648 } else {
4649 _impl_._has_bits_[0] &= ~0x00000001u;
4650 }
4651 _impl_.query_.SetAllocated(query, GetArenaForAllocation());
4652 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4653 if (_impl_.query_.IsDefault()) {
4654 _impl_.query_.Set("", GetArenaForAllocation());
4655 }
4656 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4657 // @@protoc_insertion_point(field_set_allocated:icing.lib.SearchSpecProto.query)
4658 }
4659
4660 // optional .icing.lib.TermMatchType.Code term_match_type = 2;
_internal_has_term_match_type()4661 inline bool SearchSpecProto::_internal_has_term_match_type() const {
4662 bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
4663 return value;
4664 }
has_term_match_type()4665 inline bool SearchSpecProto::has_term_match_type() const {
4666 return _internal_has_term_match_type();
4667 }
clear_term_match_type()4668 inline void SearchSpecProto::clear_term_match_type() {
4669 _impl_.term_match_type_ = 0;
4670 _impl_._has_bits_[0] &= ~0x00000008u;
4671 }
_internal_term_match_type()4672 inline ::icing::lib::TermMatchType_Code SearchSpecProto::_internal_term_match_type() const {
4673 return static_cast< ::icing::lib::TermMatchType_Code >(_impl_.term_match_type_);
4674 }
term_match_type()4675 inline ::icing::lib::TermMatchType_Code SearchSpecProto::term_match_type() const {
4676 // @@protoc_insertion_point(field_get:icing.lib.SearchSpecProto.term_match_type)
4677 return _internal_term_match_type();
4678 }
_internal_set_term_match_type(::icing::lib::TermMatchType_Code value)4679 inline void SearchSpecProto::_internal_set_term_match_type(::icing::lib::TermMatchType_Code value) {
4680 assert(::icing::lib::TermMatchType_Code_IsValid(value));
4681 _impl_._has_bits_[0] |= 0x00000008u;
4682 _impl_.term_match_type_ = value;
4683 }
set_term_match_type(::icing::lib::TermMatchType_Code value)4684 inline void SearchSpecProto::set_term_match_type(::icing::lib::TermMatchType_Code value) {
4685 _internal_set_term_match_type(value);
4686 // @@protoc_insertion_point(field_set:icing.lib.SearchSpecProto.term_match_type)
4687 }
4688
4689 // repeated string namespace_filters = 3;
_internal_namespace_filters_size()4690 inline int SearchSpecProto::_internal_namespace_filters_size() const {
4691 return _impl_.namespace_filters_.size();
4692 }
namespace_filters_size()4693 inline int SearchSpecProto::namespace_filters_size() const {
4694 return _internal_namespace_filters_size();
4695 }
clear_namespace_filters()4696 inline void SearchSpecProto::clear_namespace_filters() {
4697 _impl_.namespace_filters_.Clear();
4698 }
add_namespace_filters()4699 inline std::string* SearchSpecProto::add_namespace_filters() {
4700 std::string* _s = _internal_add_namespace_filters();
4701 // @@protoc_insertion_point(field_add_mutable:icing.lib.SearchSpecProto.namespace_filters)
4702 return _s;
4703 }
_internal_namespace_filters(int index)4704 inline const std::string& SearchSpecProto::_internal_namespace_filters(int index) const {
4705 return _impl_.namespace_filters_.Get(index);
4706 }
namespace_filters(int index)4707 inline const std::string& SearchSpecProto::namespace_filters(int index) const {
4708 // @@protoc_insertion_point(field_get:icing.lib.SearchSpecProto.namespace_filters)
4709 return _internal_namespace_filters(index);
4710 }
mutable_namespace_filters(int index)4711 inline std::string* SearchSpecProto::mutable_namespace_filters(int index) {
4712 // @@protoc_insertion_point(field_mutable:icing.lib.SearchSpecProto.namespace_filters)
4713 return _impl_.namespace_filters_.Mutable(index);
4714 }
set_namespace_filters(int index,const std::string & value)4715 inline void SearchSpecProto::set_namespace_filters(int index, const std::string& value) {
4716 _impl_.namespace_filters_.Mutable(index)->assign(value);
4717 // @@protoc_insertion_point(field_set:icing.lib.SearchSpecProto.namespace_filters)
4718 }
set_namespace_filters(int index,std::string && value)4719 inline void SearchSpecProto::set_namespace_filters(int index, std::string&& value) {
4720 _impl_.namespace_filters_.Mutable(index)->assign(std::move(value));
4721 // @@protoc_insertion_point(field_set:icing.lib.SearchSpecProto.namespace_filters)
4722 }
set_namespace_filters(int index,const char * value)4723 inline void SearchSpecProto::set_namespace_filters(int index, const char* value) {
4724 GOOGLE_DCHECK(value != nullptr);
4725 _impl_.namespace_filters_.Mutable(index)->assign(value);
4726 // @@protoc_insertion_point(field_set_char:icing.lib.SearchSpecProto.namespace_filters)
4727 }
set_namespace_filters(int index,const char * value,size_t size)4728 inline void SearchSpecProto::set_namespace_filters(int index, const char* value, size_t size) {
4729 _impl_.namespace_filters_.Mutable(index)->assign(
4730 reinterpret_cast<const char*>(value), size);
4731 // @@protoc_insertion_point(field_set_pointer:icing.lib.SearchSpecProto.namespace_filters)
4732 }
_internal_add_namespace_filters()4733 inline std::string* SearchSpecProto::_internal_add_namespace_filters() {
4734 return _impl_.namespace_filters_.Add();
4735 }
add_namespace_filters(const std::string & value)4736 inline void SearchSpecProto::add_namespace_filters(const std::string& value) {
4737 _impl_.namespace_filters_.Add()->assign(value);
4738 // @@protoc_insertion_point(field_add:icing.lib.SearchSpecProto.namespace_filters)
4739 }
add_namespace_filters(std::string && value)4740 inline void SearchSpecProto::add_namespace_filters(std::string&& value) {
4741 _impl_.namespace_filters_.Add(std::move(value));
4742 // @@protoc_insertion_point(field_add:icing.lib.SearchSpecProto.namespace_filters)
4743 }
add_namespace_filters(const char * value)4744 inline void SearchSpecProto::add_namespace_filters(const char* value) {
4745 GOOGLE_DCHECK(value != nullptr);
4746 _impl_.namespace_filters_.Add()->assign(value);
4747 // @@protoc_insertion_point(field_add_char:icing.lib.SearchSpecProto.namespace_filters)
4748 }
add_namespace_filters(const char * value,size_t size)4749 inline void SearchSpecProto::add_namespace_filters(const char* value, size_t size) {
4750 _impl_.namespace_filters_.Add()->assign(reinterpret_cast<const char*>(value), size);
4751 // @@protoc_insertion_point(field_add_pointer:icing.lib.SearchSpecProto.namespace_filters)
4752 }
4753 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
namespace_filters()4754 SearchSpecProto::namespace_filters() const {
4755 // @@protoc_insertion_point(field_list:icing.lib.SearchSpecProto.namespace_filters)
4756 return _impl_.namespace_filters_;
4757 }
4758 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
mutable_namespace_filters()4759 SearchSpecProto::mutable_namespace_filters() {
4760 // @@protoc_insertion_point(field_mutable_list:icing.lib.SearchSpecProto.namespace_filters)
4761 return &_impl_.namespace_filters_;
4762 }
4763
4764 // repeated string schema_type_filters = 4;
_internal_schema_type_filters_size()4765 inline int SearchSpecProto::_internal_schema_type_filters_size() const {
4766 return _impl_.schema_type_filters_.size();
4767 }
schema_type_filters_size()4768 inline int SearchSpecProto::schema_type_filters_size() const {
4769 return _internal_schema_type_filters_size();
4770 }
clear_schema_type_filters()4771 inline void SearchSpecProto::clear_schema_type_filters() {
4772 _impl_.schema_type_filters_.Clear();
4773 }
add_schema_type_filters()4774 inline std::string* SearchSpecProto::add_schema_type_filters() {
4775 std::string* _s = _internal_add_schema_type_filters();
4776 // @@protoc_insertion_point(field_add_mutable:icing.lib.SearchSpecProto.schema_type_filters)
4777 return _s;
4778 }
_internal_schema_type_filters(int index)4779 inline const std::string& SearchSpecProto::_internal_schema_type_filters(int index) const {
4780 return _impl_.schema_type_filters_.Get(index);
4781 }
schema_type_filters(int index)4782 inline const std::string& SearchSpecProto::schema_type_filters(int index) const {
4783 // @@protoc_insertion_point(field_get:icing.lib.SearchSpecProto.schema_type_filters)
4784 return _internal_schema_type_filters(index);
4785 }
mutable_schema_type_filters(int index)4786 inline std::string* SearchSpecProto::mutable_schema_type_filters(int index) {
4787 // @@protoc_insertion_point(field_mutable:icing.lib.SearchSpecProto.schema_type_filters)
4788 return _impl_.schema_type_filters_.Mutable(index);
4789 }
set_schema_type_filters(int index,const std::string & value)4790 inline void SearchSpecProto::set_schema_type_filters(int index, const std::string& value) {
4791 _impl_.schema_type_filters_.Mutable(index)->assign(value);
4792 // @@protoc_insertion_point(field_set:icing.lib.SearchSpecProto.schema_type_filters)
4793 }
set_schema_type_filters(int index,std::string && value)4794 inline void SearchSpecProto::set_schema_type_filters(int index, std::string&& value) {
4795 _impl_.schema_type_filters_.Mutable(index)->assign(std::move(value));
4796 // @@protoc_insertion_point(field_set:icing.lib.SearchSpecProto.schema_type_filters)
4797 }
set_schema_type_filters(int index,const char * value)4798 inline void SearchSpecProto::set_schema_type_filters(int index, const char* value) {
4799 GOOGLE_DCHECK(value != nullptr);
4800 _impl_.schema_type_filters_.Mutable(index)->assign(value);
4801 // @@protoc_insertion_point(field_set_char:icing.lib.SearchSpecProto.schema_type_filters)
4802 }
set_schema_type_filters(int index,const char * value,size_t size)4803 inline void SearchSpecProto::set_schema_type_filters(int index, const char* value, size_t size) {
4804 _impl_.schema_type_filters_.Mutable(index)->assign(
4805 reinterpret_cast<const char*>(value), size);
4806 // @@protoc_insertion_point(field_set_pointer:icing.lib.SearchSpecProto.schema_type_filters)
4807 }
_internal_add_schema_type_filters()4808 inline std::string* SearchSpecProto::_internal_add_schema_type_filters() {
4809 return _impl_.schema_type_filters_.Add();
4810 }
add_schema_type_filters(const std::string & value)4811 inline void SearchSpecProto::add_schema_type_filters(const std::string& value) {
4812 _impl_.schema_type_filters_.Add()->assign(value);
4813 // @@protoc_insertion_point(field_add:icing.lib.SearchSpecProto.schema_type_filters)
4814 }
add_schema_type_filters(std::string && value)4815 inline void SearchSpecProto::add_schema_type_filters(std::string&& value) {
4816 _impl_.schema_type_filters_.Add(std::move(value));
4817 // @@protoc_insertion_point(field_add:icing.lib.SearchSpecProto.schema_type_filters)
4818 }
add_schema_type_filters(const char * value)4819 inline void SearchSpecProto::add_schema_type_filters(const char* value) {
4820 GOOGLE_DCHECK(value != nullptr);
4821 _impl_.schema_type_filters_.Add()->assign(value);
4822 // @@protoc_insertion_point(field_add_char:icing.lib.SearchSpecProto.schema_type_filters)
4823 }
add_schema_type_filters(const char * value,size_t size)4824 inline void SearchSpecProto::add_schema_type_filters(const char* value, size_t size) {
4825 _impl_.schema_type_filters_.Add()->assign(reinterpret_cast<const char*>(value), size);
4826 // @@protoc_insertion_point(field_add_pointer:icing.lib.SearchSpecProto.schema_type_filters)
4827 }
4828 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
schema_type_filters()4829 SearchSpecProto::schema_type_filters() const {
4830 // @@protoc_insertion_point(field_list:icing.lib.SearchSpecProto.schema_type_filters)
4831 return _impl_.schema_type_filters_;
4832 }
4833 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
mutable_schema_type_filters()4834 SearchSpecProto::mutable_schema_type_filters() {
4835 // @@protoc_insertion_point(field_mutable_list:icing.lib.SearchSpecProto.schema_type_filters)
4836 return &_impl_.schema_type_filters_;
4837 }
4838
4839 // repeated .icing.lib.NamespaceDocumentUriGroup document_uri_filters = 14;
_internal_document_uri_filters_size()4840 inline int SearchSpecProto::_internal_document_uri_filters_size() const {
4841 return _impl_.document_uri_filters_.size();
4842 }
document_uri_filters_size()4843 inline int SearchSpecProto::document_uri_filters_size() const {
4844 return _internal_document_uri_filters_size();
4845 }
clear_document_uri_filters()4846 inline void SearchSpecProto::clear_document_uri_filters() {
4847 _impl_.document_uri_filters_.Clear();
4848 }
mutable_document_uri_filters(int index)4849 inline ::icing::lib::NamespaceDocumentUriGroup* SearchSpecProto::mutable_document_uri_filters(int index) {
4850 // @@protoc_insertion_point(field_mutable:icing.lib.SearchSpecProto.document_uri_filters)
4851 return _impl_.document_uri_filters_.Mutable(index);
4852 }
4853 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::NamespaceDocumentUriGroup >*
mutable_document_uri_filters()4854 SearchSpecProto::mutable_document_uri_filters() {
4855 // @@protoc_insertion_point(field_mutable_list:icing.lib.SearchSpecProto.document_uri_filters)
4856 return &_impl_.document_uri_filters_;
4857 }
_internal_document_uri_filters(int index)4858 inline const ::icing::lib::NamespaceDocumentUriGroup& SearchSpecProto::_internal_document_uri_filters(int index) const {
4859 return _impl_.document_uri_filters_.Get(index);
4860 }
document_uri_filters(int index)4861 inline const ::icing::lib::NamespaceDocumentUriGroup& SearchSpecProto::document_uri_filters(int index) const {
4862 // @@protoc_insertion_point(field_get:icing.lib.SearchSpecProto.document_uri_filters)
4863 return _internal_document_uri_filters(index);
4864 }
_internal_add_document_uri_filters()4865 inline ::icing::lib::NamespaceDocumentUriGroup* SearchSpecProto::_internal_add_document_uri_filters() {
4866 return _impl_.document_uri_filters_.Add();
4867 }
add_document_uri_filters()4868 inline ::icing::lib::NamespaceDocumentUriGroup* SearchSpecProto::add_document_uri_filters() {
4869 ::icing::lib::NamespaceDocumentUriGroup* _add = _internal_add_document_uri_filters();
4870 // @@protoc_insertion_point(field_add:icing.lib.SearchSpecProto.document_uri_filters)
4871 return _add;
4872 }
4873 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::NamespaceDocumentUriGroup >&
document_uri_filters()4874 SearchSpecProto::document_uri_filters() const {
4875 // @@protoc_insertion_point(field_list:icing.lib.SearchSpecProto.document_uri_filters)
4876 return _impl_.document_uri_filters_;
4877 }
4878
4879 // optional int64 java_to_native_start_timestamp_ms = 5;
_internal_has_java_to_native_start_timestamp_ms()4880 inline bool SearchSpecProto::_internal_has_java_to_native_start_timestamp_ms() const {
4881 bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
4882 return value;
4883 }
has_java_to_native_start_timestamp_ms()4884 inline bool SearchSpecProto::has_java_to_native_start_timestamp_ms() const {
4885 return _internal_has_java_to_native_start_timestamp_ms();
4886 }
clear_java_to_native_start_timestamp_ms()4887 inline void SearchSpecProto::clear_java_to_native_start_timestamp_ms() {
4888 _impl_.java_to_native_start_timestamp_ms_ = ::int64_t{0};
4889 _impl_._has_bits_[0] &= ~0x00000004u;
4890 }
_internal_java_to_native_start_timestamp_ms()4891 inline ::int64_t SearchSpecProto::_internal_java_to_native_start_timestamp_ms() const {
4892 return _impl_.java_to_native_start_timestamp_ms_;
4893 }
java_to_native_start_timestamp_ms()4894 inline ::int64_t SearchSpecProto::java_to_native_start_timestamp_ms() const {
4895 // @@protoc_insertion_point(field_get:icing.lib.SearchSpecProto.java_to_native_start_timestamp_ms)
4896 return _internal_java_to_native_start_timestamp_ms();
4897 }
_internal_set_java_to_native_start_timestamp_ms(::int64_t value)4898 inline void SearchSpecProto::_internal_set_java_to_native_start_timestamp_ms(::int64_t value) {
4899 _impl_._has_bits_[0] |= 0x00000004u;
4900 _impl_.java_to_native_start_timestamp_ms_ = value;
4901 }
set_java_to_native_start_timestamp_ms(::int64_t value)4902 inline void SearchSpecProto::set_java_to_native_start_timestamp_ms(::int64_t value) {
4903 _internal_set_java_to_native_start_timestamp_ms(value);
4904 // @@protoc_insertion_point(field_set:icing.lib.SearchSpecProto.java_to_native_start_timestamp_ms)
4905 }
4906
4907 // optional .icing.lib.JoinSpecProto join_spec = 7;
_internal_has_join_spec()4908 inline bool SearchSpecProto::_internal_has_join_spec() const {
4909 bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
4910 PROTOBUF_ASSUME(!value || _impl_.join_spec_ != nullptr);
4911 return value;
4912 }
has_join_spec()4913 inline bool SearchSpecProto::has_join_spec() const {
4914 return _internal_has_join_spec();
4915 }
clear_join_spec()4916 inline void SearchSpecProto::clear_join_spec() {
4917 if (_impl_.join_spec_ != nullptr) _impl_.join_spec_->Clear();
4918 _impl_._has_bits_[0] &= ~0x00000002u;
4919 }
_internal_join_spec()4920 inline const ::icing::lib::JoinSpecProto& SearchSpecProto::_internal_join_spec() const {
4921 const ::icing::lib::JoinSpecProto* p = _impl_.join_spec_;
4922 return p != nullptr ? *p : reinterpret_cast<const ::icing::lib::JoinSpecProto&>(
4923 ::icing::lib::_JoinSpecProto_default_instance_);
4924 }
join_spec()4925 inline const ::icing::lib::JoinSpecProto& SearchSpecProto::join_spec() const {
4926 // @@protoc_insertion_point(field_get:icing.lib.SearchSpecProto.join_spec)
4927 return _internal_join_spec();
4928 }
unsafe_arena_set_allocated_join_spec(::icing::lib::JoinSpecProto * join_spec)4929 inline void SearchSpecProto::unsafe_arena_set_allocated_join_spec(
4930 ::icing::lib::JoinSpecProto* join_spec) {
4931 if (GetArenaForAllocation() == nullptr) {
4932 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.join_spec_);
4933 }
4934 _impl_.join_spec_ = join_spec;
4935 if (join_spec) {
4936 _impl_._has_bits_[0] |= 0x00000002u;
4937 } else {
4938 _impl_._has_bits_[0] &= ~0x00000002u;
4939 }
4940 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:icing.lib.SearchSpecProto.join_spec)
4941 }
release_join_spec()4942 inline ::icing::lib::JoinSpecProto* SearchSpecProto::release_join_spec() {
4943 _impl_._has_bits_[0] &= ~0x00000002u;
4944 ::icing::lib::JoinSpecProto* temp = _impl_.join_spec_;
4945 _impl_.join_spec_ = nullptr;
4946 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
4947 auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
4948 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
4949 if (GetArenaForAllocation() == nullptr) { delete old; }
4950 #else // PROTOBUF_FORCE_COPY_IN_RELEASE
4951 if (GetArenaForAllocation() != nullptr) {
4952 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
4953 }
4954 #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
4955 return temp;
4956 }
unsafe_arena_release_join_spec()4957 inline ::icing::lib::JoinSpecProto* SearchSpecProto::unsafe_arena_release_join_spec() {
4958 // @@protoc_insertion_point(field_release:icing.lib.SearchSpecProto.join_spec)
4959 _impl_._has_bits_[0] &= ~0x00000002u;
4960 ::icing::lib::JoinSpecProto* temp = _impl_.join_spec_;
4961 _impl_.join_spec_ = nullptr;
4962 return temp;
4963 }
_internal_mutable_join_spec()4964 inline ::icing::lib::JoinSpecProto* SearchSpecProto::_internal_mutable_join_spec() {
4965 _impl_._has_bits_[0] |= 0x00000002u;
4966 if (_impl_.join_spec_ == nullptr) {
4967 auto* p = CreateMaybeMessage<::icing::lib::JoinSpecProto>(GetArenaForAllocation());
4968 _impl_.join_spec_ = p;
4969 }
4970 return _impl_.join_spec_;
4971 }
mutable_join_spec()4972 inline ::icing::lib::JoinSpecProto* SearchSpecProto::mutable_join_spec() {
4973 ::icing::lib::JoinSpecProto* _msg = _internal_mutable_join_spec();
4974 // @@protoc_insertion_point(field_mutable:icing.lib.SearchSpecProto.join_spec)
4975 return _msg;
4976 }
set_allocated_join_spec(::icing::lib::JoinSpecProto * join_spec)4977 inline void SearchSpecProto::set_allocated_join_spec(::icing::lib::JoinSpecProto* join_spec) {
4978 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
4979 if (message_arena == nullptr) {
4980 delete _impl_.join_spec_;
4981 }
4982 if (join_spec) {
4983 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
4984 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(join_spec);
4985 if (message_arena != submessage_arena) {
4986 join_spec = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
4987 message_arena, join_spec, submessage_arena);
4988 }
4989 _impl_._has_bits_[0] |= 0x00000002u;
4990 } else {
4991 _impl_._has_bits_[0] &= ~0x00000002u;
4992 }
4993 _impl_.join_spec_ = join_spec;
4994 // @@protoc_insertion_point(field_set_allocated:icing.lib.SearchSpecProto.join_spec)
4995 }
4996
4997 // repeated string enabled_features = 8;
_internal_enabled_features_size()4998 inline int SearchSpecProto::_internal_enabled_features_size() const {
4999 return _impl_.enabled_features_.size();
5000 }
enabled_features_size()5001 inline int SearchSpecProto::enabled_features_size() const {
5002 return _internal_enabled_features_size();
5003 }
clear_enabled_features()5004 inline void SearchSpecProto::clear_enabled_features() {
5005 _impl_.enabled_features_.Clear();
5006 }
add_enabled_features()5007 inline std::string* SearchSpecProto::add_enabled_features() {
5008 std::string* _s = _internal_add_enabled_features();
5009 // @@protoc_insertion_point(field_add_mutable:icing.lib.SearchSpecProto.enabled_features)
5010 return _s;
5011 }
_internal_enabled_features(int index)5012 inline const std::string& SearchSpecProto::_internal_enabled_features(int index) const {
5013 return _impl_.enabled_features_.Get(index);
5014 }
enabled_features(int index)5015 inline const std::string& SearchSpecProto::enabled_features(int index) const {
5016 // @@protoc_insertion_point(field_get:icing.lib.SearchSpecProto.enabled_features)
5017 return _internal_enabled_features(index);
5018 }
mutable_enabled_features(int index)5019 inline std::string* SearchSpecProto::mutable_enabled_features(int index) {
5020 // @@protoc_insertion_point(field_mutable:icing.lib.SearchSpecProto.enabled_features)
5021 return _impl_.enabled_features_.Mutable(index);
5022 }
set_enabled_features(int index,const std::string & value)5023 inline void SearchSpecProto::set_enabled_features(int index, const std::string& value) {
5024 _impl_.enabled_features_.Mutable(index)->assign(value);
5025 // @@protoc_insertion_point(field_set:icing.lib.SearchSpecProto.enabled_features)
5026 }
set_enabled_features(int index,std::string && value)5027 inline void SearchSpecProto::set_enabled_features(int index, std::string&& value) {
5028 _impl_.enabled_features_.Mutable(index)->assign(std::move(value));
5029 // @@protoc_insertion_point(field_set:icing.lib.SearchSpecProto.enabled_features)
5030 }
set_enabled_features(int index,const char * value)5031 inline void SearchSpecProto::set_enabled_features(int index, const char* value) {
5032 GOOGLE_DCHECK(value != nullptr);
5033 _impl_.enabled_features_.Mutable(index)->assign(value);
5034 // @@protoc_insertion_point(field_set_char:icing.lib.SearchSpecProto.enabled_features)
5035 }
set_enabled_features(int index,const char * value,size_t size)5036 inline void SearchSpecProto::set_enabled_features(int index, const char* value, size_t size) {
5037 _impl_.enabled_features_.Mutable(index)->assign(
5038 reinterpret_cast<const char*>(value), size);
5039 // @@protoc_insertion_point(field_set_pointer:icing.lib.SearchSpecProto.enabled_features)
5040 }
_internal_add_enabled_features()5041 inline std::string* SearchSpecProto::_internal_add_enabled_features() {
5042 return _impl_.enabled_features_.Add();
5043 }
add_enabled_features(const std::string & value)5044 inline void SearchSpecProto::add_enabled_features(const std::string& value) {
5045 _impl_.enabled_features_.Add()->assign(value);
5046 // @@protoc_insertion_point(field_add:icing.lib.SearchSpecProto.enabled_features)
5047 }
add_enabled_features(std::string && value)5048 inline void SearchSpecProto::add_enabled_features(std::string&& value) {
5049 _impl_.enabled_features_.Add(std::move(value));
5050 // @@protoc_insertion_point(field_add:icing.lib.SearchSpecProto.enabled_features)
5051 }
add_enabled_features(const char * value)5052 inline void SearchSpecProto::add_enabled_features(const char* value) {
5053 GOOGLE_DCHECK(value != nullptr);
5054 _impl_.enabled_features_.Add()->assign(value);
5055 // @@protoc_insertion_point(field_add_char:icing.lib.SearchSpecProto.enabled_features)
5056 }
add_enabled_features(const char * value,size_t size)5057 inline void SearchSpecProto::add_enabled_features(const char* value, size_t size) {
5058 _impl_.enabled_features_.Add()->assign(reinterpret_cast<const char*>(value), size);
5059 // @@protoc_insertion_point(field_add_pointer:icing.lib.SearchSpecProto.enabled_features)
5060 }
5061 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
enabled_features()5062 SearchSpecProto::enabled_features() const {
5063 // @@protoc_insertion_point(field_list:icing.lib.SearchSpecProto.enabled_features)
5064 return _impl_.enabled_features_;
5065 }
5066 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
mutable_enabled_features()5067 SearchSpecProto::mutable_enabled_features() {
5068 // @@protoc_insertion_point(field_mutable_list:icing.lib.SearchSpecProto.enabled_features)
5069 return &_impl_.enabled_features_;
5070 }
5071
5072 // optional bool use_read_only_search = 9 [default = true];
_internal_has_use_read_only_search()5073 inline bool SearchSpecProto::_internal_has_use_read_only_search() const {
5074 bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
5075 return value;
5076 }
has_use_read_only_search()5077 inline bool SearchSpecProto::has_use_read_only_search() const {
5078 return _internal_has_use_read_only_search();
5079 }
clear_use_read_only_search()5080 inline void SearchSpecProto::clear_use_read_only_search() {
5081 _impl_.use_read_only_search_ = true;
5082 _impl_._has_bits_[0] &= ~0x00000020u;
5083 }
_internal_use_read_only_search()5084 inline bool SearchSpecProto::_internal_use_read_only_search() const {
5085 return _impl_.use_read_only_search_;
5086 }
use_read_only_search()5087 inline bool SearchSpecProto::use_read_only_search() const {
5088 // @@protoc_insertion_point(field_get:icing.lib.SearchSpecProto.use_read_only_search)
5089 return _internal_use_read_only_search();
5090 }
_internal_set_use_read_only_search(bool value)5091 inline void SearchSpecProto::_internal_set_use_read_only_search(bool value) {
5092 _impl_._has_bits_[0] |= 0x00000020u;
5093 _impl_.use_read_only_search_ = value;
5094 }
set_use_read_only_search(bool value)5095 inline void SearchSpecProto::set_use_read_only_search(bool value) {
5096 _internal_set_use_read_only_search(value);
5097 // @@protoc_insertion_point(field_set:icing.lib.SearchSpecProto.use_read_only_search)
5098 }
5099
5100 // repeated .icing.lib.TypePropertyMask type_property_filters = 10;
_internal_type_property_filters_size()5101 inline int SearchSpecProto::_internal_type_property_filters_size() const {
5102 return _impl_.type_property_filters_.size();
5103 }
type_property_filters_size()5104 inline int SearchSpecProto::type_property_filters_size() const {
5105 return _internal_type_property_filters_size();
5106 }
clear_type_property_filters()5107 inline void SearchSpecProto::clear_type_property_filters() {
5108 _impl_.type_property_filters_.Clear();
5109 }
mutable_type_property_filters(int index)5110 inline ::icing::lib::TypePropertyMask* SearchSpecProto::mutable_type_property_filters(int index) {
5111 // @@protoc_insertion_point(field_mutable:icing.lib.SearchSpecProto.type_property_filters)
5112 return _impl_.type_property_filters_.Mutable(index);
5113 }
5114 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::TypePropertyMask >*
mutable_type_property_filters()5115 SearchSpecProto::mutable_type_property_filters() {
5116 // @@protoc_insertion_point(field_mutable_list:icing.lib.SearchSpecProto.type_property_filters)
5117 return &_impl_.type_property_filters_;
5118 }
_internal_type_property_filters(int index)5119 inline const ::icing::lib::TypePropertyMask& SearchSpecProto::_internal_type_property_filters(int index) const {
5120 return _impl_.type_property_filters_.Get(index);
5121 }
type_property_filters(int index)5122 inline const ::icing::lib::TypePropertyMask& SearchSpecProto::type_property_filters(int index) const {
5123 // @@protoc_insertion_point(field_get:icing.lib.SearchSpecProto.type_property_filters)
5124 return _internal_type_property_filters(index);
5125 }
_internal_add_type_property_filters()5126 inline ::icing::lib::TypePropertyMask* SearchSpecProto::_internal_add_type_property_filters() {
5127 return _impl_.type_property_filters_.Add();
5128 }
add_type_property_filters()5129 inline ::icing::lib::TypePropertyMask* SearchSpecProto::add_type_property_filters() {
5130 ::icing::lib::TypePropertyMask* _add = _internal_add_type_property_filters();
5131 // @@protoc_insertion_point(field_add:icing.lib.SearchSpecProto.type_property_filters)
5132 return _add;
5133 }
5134 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::TypePropertyMask >&
type_property_filters()5135 SearchSpecProto::type_property_filters() const {
5136 // @@protoc_insertion_point(field_list:icing.lib.SearchSpecProto.type_property_filters)
5137 return _impl_.type_property_filters_;
5138 }
5139
5140 // repeated .icing.lib.PropertyProto.VectorProto embedding_query_vectors = 11;
_internal_embedding_query_vectors_size()5141 inline int SearchSpecProto::_internal_embedding_query_vectors_size() const {
5142 return _impl_.embedding_query_vectors_.size();
5143 }
embedding_query_vectors_size()5144 inline int SearchSpecProto::embedding_query_vectors_size() const {
5145 return _internal_embedding_query_vectors_size();
5146 }
mutable_embedding_query_vectors(int index)5147 inline ::icing::lib::PropertyProto_VectorProto* SearchSpecProto::mutable_embedding_query_vectors(int index) {
5148 // @@protoc_insertion_point(field_mutable:icing.lib.SearchSpecProto.embedding_query_vectors)
5149 return _impl_.embedding_query_vectors_.Mutable(index);
5150 }
5151 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::PropertyProto_VectorProto >*
mutable_embedding_query_vectors()5152 SearchSpecProto::mutable_embedding_query_vectors() {
5153 // @@protoc_insertion_point(field_mutable_list:icing.lib.SearchSpecProto.embedding_query_vectors)
5154 return &_impl_.embedding_query_vectors_;
5155 }
_internal_embedding_query_vectors(int index)5156 inline const ::icing::lib::PropertyProto_VectorProto& SearchSpecProto::_internal_embedding_query_vectors(int index) const {
5157 return _impl_.embedding_query_vectors_.Get(index);
5158 }
embedding_query_vectors(int index)5159 inline const ::icing::lib::PropertyProto_VectorProto& SearchSpecProto::embedding_query_vectors(int index) const {
5160 // @@protoc_insertion_point(field_get:icing.lib.SearchSpecProto.embedding_query_vectors)
5161 return _internal_embedding_query_vectors(index);
5162 }
_internal_add_embedding_query_vectors()5163 inline ::icing::lib::PropertyProto_VectorProto* SearchSpecProto::_internal_add_embedding_query_vectors() {
5164 return _impl_.embedding_query_vectors_.Add();
5165 }
add_embedding_query_vectors()5166 inline ::icing::lib::PropertyProto_VectorProto* SearchSpecProto::add_embedding_query_vectors() {
5167 ::icing::lib::PropertyProto_VectorProto* _add = _internal_add_embedding_query_vectors();
5168 // @@protoc_insertion_point(field_add:icing.lib.SearchSpecProto.embedding_query_vectors)
5169 return _add;
5170 }
5171 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::PropertyProto_VectorProto >&
embedding_query_vectors()5172 SearchSpecProto::embedding_query_vectors() const {
5173 // @@protoc_insertion_point(field_list:icing.lib.SearchSpecProto.embedding_query_vectors)
5174 return _impl_.embedding_query_vectors_;
5175 }
5176
5177 // optional .icing.lib.SearchSpecProto.EmbeddingQueryMetricType.Code embedding_query_metric_type = 12;
_internal_has_embedding_query_metric_type()5178 inline bool SearchSpecProto::_internal_has_embedding_query_metric_type() const {
5179 bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
5180 return value;
5181 }
has_embedding_query_metric_type()5182 inline bool SearchSpecProto::has_embedding_query_metric_type() const {
5183 return _internal_has_embedding_query_metric_type();
5184 }
clear_embedding_query_metric_type()5185 inline void SearchSpecProto::clear_embedding_query_metric_type() {
5186 _impl_.embedding_query_metric_type_ = 0;
5187 _impl_._has_bits_[0] &= ~0x00000010u;
5188 }
_internal_embedding_query_metric_type()5189 inline ::icing::lib::SearchSpecProto_EmbeddingQueryMetricType_Code SearchSpecProto::_internal_embedding_query_metric_type() const {
5190 return static_cast< ::icing::lib::SearchSpecProto_EmbeddingQueryMetricType_Code >(_impl_.embedding_query_metric_type_);
5191 }
embedding_query_metric_type()5192 inline ::icing::lib::SearchSpecProto_EmbeddingQueryMetricType_Code SearchSpecProto::embedding_query_metric_type() const {
5193 // @@protoc_insertion_point(field_get:icing.lib.SearchSpecProto.embedding_query_metric_type)
5194 return _internal_embedding_query_metric_type();
5195 }
_internal_set_embedding_query_metric_type(::icing::lib::SearchSpecProto_EmbeddingQueryMetricType_Code value)5196 inline void SearchSpecProto::_internal_set_embedding_query_metric_type(::icing::lib::SearchSpecProto_EmbeddingQueryMetricType_Code value) {
5197 assert(::icing::lib::SearchSpecProto_EmbeddingQueryMetricType_Code_IsValid(value));
5198 _impl_._has_bits_[0] |= 0x00000010u;
5199 _impl_.embedding_query_metric_type_ = value;
5200 }
set_embedding_query_metric_type(::icing::lib::SearchSpecProto_EmbeddingQueryMetricType_Code value)5201 inline void SearchSpecProto::set_embedding_query_metric_type(::icing::lib::SearchSpecProto_EmbeddingQueryMetricType_Code value) {
5202 _internal_set_embedding_query_metric_type(value);
5203 // @@protoc_insertion_point(field_set:icing.lib.SearchSpecProto.embedding_query_metric_type)
5204 }
5205
5206 // repeated string query_parameter_strings = 13;
_internal_query_parameter_strings_size()5207 inline int SearchSpecProto::_internal_query_parameter_strings_size() const {
5208 return _impl_.query_parameter_strings_.size();
5209 }
query_parameter_strings_size()5210 inline int SearchSpecProto::query_parameter_strings_size() const {
5211 return _internal_query_parameter_strings_size();
5212 }
clear_query_parameter_strings()5213 inline void SearchSpecProto::clear_query_parameter_strings() {
5214 _impl_.query_parameter_strings_.Clear();
5215 }
add_query_parameter_strings()5216 inline std::string* SearchSpecProto::add_query_parameter_strings() {
5217 std::string* _s = _internal_add_query_parameter_strings();
5218 // @@protoc_insertion_point(field_add_mutable:icing.lib.SearchSpecProto.query_parameter_strings)
5219 return _s;
5220 }
_internal_query_parameter_strings(int index)5221 inline const std::string& SearchSpecProto::_internal_query_parameter_strings(int index) const {
5222 return _impl_.query_parameter_strings_.Get(index);
5223 }
query_parameter_strings(int index)5224 inline const std::string& SearchSpecProto::query_parameter_strings(int index) const {
5225 // @@protoc_insertion_point(field_get:icing.lib.SearchSpecProto.query_parameter_strings)
5226 return _internal_query_parameter_strings(index);
5227 }
mutable_query_parameter_strings(int index)5228 inline std::string* SearchSpecProto::mutable_query_parameter_strings(int index) {
5229 // @@protoc_insertion_point(field_mutable:icing.lib.SearchSpecProto.query_parameter_strings)
5230 return _impl_.query_parameter_strings_.Mutable(index);
5231 }
set_query_parameter_strings(int index,const std::string & value)5232 inline void SearchSpecProto::set_query_parameter_strings(int index, const std::string& value) {
5233 _impl_.query_parameter_strings_.Mutable(index)->assign(value);
5234 // @@protoc_insertion_point(field_set:icing.lib.SearchSpecProto.query_parameter_strings)
5235 }
set_query_parameter_strings(int index,std::string && value)5236 inline void SearchSpecProto::set_query_parameter_strings(int index, std::string&& value) {
5237 _impl_.query_parameter_strings_.Mutable(index)->assign(std::move(value));
5238 // @@protoc_insertion_point(field_set:icing.lib.SearchSpecProto.query_parameter_strings)
5239 }
set_query_parameter_strings(int index,const char * value)5240 inline void SearchSpecProto::set_query_parameter_strings(int index, const char* value) {
5241 GOOGLE_DCHECK(value != nullptr);
5242 _impl_.query_parameter_strings_.Mutable(index)->assign(value);
5243 // @@protoc_insertion_point(field_set_char:icing.lib.SearchSpecProto.query_parameter_strings)
5244 }
set_query_parameter_strings(int index,const char * value,size_t size)5245 inline void SearchSpecProto::set_query_parameter_strings(int index, const char* value, size_t size) {
5246 _impl_.query_parameter_strings_.Mutable(index)->assign(
5247 reinterpret_cast<const char*>(value), size);
5248 // @@protoc_insertion_point(field_set_pointer:icing.lib.SearchSpecProto.query_parameter_strings)
5249 }
_internal_add_query_parameter_strings()5250 inline std::string* SearchSpecProto::_internal_add_query_parameter_strings() {
5251 return _impl_.query_parameter_strings_.Add();
5252 }
add_query_parameter_strings(const std::string & value)5253 inline void SearchSpecProto::add_query_parameter_strings(const std::string& value) {
5254 _impl_.query_parameter_strings_.Add()->assign(value);
5255 // @@protoc_insertion_point(field_add:icing.lib.SearchSpecProto.query_parameter_strings)
5256 }
add_query_parameter_strings(std::string && value)5257 inline void SearchSpecProto::add_query_parameter_strings(std::string&& value) {
5258 _impl_.query_parameter_strings_.Add(std::move(value));
5259 // @@protoc_insertion_point(field_add:icing.lib.SearchSpecProto.query_parameter_strings)
5260 }
add_query_parameter_strings(const char * value)5261 inline void SearchSpecProto::add_query_parameter_strings(const char* value) {
5262 GOOGLE_DCHECK(value != nullptr);
5263 _impl_.query_parameter_strings_.Add()->assign(value);
5264 // @@protoc_insertion_point(field_add_char:icing.lib.SearchSpecProto.query_parameter_strings)
5265 }
add_query_parameter_strings(const char * value,size_t size)5266 inline void SearchSpecProto::add_query_parameter_strings(const char* value, size_t size) {
5267 _impl_.query_parameter_strings_.Add()->assign(reinterpret_cast<const char*>(value), size);
5268 // @@protoc_insertion_point(field_add_pointer:icing.lib.SearchSpecProto.query_parameter_strings)
5269 }
5270 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
query_parameter_strings()5271 SearchSpecProto::query_parameter_strings() const {
5272 // @@protoc_insertion_point(field_list:icing.lib.SearchSpecProto.query_parameter_strings)
5273 return _impl_.query_parameter_strings_;
5274 }
5275 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
mutable_query_parameter_strings()5276 SearchSpecProto::mutable_query_parameter_strings() {
5277 // @@protoc_insertion_point(field_mutable_list:icing.lib.SearchSpecProto.query_parameter_strings)
5278 return &_impl_.query_parameter_strings_;
5279 }
5280
5281 // -------------------------------------------------------------------
5282
5283 // ResultSpecProto_SnippetSpecProto
5284
5285 // optional int32 num_to_snippet = 1;
_internal_has_num_to_snippet()5286 inline bool ResultSpecProto_SnippetSpecProto::_internal_has_num_to_snippet() const {
5287 bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
5288 return value;
5289 }
has_num_to_snippet()5290 inline bool ResultSpecProto_SnippetSpecProto::has_num_to_snippet() const {
5291 return _internal_has_num_to_snippet();
5292 }
clear_num_to_snippet()5293 inline void ResultSpecProto_SnippetSpecProto::clear_num_to_snippet() {
5294 _impl_.num_to_snippet_ = 0;
5295 _impl_._has_bits_[0] &= ~0x00000001u;
5296 }
_internal_num_to_snippet()5297 inline ::int32_t ResultSpecProto_SnippetSpecProto::_internal_num_to_snippet() const {
5298 return _impl_.num_to_snippet_;
5299 }
num_to_snippet()5300 inline ::int32_t ResultSpecProto_SnippetSpecProto::num_to_snippet() const {
5301 // @@protoc_insertion_point(field_get:icing.lib.ResultSpecProto.SnippetSpecProto.num_to_snippet)
5302 return _internal_num_to_snippet();
5303 }
_internal_set_num_to_snippet(::int32_t value)5304 inline void ResultSpecProto_SnippetSpecProto::_internal_set_num_to_snippet(::int32_t value) {
5305 _impl_._has_bits_[0] |= 0x00000001u;
5306 _impl_.num_to_snippet_ = value;
5307 }
set_num_to_snippet(::int32_t value)5308 inline void ResultSpecProto_SnippetSpecProto::set_num_to_snippet(::int32_t value) {
5309 _internal_set_num_to_snippet(value);
5310 // @@protoc_insertion_point(field_set:icing.lib.ResultSpecProto.SnippetSpecProto.num_to_snippet)
5311 }
5312
5313 // optional int32 num_matches_per_property = 2;
_internal_has_num_matches_per_property()5314 inline bool ResultSpecProto_SnippetSpecProto::_internal_has_num_matches_per_property() const {
5315 bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
5316 return value;
5317 }
has_num_matches_per_property()5318 inline bool ResultSpecProto_SnippetSpecProto::has_num_matches_per_property() const {
5319 return _internal_has_num_matches_per_property();
5320 }
clear_num_matches_per_property()5321 inline void ResultSpecProto_SnippetSpecProto::clear_num_matches_per_property() {
5322 _impl_.num_matches_per_property_ = 0;
5323 _impl_._has_bits_[0] &= ~0x00000002u;
5324 }
_internal_num_matches_per_property()5325 inline ::int32_t ResultSpecProto_SnippetSpecProto::_internal_num_matches_per_property() const {
5326 return _impl_.num_matches_per_property_;
5327 }
num_matches_per_property()5328 inline ::int32_t ResultSpecProto_SnippetSpecProto::num_matches_per_property() const {
5329 // @@protoc_insertion_point(field_get:icing.lib.ResultSpecProto.SnippetSpecProto.num_matches_per_property)
5330 return _internal_num_matches_per_property();
5331 }
_internal_set_num_matches_per_property(::int32_t value)5332 inline void ResultSpecProto_SnippetSpecProto::_internal_set_num_matches_per_property(::int32_t value) {
5333 _impl_._has_bits_[0] |= 0x00000002u;
5334 _impl_.num_matches_per_property_ = value;
5335 }
set_num_matches_per_property(::int32_t value)5336 inline void ResultSpecProto_SnippetSpecProto::set_num_matches_per_property(::int32_t value) {
5337 _internal_set_num_matches_per_property(value);
5338 // @@protoc_insertion_point(field_set:icing.lib.ResultSpecProto.SnippetSpecProto.num_matches_per_property)
5339 }
5340
5341 // optional int32 max_window_utf32_length = 3;
_internal_has_max_window_utf32_length()5342 inline bool ResultSpecProto_SnippetSpecProto::_internal_has_max_window_utf32_length() const {
5343 bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
5344 return value;
5345 }
has_max_window_utf32_length()5346 inline bool ResultSpecProto_SnippetSpecProto::has_max_window_utf32_length() const {
5347 return _internal_has_max_window_utf32_length();
5348 }
clear_max_window_utf32_length()5349 inline void ResultSpecProto_SnippetSpecProto::clear_max_window_utf32_length() {
5350 _impl_.max_window_utf32_length_ = 0;
5351 _impl_._has_bits_[0] &= ~0x00000004u;
5352 }
_internal_max_window_utf32_length()5353 inline ::int32_t ResultSpecProto_SnippetSpecProto::_internal_max_window_utf32_length() const {
5354 return _impl_.max_window_utf32_length_;
5355 }
max_window_utf32_length()5356 inline ::int32_t ResultSpecProto_SnippetSpecProto::max_window_utf32_length() const {
5357 // @@protoc_insertion_point(field_get:icing.lib.ResultSpecProto.SnippetSpecProto.max_window_utf32_length)
5358 return _internal_max_window_utf32_length();
5359 }
_internal_set_max_window_utf32_length(::int32_t value)5360 inline void ResultSpecProto_SnippetSpecProto::_internal_set_max_window_utf32_length(::int32_t value) {
5361 _impl_._has_bits_[0] |= 0x00000004u;
5362 _impl_.max_window_utf32_length_ = value;
5363 }
set_max_window_utf32_length(::int32_t value)5364 inline void ResultSpecProto_SnippetSpecProto::set_max_window_utf32_length(::int32_t value) {
5365 _internal_set_max_window_utf32_length(value);
5366 // @@protoc_insertion_point(field_set:icing.lib.ResultSpecProto.SnippetSpecProto.max_window_utf32_length)
5367 }
5368
5369 // -------------------------------------------------------------------
5370
5371 // ResultSpecProto_ResultGrouping_Entry
5372
5373 // optional string namespace = 1;
_internal_has_namespace_()5374 inline bool ResultSpecProto_ResultGrouping_Entry::_internal_has_namespace_() const {
5375 bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
5376 return value;
5377 }
has_namespace_()5378 inline bool ResultSpecProto_ResultGrouping_Entry::has_namespace_() const {
5379 return _internal_has_namespace_();
5380 }
clear_namespace_()5381 inline void ResultSpecProto_ResultGrouping_Entry::clear_namespace_() {
5382 _impl_.namespace__.ClearToEmpty();
5383 _impl_._has_bits_[0] &= ~0x00000001u;
5384 }
namespace_()5385 inline const std::string& ResultSpecProto_ResultGrouping_Entry::namespace_() const {
5386 // @@protoc_insertion_point(field_get:icing.lib.ResultSpecProto.ResultGrouping.Entry.namespace)
5387 return _internal_namespace_();
5388 }
5389 template <typename ArgT0, typename... ArgT>
5390 inline PROTOBUF_ALWAYS_INLINE
set_namespace_(ArgT0 && arg0,ArgT...args)5391 void ResultSpecProto_ResultGrouping_Entry::set_namespace_(ArgT0&& arg0, ArgT... args) {
5392 _impl_._has_bits_[0] |= 0x00000001u;
5393 _impl_.namespace__.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
5394 // @@protoc_insertion_point(field_set:icing.lib.ResultSpecProto.ResultGrouping.Entry.namespace)
5395 }
mutable_namespace_()5396 inline std::string* ResultSpecProto_ResultGrouping_Entry::mutable_namespace_() {
5397 std::string* _s = _internal_mutable_namespace_();
5398 // @@protoc_insertion_point(field_mutable:icing.lib.ResultSpecProto.ResultGrouping.Entry.namespace)
5399 return _s;
5400 }
_internal_namespace_()5401 inline const std::string& ResultSpecProto_ResultGrouping_Entry::_internal_namespace_() const {
5402 return _impl_.namespace__.Get();
5403 }
_internal_set_namespace_(const std::string & value)5404 inline void ResultSpecProto_ResultGrouping_Entry::_internal_set_namespace_(const std::string& value) {
5405 _impl_._has_bits_[0] |= 0x00000001u;
5406 _impl_.namespace__.Set(value, GetArenaForAllocation());
5407 }
_internal_mutable_namespace_()5408 inline std::string* ResultSpecProto_ResultGrouping_Entry::_internal_mutable_namespace_() {
5409 _impl_._has_bits_[0] |= 0x00000001u;
5410 return _impl_.namespace__.Mutable(GetArenaForAllocation());
5411 }
release_namespace_()5412 inline std::string* ResultSpecProto_ResultGrouping_Entry::release_namespace_() {
5413 // @@protoc_insertion_point(field_release:icing.lib.ResultSpecProto.ResultGrouping.Entry.namespace)
5414 if (!_internal_has_namespace_()) {
5415 return nullptr;
5416 }
5417 _impl_._has_bits_[0] &= ~0x00000001u;
5418 auto* p = _impl_.namespace__.Release();
5419 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
5420 if (_impl_.namespace__.IsDefault()) {
5421 _impl_.namespace__.Set("", GetArenaForAllocation());
5422 }
5423 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
5424 return p;
5425 }
set_allocated_namespace_(std::string * namespace_)5426 inline void ResultSpecProto_ResultGrouping_Entry::set_allocated_namespace_(std::string* namespace_) {
5427 if (namespace_ != nullptr) {
5428 _impl_._has_bits_[0] |= 0x00000001u;
5429 } else {
5430 _impl_._has_bits_[0] &= ~0x00000001u;
5431 }
5432 _impl_.namespace__.SetAllocated(namespace_, GetArenaForAllocation());
5433 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
5434 if (_impl_.namespace__.IsDefault()) {
5435 _impl_.namespace__.Set("", GetArenaForAllocation());
5436 }
5437 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
5438 // @@protoc_insertion_point(field_set_allocated:icing.lib.ResultSpecProto.ResultGrouping.Entry.namespace)
5439 }
5440
5441 // optional string schema = 2;
_internal_has_schema()5442 inline bool ResultSpecProto_ResultGrouping_Entry::_internal_has_schema() const {
5443 bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
5444 return value;
5445 }
has_schema()5446 inline bool ResultSpecProto_ResultGrouping_Entry::has_schema() const {
5447 return _internal_has_schema();
5448 }
clear_schema()5449 inline void ResultSpecProto_ResultGrouping_Entry::clear_schema() {
5450 _impl_.schema_.ClearToEmpty();
5451 _impl_._has_bits_[0] &= ~0x00000002u;
5452 }
schema()5453 inline const std::string& ResultSpecProto_ResultGrouping_Entry::schema() const {
5454 // @@protoc_insertion_point(field_get:icing.lib.ResultSpecProto.ResultGrouping.Entry.schema)
5455 return _internal_schema();
5456 }
5457 template <typename ArgT0, typename... ArgT>
5458 inline PROTOBUF_ALWAYS_INLINE
set_schema(ArgT0 && arg0,ArgT...args)5459 void ResultSpecProto_ResultGrouping_Entry::set_schema(ArgT0&& arg0, ArgT... args) {
5460 _impl_._has_bits_[0] |= 0x00000002u;
5461 _impl_.schema_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
5462 // @@protoc_insertion_point(field_set:icing.lib.ResultSpecProto.ResultGrouping.Entry.schema)
5463 }
mutable_schema()5464 inline std::string* ResultSpecProto_ResultGrouping_Entry::mutable_schema() {
5465 std::string* _s = _internal_mutable_schema();
5466 // @@protoc_insertion_point(field_mutable:icing.lib.ResultSpecProto.ResultGrouping.Entry.schema)
5467 return _s;
5468 }
_internal_schema()5469 inline const std::string& ResultSpecProto_ResultGrouping_Entry::_internal_schema() const {
5470 return _impl_.schema_.Get();
5471 }
_internal_set_schema(const std::string & value)5472 inline void ResultSpecProto_ResultGrouping_Entry::_internal_set_schema(const std::string& value) {
5473 _impl_._has_bits_[0] |= 0x00000002u;
5474 _impl_.schema_.Set(value, GetArenaForAllocation());
5475 }
_internal_mutable_schema()5476 inline std::string* ResultSpecProto_ResultGrouping_Entry::_internal_mutable_schema() {
5477 _impl_._has_bits_[0] |= 0x00000002u;
5478 return _impl_.schema_.Mutable(GetArenaForAllocation());
5479 }
release_schema()5480 inline std::string* ResultSpecProto_ResultGrouping_Entry::release_schema() {
5481 // @@protoc_insertion_point(field_release:icing.lib.ResultSpecProto.ResultGrouping.Entry.schema)
5482 if (!_internal_has_schema()) {
5483 return nullptr;
5484 }
5485 _impl_._has_bits_[0] &= ~0x00000002u;
5486 auto* p = _impl_.schema_.Release();
5487 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
5488 if (_impl_.schema_.IsDefault()) {
5489 _impl_.schema_.Set("", GetArenaForAllocation());
5490 }
5491 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
5492 return p;
5493 }
set_allocated_schema(std::string * schema)5494 inline void ResultSpecProto_ResultGrouping_Entry::set_allocated_schema(std::string* schema) {
5495 if (schema != nullptr) {
5496 _impl_._has_bits_[0] |= 0x00000002u;
5497 } else {
5498 _impl_._has_bits_[0] &= ~0x00000002u;
5499 }
5500 _impl_.schema_.SetAllocated(schema, GetArenaForAllocation());
5501 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
5502 if (_impl_.schema_.IsDefault()) {
5503 _impl_.schema_.Set("", GetArenaForAllocation());
5504 }
5505 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
5506 // @@protoc_insertion_point(field_set_allocated:icing.lib.ResultSpecProto.ResultGrouping.Entry.schema)
5507 }
5508
5509 // -------------------------------------------------------------------
5510
5511 // ResultSpecProto_ResultGrouping
5512
5513 // repeated .icing.lib.ResultSpecProto.ResultGrouping.Entry entry_groupings = 1;
_internal_entry_groupings_size()5514 inline int ResultSpecProto_ResultGrouping::_internal_entry_groupings_size() const {
5515 return _impl_.entry_groupings_.size();
5516 }
entry_groupings_size()5517 inline int ResultSpecProto_ResultGrouping::entry_groupings_size() const {
5518 return _internal_entry_groupings_size();
5519 }
clear_entry_groupings()5520 inline void ResultSpecProto_ResultGrouping::clear_entry_groupings() {
5521 _impl_.entry_groupings_.Clear();
5522 }
mutable_entry_groupings(int index)5523 inline ::icing::lib::ResultSpecProto_ResultGrouping_Entry* ResultSpecProto_ResultGrouping::mutable_entry_groupings(int index) {
5524 // @@protoc_insertion_point(field_mutable:icing.lib.ResultSpecProto.ResultGrouping.entry_groupings)
5525 return _impl_.entry_groupings_.Mutable(index);
5526 }
5527 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::ResultSpecProto_ResultGrouping_Entry >*
mutable_entry_groupings()5528 ResultSpecProto_ResultGrouping::mutable_entry_groupings() {
5529 // @@protoc_insertion_point(field_mutable_list:icing.lib.ResultSpecProto.ResultGrouping.entry_groupings)
5530 return &_impl_.entry_groupings_;
5531 }
_internal_entry_groupings(int index)5532 inline const ::icing::lib::ResultSpecProto_ResultGrouping_Entry& ResultSpecProto_ResultGrouping::_internal_entry_groupings(int index) const {
5533 return _impl_.entry_groupings_.Get(index);
5534 }
entry_groupings(int index)5535 inline const ::icing::lib::ResultSpecProto_ResultGrouping_Entry& ResultSpecProto_ResultGrouping::entry_groupings(int index) const {
5536 // @@protoc_insertion_point(field_get:icing.lib.ResultSpecProto.ResultGrouping.entry_groupings)
5537 return _internal_entry_groupings(index);
5538 }
_internal_add_entry_groupings()5539 inline ::icing::lib::ResultSpecProto_ResultGrouping_Entry* ResultSpecProto_ResultGrouping::_internal_add_entry_groupings() {
5540 return _impl_.entry_groupings_.Add();
5541 }
add_entry_groupings()5542 inline ::icing::lib::ResultSpecProto_ResultGrouping_Entry* ResultSpecProto_ResultGrouping::add_entry_groupings() {
5543 ::icing::lib::ResultSpecProto_ResultGrouping_Entry* _add = _internal_add_entry_groupings();
5544 // @@protoc_insertion_point(field_add:icing.lib.ResultSpecProto.ResultGrouping.entry_groupings)
5545 return _add;
5546 }
5547 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::ResultSpecProto_ResultGrouping_Entry >&
entry_groupings()5548 ResultSpecProto_ResultGrouping::entry_groupings() const {
5549 // @@protoc_insertion_point(field_list:icing.lib.ResultSpecProto.ResultGrouping.entry_groupings)
5550 return _impl_.entry_groupings_;
5551 }
5552
5553 // optional int32 max_results = 2;
_internal_has_max_results()5554 inline bool ResultSpecProto_ResultGrouping::_internal_has_max_results() const {
5555 bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
5556 return value;
5557 }
has_max_results()5558 inline bool ResultSpecProto_ResultGrouping::has_max_results() const {
5559 return _internal_has_max_results();
5560 }
clear_max_results()5561 inline void ResultSpecProto_ResultGrouping::clear_max_results() {
5562 _impl_.max_results_ = 0;
5563 _impl_._has_bits_[0] &= ~0x00000001u;
5564 }
_internal_max_results()5565 inline ::int32_t ResultSpecProto_ResultGrouping::_internal_max_results() const {
5566 return _impl_.max_results_;
5567 }
max_results()5568 inline ::int32_t ResultSpecProto_ResultGrouping::max_results() const {
5569 // @@protoc_insertion_point(field_get:icing.lib.ResultSpecProto.ResultGrouping.max_results)
5570 return _internal_max_results();
5571 }
_internal_set_max_results(::int32_t value)5572 inline void ResultSpecProto_ResultGrouping::_internal_set_max_results(::int32_t value) {
5573 _impl_._has_bits_[0] |= 0x00000001u;
5574 _impl_.max_results_ = value;
5575 }
set_max_results(::int32_t value)5576 inline void ResultSpecProto_ResultGrouping::set_max_results(::int32_t value) {
5577 _internal_set_max_results(value);
5578 // @@protoc_insertion_point(field_set:icing.lib.ResultSpecProto.ResultGrouping.max_results)
5579 }
5580
5581 // -------------------------------------------------------------------
5582
5583 // ResultSpecProto
5584
5585 // optional int32 num_per_page = 1 [default = 10];
_internal_has_num_per_page()5586 inline bool ResultSpecProto::_internal_has_num_per_page() const {
5587 bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
5588 return value;
5589 }
has_num_per_page()5590 inline bool ResultSpecProto::has_num_per_page() const {
5591 return _internal_has_num_per_page();
5592 }
clear_num_per_page()5593 inline void ResultSpecProto::clear_num_per_page() {
5594 _impl_.num_per_page_ = 10;
5595 _impl_._has_bits_[0] &= ~0x00000020u;
5596 }
_internal_num_per_page()5597 inline ::int32_t ResultSpecProto::_internal_num_per_page() const {
5598 return _impl_.num_per_page_;
5599 }
num_per_page()5600 inline ::int32_t ResultSpecProto::num_per_page() const {
5601 // @@protoc_insertion_point(field_get:icing.lib.ResultSpecProto.num_per_page)
5602 return _internal_num_per_page();
5603 }
_internal_set_num_per_page(::int32_t value)5604 inline void ResultSpecProto::_internal_set_num_per_page(::int32_t value) {
5605 _impl_._has_bits_[0] |= 0x00000020u;
5606 _impl_.num_per_page_ = value;
5607 }
set_num_per_page(::int32_t value)5608 inline void ResultSpecProto::set_num_per_page(::int32_t value) {
5609 _internal_set_num_per_page(value);
5610 // @@protoc_insertion_point(field_set:icing.lib.ResultSpecProto.num_per_page)
5611 }
5612
5613 // optional bool debug_info = 2;
_internal_has_debug_info()5614 inline bool ResultSpecProto::_internal_has_debug_info() const {
5615 bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
5616 return value;
5617 }
has_debug_info()5618 inline bool ResultSpecProto::has_debug_info() const {
5619 return _internal_has_debug_info();
5620 }
clear_debug_info()5621 inline void ResultSpecProto::clear_debug_info() {
5622 _impl_.debug_info_ = false;
5623 _impl_._has_bits_[0] &= ~0x00000002u;
5624 }
_internal_debug_info()5625 inline bool ResultSpecProto::_internal_debug_info() const {
5626 return _impl_.debug_info_;
5627 }
debug_info()5628 inline bool ResultSpecProto::debug_info() const {
5629 // @@protoc_insertion_point(field_get:icing.lib.ResultSpecProto.debug_info)
5630 return _internal_debug_info();
5631 }
_internal_set_debug_info(bool value)5632 inline void ResultSpecProto::_internal_set_debug_info(bool value) {
5633 _impl_._has_bits_[0] |= 0x00000002u;
5634 _impl_.debug_info_ = value;
5635 }
set_debug_info(bool value)5636 inline void ResultSpecProto::set_debug_info(bool value) {
5637 _internal_set_debug_info(value);
5638 // @@protoc_insertion_point(field_set:icing.lib.ResultSpecProto.debug_info)
5639 }
5640
5641 // optional .icing.lib.ResultSpecProto.SnippetSpecProto snippet_spec = 3;
_internal_has_snippet_spec()5642 inline bool ResultSpecProto::_internal_has_snippet_spec() const {
5643 bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
5644 PROTOBUF_ASSUME(!value || _impl_.snippet_spec_ != nullptr);
5645 return value;
5646 }
has_snippet_spec()5647