1 // Generated by the protocol buffer compiler. DO NOT EDIT!
2 // source: icing/proto/document.proto
3
4 #ifndef GOOGLE_PROTOBUF_INCLUDED_icing_2fproto_2fdocument_2eproto
5 #define GOOGLE_PROTOBUF_INCLUDED_icing_2fproto_2fdocument_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 "icing/proto/logging.pb.h"
33 #include "icing/proto/status.pb.h"
34 // @@protoc_insertion_point(includes)
35 #include <google/protobuf/port_def.inc>
36 #define PROTOBUF_INTERNAL_EXPORT_icing_2fproto_2fdocument_2eproto
37 PROTOBUF_NAMESPACE_OPEN
38 namespace internal {
39 class AnyMetadata;
40 } // namespace internal
41 PROTOBUF_NAMESPACE_CLOSE
42
43 // Internal implementation detail -- do not use these members.
44 struct TableStruct_icing_2fproto_2fdocument_2eproto {
45 static const ::uint32_t offsets[];
46 };
47 namespace icing {
48 namespace lib {
49 class DeleteByNamespaceResultProto;
50 struct DeleteByNamespaceResultProtoDefaultTypeInternal;
51 extern DeleteByNamespaceResultProtoDefaultTypeInternal _DeleteByNamespaceResultProto_default_instance_;
52 class DeleteByQueryResultProto;
53 struct DeleteByQueryResultProtoDefaultTypeInternal;
54 extern DeleteByQueryResultProtoDefaultTypeInternal _DeleteByQueryResultProto_default_instance_;
55 class DeleteByQueryResultProto_DocumentGroupInfo;
56 struct DeleteByQueryResultProto_DocumentGroupInfoDefaultTypeInternal;
57 extern DeleteByQueryResultProto_DocumentGroupInfoDefaultTypeInternal _DeleteByQueryResultProto_DocumentGroupInfo_default_instance_;
58 class DeleteBySchemaTypeResultProto;
59 struct DeleteBySchemaTypeResultProtoDefaultTypeInternal;
60 extern DeleteBySchemaTypeResultProtoDefaultTypeInternal _DeleteBySchemaTypeResultProto_default_instance_;
61 class DeleteResultProto;
62 struct DeleteResultProtoDefaultTypeInternal;
63 extern DeleteResultProtoDefaultTypeInternal _DeleteResultProto_default_instance_;
64 class DocumentProto;
65 struct DocumentProtoDefaultTypeInternal;
66 extern DocumentProtoDefaultTypeInternal _DocumentProto_default_instance_;
67 class DocumentProto_InternalFields;
68 struct DocumentProto_InternalFieldsDefaultTypeInternal;
69 extern DocumentProto_InternalFieldsDefaultTypeInternal _DocumentProto_InternalFields_default_instance_;
70 class GetAllNamespacesResultProto;
71 struct GetAllNamespacesResultProtoDefaultTypeInternal;
72 extern GetAllNamespacesResultProtoDefaultTypeInternal _GetAllNamespacesResultProto_default_instance_;
73 class GetResultProto;
74 struct GetResultProtoDefaultTypeInternal;
75 extern GetResultProtoDefaultTypeInternal _GetResultProto_default_instance_;
76 class PropertyProto;
77 struct PropertyProtoDefaultTypeInternal;
78 extern PropertyProtoDefaultTypeInternal _PropertyProto_default_instance_;
79 class PropertyProto_BlobHandleProto;
80 struct PropertyProto_BlobHandleProtoDefaultTypeInternal;
81 extern PropertyProto_BlobHandleProtoDefaultTypeInternal _PropertyProto_BlobHandleProto_default_instance_;
82 class PropertyProto_VectorProto;
83 struct PropertyProto_VectorProtoDefaultTypeInternal;
84 extern PropertyProto_VectorProtoDefaultTypeInternal _PropertyProto_VectorProto_default_instance_;
85 class PutResultProto;
86 struct PutResultProtoDefaultTypeInternal;
87 extern PutResultProtoDefaultTypeInternal _PutResultProto_default_instance_;
88 } // namespace lib
89 } // namespace icing
90 PROTOBUF_NAMESPACE_OPEN
91 template<> ::icing::lib::DeleteByNamespaceResultProto* Arena::CreateMaybeMessage<::icing::lib::DeleteByNamespaceResultProto>(Arena*);
92 template<> ::icing::lib::DeleteByQueryResultProto* Arena::CreateMaybeMessage<::icing::lib::DeleteByQueryResultProto>(Arena*);
93 template<> ::icing::lib::DeleteByQueryResultProto_DocumentGroupInfo* Arena::CreateMaybeMessage<::icing::lib::DeleteByQueryResultProto_DocumentGroupInfo>(Arena*);
94 template<> ::icing::lib::DeleteBySchemaTypeResultProto* Arena::CreateMaybeMessage<::icing::lib::DeleteBySchemaTypeResultProto>(Arena*);
95 template<> ::icing::lib::DeleteResultProto* Arena::CreateMaybeMessage<::icing::lib::DeleteResultProto>(Arena*);
96 template<> ::icing::lib::DocumentProto* Arena::CreateMaybeMessage<::icing::lib::DocumentProto>(Arena*);
97 template<> ::icing::lib::DocumentProto_InternalFields* Arena::CreateMaybeMessage<::icing::lib::DocumentProto_InternalFields>(Arena*);
98 template<> ::icing::lib::GetAllNamespacesResultProto* Arena::CreateMaybeMessage<::icing::lib::GetAllNamespacesResultProto>(Arena*);
99 template<> ::icing::lib::GetResultProto* Arena::CreateMaybeMessage<::icing::lib::GetResultProto>(Arena*);
100 template<> ::icing::lib::PropertyProto* Arena::CreateMaybeMessage<::icing::lib::PropertyProto>(Arena*);
101 template<> ::icing::lib::PropertyProto_BlobHandleProto* Arena::CreateMaybeMessage<::icing::lib::PropertyProto_BlobHandleProto>(Arena*);
102 template<> ::icing::lib::PropertyProto_VectorProto* Arena::CreateMaybeMessage<::icing::lib::PropertyProto_VectorProto>(Arena*);
103 template<> ::icing::lib::PutResultProto* Arena::CreateMaybeMessage<::icing::lib::PutResultProto>(Arena*);
104 PROTOBUF_NAMESPACE_CLOSE
105 namespace icing {
106 namespace lib {
107
108 // ===================================================================
109
110 class DocumentProto_InternalFields final :
111 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:icing.lib.DocumentProto.InternalFields) */ {
112 public:
DocumentProto_InternalFields()113 inline DocumentProto_InternalFields() : DocumentProto_InternalFields(nullptr) {}
114 ~DocumentProto_InternalFields() override;
115 explicit PROTOBUF_CONSTEXPR DocumentProto_InternalFields(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
116
117 DocumentProto_InternalFields(const DocumentProto_InternalFields& from);
DocumentProto_InternalFields(DocumentProto_InternalFields && from)118 DocumentProto_InternalFields(DocumentProto_InternalFields&& from) noexcept
119 : DocumentProto_InternalFields() {
120 *this = ::std::move(from);
121 }
122
123 inline DocumentProto_InternalFields& operator=(const DocumentProto_InternalFields& from) {
124 if (this == &from) return *this;
125 CopyFrom(from);
126 return *this;
127 }
128 inline DocumentProto_InternalFields& operator=(DocumentProto_InternalFields&& from) noexcept {
129 if (this == &from) return *this;
130 if (GetOwningArena() == from.GetOwningArena()
131 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
132 && GetOwningArena() != nullptr
133 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
134 ) {
135 InternalSwap(&from);
136 } else {
137 CopyFrom(from);
138 }
139 return *this;
140 }
141
unknown_fields()142 inline const std::string& unknown_fields() const {
143 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
144 }
mutable_unknown_fields()145 inline std::string* mutable_unknown_fields() {
146 return _internal_metadata_.mutable_unknown_fields<std::string>();
147 }
148
default_instance()149 static const DocumentProto_InternalFields& default_instance() {
150 return *internal_default_instance();
151 }
internal_default_instance()152 static inline const DocumentProto_InternalFields* internal_default_instance() {
153 return reinterpret_cast<const DocumentProto_InternalFields*>(
154 &_DocumentProto_InternalFields_default_instance_);
155 }
156 static constexpr int kIndexInFileMessages =
157 0;
158
swap(DocumentProto_InternalFields & a,DocumentProto_InternalFields & b)159 friend void swap(DocumentProto_InternalFields& a, DocumentProto_InternalFields& b) {
160 a.Swap(&b);
161 }
Swap(DocumentProto_InternalFields * other)162 inline void Swap(DocumentProto_InternalFields* other) {
163 if (other == this) return;
164 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
165 if (GetOwningArena() != nullptr &&
166 GetOwningArena() == other->GetOwningArena()) {
167 #else // PROTOBUF_FORCE_COPY_IN_SWAP
168 if (GetOwningArena() == other->GetOwningArena()) {
169 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
170 InternalSwap(other);
171 } else {
172 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
173 }
174 }
175 void UnsafeArenaSwap(DocumentProto_InternalFields* other) {
176 if (other == this) return;
177 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
178 InternalSwap(other);
179 }
180
181 // implements Message ----------------------------------------------
182
183 DocumentProto_InternalFields* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
184 return CreateMaybeMessage<DocumentProto_InternalFields>(arena);
185 }
186 DocumentProto_InternalFields* New() const {
187 return New(nullptr);
188 }
189 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
190 void CopyFrom(const DocumentProto_InternalFields& from);
191 void MergeFrom(const DocumentProto_InternalFields& from);
192 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
193 bool IsInitialized() const final;
194
195 size_t ByteSizeLong() const final;
196 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
197 ::uint8_t* _InternalSerialize(
198 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
199 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
200
201 private:
202 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
203 void SharedDtor();
204 void SetCachedSize(int size) const;
205 void InternalSwap(DocumentProto_InternalFields* other);
206
207 private:
208 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
209 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
210 return "icing.lib.DocumentProto.InternalFields";
211 }
212 protected:
213 explicit DocumentProto_InternalFields(::PROTOBUF_NAMESPACE_ID::Arena* arena,
214 bool is_message_owned = false);
215 public:
216
217 std::string GetTypeName() const final;
218
219 // nested types ----------------------------------------------------
220
221 // accessors -------------------------------------------------------
222
223 enum : int {
224 kLengthInTokensFieldNumber = 1,
225 };
226 // optional int32 length_in_tokens = 1;
227 bool has_length_in_tokens() const;
228 private:
229 bool _internal_has_length_in_tokens() const;
230 public:
231 void clear_length_in_tokens();
232 ::int32_t length_in_tokens() const;
233 void set_length_in_tokens(::int32_t value);
234 private:
235 ::int32_t _internal_length_in_tokens() const;
236 void _internal_set_length_in_tokens(::int32_t value);
237 public:
238
239 // @@protoc_insertion_point(class_scope:icing.lib.DocumentProto.InternalFields)
240 private:
241 class _Internal;
242
243 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
244 typedef void InternalArenaConstructable_;
245 typedef void DestructorSkippable_;
246 struct Impl_ {
247 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
248 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
249 ::int32_t length_in_tokens_;
250 };
251 union { Impl_ _impl_; };
252 friend struct ::TableStruct_icing_2fproto_2fdocument_2eproto;
253 };
254 // -------------------------------------------------------------------
255
256 class DocumentProto final :
257 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:icing.lib.DocumentProto) */ {
258 public:
DocumentProto()259 inline DocumentProto() : DocumentProto(nullptr) {}
260 ~DocumentProto() override;
261 explicit PROTOBUF_CONSTEXPR DocumentProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
262
263 DocumentProto(const DocumentProto& from);
DocumentProto(DocumentProto && from)264 DocumentProto(DocumentProto&& from) noexcept
265 : DocumentProto() {
266 *this = ::std::move(from);
267 }
268
269 inline DocumentProto& operator=(const DocumentProto& from) {
270 if (this == &from) return *this;
271 CopyFrom(from);
272 return *this;
273 }
274 inline DocumentProto& operator=(DocumentProto&& from) noexcept {
275 if (this == &from) return *this;
276 if (GetOwningArena() == from.GetOwningArena()
277 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
278 && GetOwningArena() != nullptr
279 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
280 ) {
281 InternalSwap(&from);
282 } else {
283 CopyFrom(from);
284 }
285 return *this;
286 }
287
unknown_fields()288 inline const std::string& unknown_fields() const {
289 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
290 }
mutable_unknown_fields()291 inline std::string* mutable_unknown_fields() {
292 return _internal_metadata_.mutable_unknown_fields<std::string>();
293 }
294
default_instance()295 static const DocumentProto& default_instance() {
296 return *internal_default_instance();
297 }
internal_default_instance()298 static inline const DocumentProto* internal_default_instance() {
299 return reinterpret_cast<const DocumentProto*>(
300 &_DocumentProto_default_instance_);
301 }
302 static constexpr int kIndexInFileMessages =
303 1;
304
swap(DocumentProto & a,DocumentProto & b)305 friend void swap(DocumentProto& a, DocumentProto& b) {
306 a.Swap(&b);
307 }
Swap(DocumentProto * other)308 inline void Swap(DocumentProto* other) {
309 if (other == this) return;
310 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
311 if (GetOwningArena() != nullptr &&
312 GetOwningArena() == other->GetOwningArena()) {
313 #else // PROTOBUF_FORCE_COPY_IN_SWAP
314 if (GetOwningArena() == other->GetOwningArena()) {
315 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
316 InternalSwap(other);
317 } else {
318 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
319 }
320 }
321 void UnsafeArenaSwap(DocumentProto* other) {
322 if (other == this) return;
323 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
324 InternalSwap(other);
325 }
326
327 // implements Message ----------------------------------------------
328
329 DocumentProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
330 return CreateMaybeMessage<DocumentProto>(arena);
331 }
332 DocumentProto* New() const {
333 return New(nullptr);
334 }
335 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
336 void CopyFrom(const DocumentProto& from);
337 void MergeFrom(const DocumentProto& from);
338 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
339 bool IsInitialized() const final;
340
341 size_t ByteSizeLong() const final;
342 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
343 ::uint8_t* _InternalSerialize(
344 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
345 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
346
347 private:
348 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
349 void SharedDtor();
350 void SetCachedSize(int size) const;
351 void InternalSwap(DocumentProto* other);
352
353 private:
354 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
355 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
356 return "icing.lib.DocumentProto";
357 }
358 protected:
359 explicit DocumentProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
360 bool is_message_owned = false);
361 public:
362
363 std::string GetTypeName() const final;
364
365 // nested types ----------------------------------------------------
366
367 typedef DocumentProto_InternalFields InternalFields;
368
369 // accessors -------------------------------------------------------
370
371 enum : int {
372 kPropertiesFieldNumber = 5,
373 kNamespaceFieldNumber = 1,
374 kUriFieldNumber = 2,
375 kSchemaFieldNumber = 3,
376 kInternalFieldsFieldNumber = 9,
377 kCreationTimestampMsFieldNumber = 4,
378 kTtlMsFieldNumber = 8,
379 kScoreFieldNumber = 7,
380 };
381 // repeated .icing.lib.PropertyProto properties = 5;
382 int properties_size() const;
383 private:
384 int _internal_properties_size() const;
385 public:
386 void clear_properties();
387 ::icing::lib::PropertyProto* mutable_properties(int index);
388 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::PropertyProto >*
389 mutable_properties();
390 private:
391 const ::icing::lib::PropertyProto& _internal_properties(int index) const;
392 ::icing::lib::PropertyProto* _internal_add_properties();
393 public:
394 const ::icing::lib::PropertyProto& properties(int index) const;
395 ::icing::lib::PropertyProto* add_properties();
396 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::PropertyProto >&
397 properties() const;
398
399 // optional string namespace = 1;
400 bool has_namespace_() const;
401 private:
402 bool _internal_has_namespace_() const;
403 public:
404 void clear_namespace_();
405 const std::string& namespace_() const;
406 template <typename ArgT0 = const std::string&, typename... ArgT>
407 void set_namespace_(ArgT0&& arg0, ArgT... args);
408 std::string* mutable_namespace_();
409 PROTOBUF_NODISCARD std::string* release_namespace_();
410 void set_allocated_namespace_(std::string* namespace_);
411 private:
412 const std::string& _internal_namespace_() const;
413 inline PROTOBUF_ALWAYS_INLINE void _internal_set_namespace_(const std::string& value);
414 std::string* _internal_mutable_namespace_();
415 public:
416
417 // optional string uri = 2;
418 bool has_uri() const;
419 private:
420 bool _internal_has_uri() const;
421 public:
422 void clear_uri();
423 const std::string& uri() const;
424 template <typename ArgT0 = const std::string&, typename... ArgT>
425 void set_uri(ArgT0&& arg0, ArgT... args);
426 std::string* mutable_uri();
427 PROTOBUF_NODISCARD std::string* release_uri();
428 void set_allocated_uri(std::string* uri);
429 private:
430 const std::string& _internal_uri() const;
431 inline PROTOBUF_ALWAYS_INLINE void _internal_set_uri(const std::string& value);
432 std::string* _internal_mutable_uri();
433 public:
434
435 // optional string schema = 3;
436 bool has_schema() const;
437 private:
438 bool _internal_has_schema() const;
439 public:
440 void clear_schema();
441 const std::string& schema() const;
442 template <typename ArgT0 = const std::string&, typename... ArgT>
443 void set_schema(ArgT0&& arg0, ArgT... args);
444 std::string* mutable_schema();
445 PROTOBUF_NODISCARD std::string* release_schema();
446 void set_allocated_schema(std::string* schema);
447 private:
448 const std::string& _internal_schema() const;
449 inline PROTOBUF_ALWAYS_INLINE void _internal_set_schema(const std::string& value);
450 std::string* _internal_mutable_schema();
451 public:
452
453 // optional .icing.lib.DocumentProto.InternalFields internal_fields = 9;
454 bool has_internal_fields() const;
455 private:
456 bool _internal_has_internal_fields() const;
457 public:
458 void clear_internal_fields();
459 const ::icing::lib::DocumentProto_InternalFields& internal_fields() const;
460 PROTOBUF_NODISCARD ::icing::lib::DocumentProto_InternalFields* release_internal_fields();
461 ::icing::lib::DocumentProto_InternalFields* mutable_internal_fields();
462 void set_allocated_internal_fields(::icing::lib::DocumentProto_InternalFields* internal_fields);
463 private:
464 const ::icing::lib::DocumentProto_InternalFields& _internal_internal_fields() const;
465 ::icing::lib::DocumentProto_InternalFields* _internal_mutable_internal_fields();
466 public:
467 void unsafe_arena_set_allocated_internal_fields(
468 ::icing::lib::DocumentProto_InternalFields* internal_fields);
469 ::icing::lib::DocumentProto_InternalFields* unsafe_arena_release_internal_fields();
470
471 // optional int64 creation_timestamp_ms = 4;
472 bool has_creation_timestamp_ms() const;
473 private:
474 bool _internal_has_creation_timestamp_ms() const;
475 public:
476 void clear_creation_timestamp_ms();
477 ::int64_t creation_timestamp_ms() const;
478 void set_creation_timestamp_ms(::int64_t value);
479 private:
480 ::int64_t _internal_creation_timestamp_ms() const;
481 void _internal_set_creation_timestamp_ms(::int64_t value);
482 public:
483
484 // optional int64 ttl_ms = 8 [default = 0];
485 bool has_ttl_ms() const;
486 private:
487 bool _internal_has_ttl_ms() const;
488 public:
489 void clear_ttl_ms();
490 ::int64_t ttl_ms() const;
491 void set_ttl_ms(::int64_t value);
492 private:
493 ::int64_t _internal_ttl_ms() const;
494 void _internal_set_ttl_ms(::int64_t value);
495 public:
496
497 // optional int32 score = 7 [default = 0];
498 bool has_score() const;
499 private:
500 bool _internal_has_score() const;
501 public:
502 void clear_score();
503 ::int32_t score() const;
504 void set_score(::int32_t value);
505 private:
506 ::int32_t _internal_score() const;
507 void _internal_set_score(::int32_t value);
508 public:
509
510 // @@protoc_insertion_point(class_scope:icing.lib.DocumentProto)
511 private:
512 class _Internal;
513
514 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
515 typedef void InternalArenaConstructable_;
516 typedef void DestructorSkippable_;
517 struct Impl_ {
518 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
519 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
520 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::PropertyProto > properties_;
521 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr namespace__;
522 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr uri_;
523 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr schema_;
524 ::icing::lib::DocumentProto_InternalFields* internal_fields_;
525 ::int64_t creation_timestamp_ms_;
526 ::int64_t ttl_ms_;
527 ::int32_t score_;
528 };
529 union { Impl_ _impl_; };
530 friend struct ::TableStruct_icing_2fproto_2fdocument_2eproto;
531 };
532 // -------------------------------------------------------------------
533
534 class PropertyProto_VectorProto final :
535 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:icing.lib.PropertyProto.VectorProto) */ {
536 public:
PropertyProto_VectorProto()537 inline PropertyProto_VectorProto() : PropertyProto_VectorProto(nullptr) {}
538 ~PropertyProto_VectorProto() override;
539 explicit PROTOBUF_CONSTEXPR PropertyProto_VectorProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
540
541 PropertyProto_VectorProto(const PropertyProto_VectorProto& from);
PropertyProto_VectorProto(PropertyProto_VectorProto && from)542 PropertyProto_VectorProto(PropertyProto_VectorProto&& from) noexcept
543 : PropertyProto_VectorProto() {
544 *this = ::std::move(from);
545 }
546
547 inline PropertyProto_VectorProto& operator=(const PropertyProto_VectorProto& from) {
548 if (this == &from) return *this;
549 CopyFrom(from);
550 return *this;
551 }
552 inline PropertyProto_VectorProto& operator=(PropertyProto_VectorProto&& from) noexcept {
553 if (this == &from) return *this;
554 if (GetOwningArena() == from.GetOwningArena()
555 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
556 && GetOwningArena() != nullptr
557 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
558 ) {
559 InternalSwap(&from);
560 } else {
561 CopyFrom(from);
562 }
563 return *this;
564 }
565
unknown_fields()566 inline const std::string& unknown_fields() const {
567 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
568 }
mutable_unknown_fields()569 inline std::string* mutable_unknown_fields() {
570 return _internal_metadata_.mutable_unknown_fields<std::string>();
571 }
572
default_instance()573 static const PropertyProto_VectorProto& default_instance() {
574 return *internal_default_instance();
575 }
internal_default_instance()576 static inline const PropertyProto_VectorProto* internal_default_instance() {
577 return reinterpret_cast<const PropertyProto_VectorProto*>(
578 &_PropertyProto_VectorProto_default_instance_);
579 }
580 static constexpr int kIndexInFileMessages =
581 2;
582
swap(PropertyProto_VectorProto & a,PropertyProto_VectorProto & b)583 friend void swap(PropertyProto_VectorProto& a, PropertyProto_VectorProto& b) {
584 a.Swap(&b);
585 }
Swap(PropertyProto_VectorProto * other)586 inline void Swap(PropertyProto_VectorProto* other) {
587 if (other == this) return;
588 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
589 if (GetOwningArena() != nullptr &&
590 GetOwningArena() == other->GetOwningArena()) {
591 #else // PROTOBUF_FORCE_COPY_IN_SWAP
592 if (GetOwningArena() == other->GetOwningArena()) {
593 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
594 InternalSwap(other);
595 } else {
596 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
597 }
598 }
599 void UnsafeArenaSwap(PropertyProto_VectorProto* other) {
600 if (other == this) return;
601 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
602 InternalSwap(other);
603 }
604
605 // implements Message ----------------------------------------------
606
607 PropertyProto_VectorProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
608 return CreateMaybeMessage<PropertyProto_VectorProto>(arena);
609 }
610 PropertyProto_VectorProto* New() const {
611 return New(nullptr);
612 }
613 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
614 void CopyFrom(const PropertyProto_VectorProto& from);
615 void MergeFrom(const PropertyProto_VectorProto& from);
616 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
617 bool IsInitialized() const final;
618
619 size_t ByteSizeLong() const final;
620 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
621 ::uint8_t* _InternalSerialize(
622 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
623 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
624
625 private:
626 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
627 void SharedDtor();
628 void SetCachedSize(int size) const;
629 void InternalSwap(PropertyProto_VectorProto* other);
630
631 private:
632 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
633 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
634 return "icing.lib.PropertyProto.VectorProto";
635 }
636 protected:
637 explicit PropertyProto_VectorProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
638 bool is_message_owned = false);
639 public:
640
641 std::string GetTypeName() const final;
642
643 // nested types ----------------------------------------------------
644
645 // accessors -------------------------------------------------------
646
647 enum : int {
648 kValuesFieldNumber = 1,
649 kModelSignatureFieldNumber = 2,
650 };
651 // repeated float values = 1 [packed = true];
652 int values_size() const;
653 private:
654 int _internal_values_size() const;
655 public:
656 void clear_values();
657 private:
658 float _internal_values(int index) const;
659 const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
660 _internal_values() const;
661 void _internal_add_values(float value);
662 ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
663 _internal_mutable_values();
664 public:
665 float values(int index) const;
666 void set_values(int index, float value);
667 void add_values(float value);
668 const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
669 values() const;
670 ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
671 mutable_values();
672
673 // optional string model_signature = 2;
674 bool has_model_signature() const;
675 private:
676 bool _internal_has_model_signature() const;
677 public:
678 void clear_model_signature();
679 const std::string& model_signature() const;
680 template <typename ArgT0 = const std::string&, typename... ArgT>
681 void set_model_signature(ArgT0&& arg0, ArgT... args);
682 std::string* mutable_model_signature();
683 PROTOBUF_NODISCARD std::string* release_model_signature();
684 void set_allocated_model_signature(std::string* model_signature);
685 private:
686 const std::string& _internal_model_signature() const;
687 inline PROTOBUF_ALWAYS_INLINE void _internal_set_model_signature(const std::string& value);
688 std::string* _internal_mutable_model_signature();
689 public:
690
691 // @@protoc_insertion_point(class_scope:icing.lib.PropertyProto.VectorProto)
692 private:
693 class _Internal;
694
695 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
696 typedef void InternalArenaConstructable_;
697 typedef void DestructorSkippable_;
698 struct Impl_ {
699 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
700 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
701 ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > values_;
702 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr model_signature_;
703 };
704 union { Impl_ _impl_; };
705 friend struct ::TableStruct_icing_2fproto_2fdocument_2eproto;
706 };
707 // -------------------------------------------------------------------
708
709 class PropertyProto_BlobHandleProto final :
710 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:icing.lib.PropertyProto.BlobHandleProto) */ {
711 public:
PropertyProto_BlobHandleProto()712 inline PropertyProto_BlobHandleProto() : PropertyProto_BlobHandleProto(nullptr) {}
713 ~PropertyProto_BlobHandleProto() override;
714 explicit PROTOBUF_CONSTEXPR PropertyProto_BlobHandleProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
715
716 PropertyProto_BlobHandleProto(const PropertyProto_BlobHandleProto& from);
PropertyProto_BlobHandleProto(PropertyProto_BlobHandleProto && from)717 PropertyProto_BlobHandleProto(PropertyProto_BlobHandleProto&& from) noexcept
718 : PropertyProto_BlobHandleProto() {
719 *this = ::std::move(from);
720 }
721
722 inline PropertyProto_BlobHandleProto& operator=(const PropertyProto_BlobHandleProto& from) {
723 if (this == &from) return *this;
724 CopyFrom(from);
725 return *this;
726 }
727 inline PropertyProto_BlobHandleProto& operator=(PropertyProto_BlobHandleProto&& from) noexcept {
728 if (this == &from) return *this;
729 if (GetOwningArena() == from.GetOwningArena()
730 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
731 && GetOwningArena() != nullptr
732 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
733 ) {
734 InternalSwap(&from);
735 } else {
736 CopyFrom(from);
737 }
738 return *this;
739 }
740
unknown_fields()741 inline const std::string& unknown_fields() const {
742 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
743 }
mutable_unknown_fields()744 inline std::string* mutable_unknown_fields() {
745 return _internal_metadata_.mutable_unknown_fields<std::string>();
746 }
747
default_instance()748 static const PropertyProto_BlobHandleProto& default_instance() {
749 return *internal_default_instance();
750 }
internal_default_instance()751 static inline const PropertyProto_BlobHandleProto* internal_default_instance() {
752 return reinterpret_cast<const PropertyProto_BlobHandleProto*>(
753 &_PropertyProto_BlobHandleProto_default_instance_);
754 }
755 static constexpr int kIndexInFileMessages =
756 3;
757
swap(PropertyProto_BlobHandleProto & a,PropertyProto_BlobHandleProto & b)758 friend void swap(PropertyProto_BlobHandleProto& a, PropertyProto_BlobHandleProto& b) {
759 a.Swap(&b);
760 }
Swap(PropertyProto_BlobHandleProto * other)761 inline void Swap(PropertyProto_BlobHandleProto* other) {
762 if (other == this) return;
763 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
764 if (GetOwningArena() != nullptr &&
765 GetOwningArena() == other->GetOwningArena()) {
766 #else // PROTOBUF_FORCE_COPY_IN_SWAP
767 if (GetOwningArena() == other->GetOwningArena()) {
768 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
769 InternalSwap(other);
770 } else {
771 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
772 }
773 }
774 void UnsafeArenaSwap(PropertyProto_BlobHandleProto* other) {
775 if (other == this) return;
776 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
777 InternalSwap(other);
778 }
779
780 // implements Message ----------------------------------------------
781
782 PropertyProto_BlobHandleProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
783 return CreateMaybeMessage<PropertyProto_BlobHandleProto>(arena);
784 }
785 PropertyProto_BlobHandleProto* New() const {
786 return New(nullptr);
787 }
788 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
789 void CopyFrom(const PropertyProto_BlobHandleProto& from);
790 void MergeFrom(const PropertyProto_BlobHandleProto& from);
791 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
792 bool IsInitialized() const final;
793
794 size_t ByteSizeLong() const final;
795 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
796 ::uint8_t* _InternalSerialize(
797 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
798 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
799
800 private:
801 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
802 void SharedDtor();
803 void SetCachedSize(int size) const;
804 void InternalSwap(PropertyProto_BlobHandleProto* other);
805
806 private:
807 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
808 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
809 return "icing.lib.PropertyProto.BlobHandleProto";
810 }
811 protected:
812 explicit PropertyProto_BlobHandleProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
813 bool is_message_owned = false);
814 public:
815
816 std::string GetTypeName() const final;
817
818 // nested types ----------------------------------------------------
819
820 // accessors -------------------------------------------------------
821
822 enum : int {
823 kDigestFieldNumber = 1,
824 kNamespaceFieldNumber = 3,
825 };
826 // optional bytes digest = 1;
827 bool has_digest() const;
828 private:
829 bool _internal_has_digest() const;
830 public:
831 void clear_digest();
832 const std::string& digest() const;
833 template <typename ArgT0 = const std::string&, typename... ArgT>
834 void set_digest(ArgT0&& arg0, ArgT... args);
835 std::string* mutable_digest();
836 PROTOBUF_NODISCARD std::string* release_digest();
837 void set_allocated_digest(std::string* digest);
838 private:
839 const std::string& _internal_digest() const;
840 inline PROTOBUF_ALWAYS_INLINE void _internal_set_digest(const std::string& value);
841 std::string* _internal_mutable_digest();
842 public:
843
844 // optional string namespace = 3;
845 bool has_namespace_() const;
846 private:
847 bool _internal_has_namespace_() const;
848 public:
849 void clear_namespace_();
850 const std::string& namespace_() const;
851 template <typename ArgT0 = const std::string&, typename... ArgT>
852 void set_namespace_(ArgT0&& arg0, ArgT... args);
853 std::string* mutable_namespace_();
854 PROTOBUF_NODISCARD std::string* release_namespace_();
855 void set_allocated_namespace_(std::string* namespace_);
856 private:
857 const std::string& _internal_namespace_() const;
858 inline PROTOBUF_ALWAYS_INLINE void _internal_set_namespace_(const std::string& value);
859 std::string* _internal_mutable_namespace_();
860 public:
861
862 // @@protoc_insertion_point(class_scope:icing.lib.PropertyProto.BlobHandleProto)
863 private:
864 class _Internal;
865
866 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
867 typedef void InternalArenaConstructable_;
868 typedef void DestructorSkippable_;
869 struct Impl_ {
870 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
871 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
872 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr digest_;
873 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr namespace__;
874 };
875 union { Impl_ _impl_; };
876 friend struct ::TableStruct_icing_2fproto_2fdocument_2eproto;
877 };
878 // -------------------------------------------------------------------
879
880 class PropertyProto final :
881 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:icing.lib.PropertyProto) */ {
882 public:
PropertyProto()883 inline PropertyProto() : PropertyProto(nullptr) {}
884 ~PropertyProto() override;
885 explicit PROTOBUF_CONSTEXPR PropertyProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
886
887 PropertyProto(const PropertyProto& from);
PropertyProto(PropertyProto && from)888 PropertyProto(PropertyProto&& from) noexcept
889 : PropertyProto() {
890 *this = ::std::move(from);
891 }
892
893 inline PropertyProto& operator=(const PropertyProto& from) {
894 if (this == &from) return *this;
895 CopyFrom(from);
896 return *this;
897 }
898 inline PropertyProto& operator=(PropertyProto&& from) noexcept {
899 if (this == &from) return *this;
900 if (GetOwningArena() == from.GetOwningArena()
901 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
902 && GetOwningArena() != nullptr
903 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
904 ) {
905 InternalSwap(&from);
906 } else {
907 CopyFrom(from);
908 }
909 return *this;
910 }
911
unknown_fields()912 inline const std::string& unknown_fields() const {
913 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
914 }
mutable_unknown_fields()915 inline std::string* mutable_unknown_fields() {
916 return _internal_metadata_.mutable_unknown_fields<std::string>();
917 }
918
default_instance()919 static const PropertyProto& default_instance() {
920 return *internal_default_instance();
921 }
internal_default_instance()922 static inline const PropertyProto* internal_default_instance() {
923 return reinterpret_cast<const PropertyProto*>(
924 &_PropertyProto_default_instance_);
925 }
926 static constexpr int kIndexInFileMessages =
927 4;
928
swap(PropertyProto & a,PropertyProto & b)929 friend void swap(PropertyProto& a, PropertyProto& b) {
930 a.Swap(&b);
931 }
Swap(PropertyProto * other)932 inline void Swap(PropertyProto* other) {
933 if (other == this) return;
934 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
935 if (GetOwningArena() != nullptr &&
936 GetOwningArena() == other->GetOwningArena()) {
937 #else // PROTOBUF_FORCE_COPY_IN_SWAP
938 if (GetOwningArena() == other->GetOwningArena()) {
939 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
940 InternalSwap(other);
941 } else {
942 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
943 }
944 }
945 void UnsafeArenaSwap(PropertyProto* other) {
946 if (other == this) return;
947 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
948 InternalSwap(other);
949 }
950
951 // implements Message ----------------------------------------------
952
953 PropertyProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
954 return CreateMaybeMessage<PropertyProto>(arena);
955 }
956 PropertyProto* New() const {
957 return New(nullptr);
958 }
959 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
960 void CopyFrom(const PropertyProto& from);
961 void MergeFrom(const PropertyProto& from);
962 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
963 bool IsInitialized() const final;
964
965 size_t ByteSizeLong() const final;
966 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
967 ::uint8_t* _InternalSerialize(
968 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
969 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
970
971 private:
972 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
973 void SharedDtor();
974 void SetCachedSize(int size) const;
975 void InternalSwap(PropertyProto* other);
976
977 private:
978 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
979 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
980 return "icing.lib.PropertyProto";
981 }
982 protected:
983 explicit PropertyProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
984 bool is_message_owned = false);
985 public:
986
987 std::string GetTypeName() const final;
988
989 // nested types ----------------------------------------------------
990
991 typedef PropertyProto_VectorProto VectorProto;
992 typedef PropertyProto_BlobHandleProto BlobHandleProto;
993
994 // accessors -------------------------------------------------------
995
996 enum : int {
997 kStringValuesFieldNumber = 2,
998 kInt64ValuesFieldNumber = 3,
999 kDoubleValuesFieldNumber = 4,
1000 kBooleanValuesFieldNumber = 5,
1001 kBytesValuesFieldNumber = 6,
1002 kDocumentValuesFieldNumber = 7,
1003 kVectorValuesFieldNumber = 8,
1004 kBlobHandleValuesFieldNumber = 9,
1005 kNameFieldNumber = 1,
1006 };
1007 // repeated string string_values = 2;
1008 int string_values_size() const;
1009 private:
1010 int _internal_string_values_size() const;
1011 public:
1012 void clear_string_values();
1013 const std::string& string_values(int index) const;
1014 std::string* mutable_string_values(int index);
1015 void set_string_values(int index, const std::string& value);
1016 void set_string_values(int index, std::string&& value);
1017 void set_string_values(int index, const char* value);
1018 void set_string_values(int index, const char* value, size_t size);
1019 std::string* add_string_values();
1020 void add_string_values(const std::string& value);
1021 void add_string_values(std::string&& value);
1022 void add_string_values(const char* value);
1023 void add_string_values(const char* value, size_t size);
1024 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& string_values() const;
1025 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_string_values();
1026 private:
1027 const std::string& _internal_string_values(int index) const;
1028 std::string* _internal_add_string_values();
1029 public:
1030
1031 // repeated int64 int64_values = 3;
1032 int int64_values_size() const;
1033 private:
1034 int _internal_int64_values_size() const;
1035 public:
1036 void clear_int64_values();
1037 private:
1038 ::int64_t _internal_int64_values(int index) const;
1039 const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int64_t >&
1040 _internal_int64_values() const;
1041 void _internal_add_int64_values(::int64_t value);
1042 ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int64_t >*
1043 _internal_mutable_int64_values();
1044 public:
1045 ::int64_t int64_values(int index) const;
1046 void set_int64_values(int index, ::int64_t value);
1047 void add_int64_values(::int64_t value);
1048 const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int64_t >&
1049 int64_values() const;
1050 ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int64_t >*
1051 mutable_int64_values();
1052
1053 // repeated double double_values = 4;
1054 int double_values_size() const;
1055 private:
1056 int _internal_double_values_size() const;
1057 public:
1058 void clear_double_values();
1059 private:
1060 double _internal_double_values(int index) const;
1061 const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
1062 _internal_double_values() const;
1063 void _internal_add_double_values(double value);
1064 ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
1065 _internal_mutable_double_values();
1066 public:
1067 double double_values(int index) const;
1068 void set_double_values(int index, double value);
1069 void add_double_values(double value);
1070 const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
1071 double_values() const;
1072 ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
1073 mutable_double_values();
1074
1075 // repeated bool boolean_values = 5;
1076 int boolean_values_size() const;
1077 private:
1078 int _internal_boolean_values_size() const;
1079 public:
1080 void clear_boolean_values();
1081 private:
1082 bool _internal_boolean_values(int index) const;
1083 const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >&
1084 _internal_boolean_values() const;
1085 void _internal_add_boolean_values(bool value);
1086 ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >*
1087 _internal_mutable_boolean_values();
1088 public:
1089 bool boolean_values(int index) const;
1090 void set_boolean_values(int index, bool value);
1091 void add_boolean_values(bool value);
1092 const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >&
1093 boolean_values() const;
1094 ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >*
1095 mutable_boolean_values();
1096
1097 // repeated bytes bytes_values = 6;
1098 int bytes_values_size() const;
1099 private:
1100 int _internal_bytes_values_size() const;
1101 public:
1102 void clear_bytes_values();
1103 const std::string& bytes_values(int index) const;
1104 std::string* mutable_bytes_values(int index);
1105 void set_bytes_values(int index, const std::string& value);
1106 void set_bytes_values(int index, std::string&& value);
1107 void set_bytes_values(int index, const char* value);
1108 void set_bytes_values(int index, const void* value, size_t size);
1109 std::string* add_bytes_values();
1110 void add_bytes_values(const std::string& value);
1111 void add_bytes_values(std::string&& value);
1112 void add_bytes_values(const char* value);
1113 void add_bytes_values(const void* value, size_t size);
1114 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& bytes_values() const;
1115 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_bytes_values();
1116 private:
1117 const std::string& _internal_bytes_values(int index) const;
1118 std::string* _internal_add_bytes_values();
1119 public:
1120
1121 // repeated .icing.lib.DocumentProto document_values = 7;
1122 int document_values_size() const;
1123 private:
1124 int _internal_document_values_size() const;
1125 public:
1126 void clear_document_values();
1127 ::icing::lib::DocumentProto* mutable_document_values(int index);
1128 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::DocumentProto >*
1129 mutable_document_values();
1130 private:
1131 const ::icing::lib::DocumentProto& _internal_document_values(int index) const;
1132 ::icing::lib::DocumentProto* _internal_add_document_values();
1133 public:
1134 const ::icing::lib::DocumentProto& document_values(int index) const;
1135 ::icing::lib::DocumentProto* add_document_values();
1136 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::DocumentProto >&
1137 document_values() const;
1138
1139 // repeated .icing.lib.PropertyProto.VectorProto vector_values = 8;
1140 int vector_values_size() const;
1141 private:
1142 int _internal_vector_values_size() const;
1143 public:
1144 void clear_vector_values();
1145 ::icing::lib::PropertyProto_VectorProto* mutable_vector_values(int index);
1146 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::PropertyProto_VectorProto >*
1147 mutable_vector_values();
1148 private:
1149 const ::icing::lib::PropertyProto_VectorProto& _internal_vector_values(int index) const;
1150 ::icing::lib::PropertyProto_VectorProto* _internal_add_vector_values();
1151 public:
1152 const ::icing::lib::PropertyProto_VectorProto& vector_values(int index) const;
1153 ::icing::lib::PropertyProto_VectorProto* add_vector_values();
1154 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::PropertyProto_VectorProto >&
1155 vector_values() const;
1156
1157 // repeated .icing.lib.PropertyProto.BlobHandleProto blob_handle_values = 9;
1158 int blob_handle_values_size() const;
1159 private:
1160 int _internal_blob_handle_values_size() const;
1161 public:
1162 void clear_blob_handle_values();
1163 ::icing::lib::PropertyProto_BlobHandleProto* mutable_blob_handle_values(int index);
1164 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::PropertyProto_BlobHandleProto >*
1165 mutable_blob_handle_values();
1166 private:
1167 const ::icing::lib::PropertyProto_BlobHandleProto& _internal_blob_handle_values(int index) const;
1168 ::icing::lib::PropertyProto_BlobHandleProto* _internal_add_blob_handle_values();
1169 public:
1170 const ::icing::lib::PropertyProto_BlobHandleProto& blob_handle_values(int index) const;
1171 ::icing::lib::PropertyProto_BlobHandleProto* add_blob_handle_values();
1172 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::PropertyProto_BlobHandleProto >&
1173 blob_handle_values() const;
1174
1175 // optional string name = 1;
1176 bool has_name() const;
1177 private:
1178 bool _internal_has_name() const;
1179 public:
1180 void clear_name();
1181 const std::string& name() const;
1182 template <typename ArgT0 = const std::string&, typename... ArgT>
1183 void set_name(ArgT0&& arg0, ArgT... args);
1184 std::string* mutable_name();
1185 PROTOBUF_NODISCARD std::string* release_name();
1186 void set_allocated_name(std::string* name);
1187 private:
1188 const std::string& _internal_name() const;
1189 inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
1190 std::string* _internal_mutable_name();
1191 public:
1192
1193 // @@protoc_insertion_point(class_scope:icing.lib.PropertyProto)
1194 private:
1195 class _Internal;
1196
1197 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1198 typedef void InternalArenaConstructable_;
1199 typedef void DestructorSkippable_;
1200 struct Impl_ {
1201 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
1202 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1203 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> string_values_;
1204 ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int64_t > int64_values_;
1205 ::PROTOBUF_NAMESPACE_ID::RepeatedField< double > double_values_;
1206 ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool > boolean_values_;
1207 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> bytes_values_;
1208 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::DocumentProto > document_values_;
1209 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::PropertyProto_VectorProto > vector_values_;
1210 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::PropertyProto_BlobHandleProto > blob_handle_values_;
1211 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
1212 };
1213 union { Impl_ _impl_; };
1214 friend struct ::TableStruct_icing_2fproto_2fdocument_2eproto;
1215 };
1216 // -------------------------------------------------------------------
1217
1218 class PutResultProto final :
1219 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:icing.lib.PutResultProto) */ {
1220 public:
PutResultProto()1221 inline PutResultProto() : PutResultProto(nullptr) {}
1222 ~PutResultProto() override;
1223 explicit PROTOBUF_CONSTEXPR PutResultProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1224
1225 PutResultProto(const PutResultProto& from);
PutResultProto(PutResultProto && from)1226 PutResultProto(PutResultProto&& from) noexcept
1227 : PutResultProto() {
1228 *this = ::std::move(from);
1229 }
1230
1231 inline PutResultProto& operator=(const PutResultProto& from) {
1232 if (this == &from) return *this;
1233 CopyFrom(from);
1234 return *this;
1235 }
1236 inline PutResultProto& operator=(PutResultProto&& from) noexcept {
1237 if (this == &from) return *this;
1238 if (GetOwningArena() == from.GetOwningArena()
1239 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1240 && GetOwningArena() != nullptr
1241 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
1242 ) {
1243 InternalSwap(&from);
1244 } else {
1245 CopyFrom(from);
1246 }
1247 return *this;
1248 }
1249
unknown_fields()1250 inline const std::string& unknown_fields() const {
1251 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
1252 }
mutable_unknown_fields()1253 inline std::string* mutable_unknown_fields() {
1254 return _internal_metadata_.mutable_unknown_fields<std::string>();
1255 }
1256
default_instance()1257 static const PutResultProto& default_instance() {
1258 return *internal_default_instance();
1259 }
internal_default_instance()1260 static inline const PutResultProto* internal_default_instance() {
1261 return reinterpret_cast<const PutResultProto*>(
1262 &_PutResultProto_default_instance_);
1263 }
1264 static constexpr int kIndexInFileMessages =
1265 5;
1266
swap(PutResultProto & a,PutResultProto & b)1267 friend void swap(PutResultProto& a, PutResultProto& b) {
1268 a.Swap(&b);
1269 }
Swap(PutResultProto * other)1270 inline void Swap(PutResultProto* other) {
1271 if (other == this) return;
1272 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1273 if (GetOwningArena() != nullptr &&
1274 GetOwningArena() == other->GetOwningArena()) {
1275 #else // PROTOBUF_FORCE_COPY_IN_SWAP
1276 if (GetOwningArena() == other->GetOwningArena()) {
1277 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
1278 InternalSwap(other);
1279 } else {
1280 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1281 }
1282 }
1283 void UnsafeArenaSwap(PutResultProto* other) {
1284 if (other == this) return;
1285 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1286 InternalSwap(other);
1287 }
1288
1289 // implements Message ----------------------------------------------
1290
1291 PutResultProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1292 return CreateMaybeMessage<PutResultProto>(arena);
1293 }
1294 PutResultProto* New() const {
1295 return New(nullptr);
1296 }
1297 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
1298 void CopyFrom(const PutResultProto& from);
1299 void MergeFrom(const PutResultProto& from);
1300 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1301 bool IsInitialized() const final;
1302
1303 size_t ByteSizeLong() const final;
1304 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1305 ::uint8_t* _InternalSerialize(
1306 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1307 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1308
1309 private:
1310 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1311 void SharedDtor();
1312 void SetCachedSize(int size) const;
1313 void InternalSwap(PutResultProto* other);
1314
1315 private:
1316 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1317 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1318 return "icing.lib.PutResultProto";
1319 }
1320 protected:
1321 explicit PutResultProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1322 bool is_message_owned = false);
1323 public:
1324
1325 std::string GetTypeName() const final;
1326
1327 // nested types ----------------------------------------------------
1328
1329 // accessors -------------------------------------------------------
1330
1331 enum : int {
1332 kStatusFieldNumber = 1,
1333 kPutDocumentStatsFieldNumber = 2,
1334 kWasReplacementFieldNumber = 3,
1335 };
1336 // optional .icing.lib.StatusProto status = 1;
1337 bool has_status() const;
1338 private:
1339 bool _internal_has_status() const;
1340 public:
1341 void clear_status();
1342 const ::icing::lib::StatusProto& status() const;
1343 PROTOBUF_NODISCARD ::icing::lib::StatusProto* release_status();
1344 ::icing::lib::StatusProto* mutable_status();
1345 void set_allocated_status(::icing::lib::StatusProto* status);
1346 private:
1347 const ::icing::lib::StatusProto& _internal_status() const;
1348 ::icing::lib::StatusProto* _internal_mutable_status();
1349 public:
1350 void unsafe_arena_set_allocated_status(
1351 ::icing::lib::StatusProto* status);
1352 ::icing::lib::StatusProto* unsafe_arena_release_status();
1353
1354 // optional .icing.lib.PutDocumentStatsProto put_document_stats = 2;
1355 bool has_put_document_stats() const;
1356 private:
1357 bool _internal_has_put_document_stats() const;
1358 public:
1359 void clear_put_document_stats();
1360 const ::icing::lib::PutDocumentStatsProto& put_document_stats() const;
1361 PROTOBUF_NODISCARD ::icing::lib::PutDocumentStatsProto* release_put_document_stats();
1362 ::icing::lib::PutDocumentStatsProto* mutable_put_document_stats();
1363 void set_allocated_put_document_stats(::icing::lib::PutDocumentStatsProto* put_document_stats);
1364 private:
1365 const ::icing::lib::PutDocumentStatsProto& _internal_put_document_stats() const;
1366 ::icing::lib::PutDocumentStatsProto* _internal_mutable_put_document_stats();
1367 public:
1368 void unsafe_arena_set_allocated_put_document_stats(
1369 ::icing::lib::PutDocumentStatsProto* put_document_stats);
1370 ::icing::lib::PutDocumentStatsProto* unsafe_arena_release_put_document_stats();
1371
1372 // optional bool was_replacement = 3;
1373 bool has_was_replacement() const;
1374 private:
1375 bool _internal_has_was_replacement() const;
1376 public:
1377 void clear_was_replacement();
1378 bool was_replacement() const;
1379 void set_was_replacement(bool value);
1380 private:
1381 bool _internal_was_replacement() const;
1382 void _internal_set_was_replacement(bool value);
1383 public:
1384
1385 // @@protoc_insertion_point(class_scope:icing.lib.PutResultProto)
1386 private:
1387 class _Internal;
1388
1389 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1390 typedef void InternalArenaConstructable_;
1391 typedef void DestructorSkippable_;
1392 struct Impl_ {
1393 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
1394 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1395 ::icing::lib::StatusProto* status_;
1396 ::icing::lib::PutDocumentStatsProto* put_document_stats_;
1397 bool was_replacement_;
1398 };
1399 union { Impl_ _impl_; };
1400 friend struct ::TableStruct_icing_2fproto_2fdocument_2eproto;
1401 };
1402 // -------------------------------------------------------------------
1403
1404 class GetResultProto final :
1405 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:icing.lib.GetResultProto) */ {
1406 public:
GetResultProto()1407 inline GetResultProto() : GetResultProto(nullptr) {}
1408 ~GetResultProto() override;
1409 explicit PROTOBUF_CONSTEXPR GetResultProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1410
1411 GetResultProto(const GetResultProto& from);
GetResultProto(GetResultProto && from)1412 GetResultProto(GetResultProto&& from) noexcept
1413 : GetResultProto() {
1414 *this = ::std::move(from);
1415 }
1416
1417 inline GetResultProto& operator=(const GetResultProto& from) {
1418 if (this == &from) return *this;
1419 CopyFrom(from);
1420 return *this;
1421 }
1422 inline GetResultProto& operator=(GetResultProto&& from) noexcept {
1423 if (this == &from) return *this;
1424 if (GetOwningArena() == from.GetOwningArena()
1425 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1426 && GetOwningArena() != nullptr
1427 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
1428 ) {
1429 InternalSwap(&from);
1430 } else {
1431 CopyFrom(from);
1432 }
1433 return *this;
1434 }
1435
unknown_fields()1436 inline const std::string& unknown_fields() const {
1437 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
1438 }
mutable_unknown_fields()1439 inline std::string* mutable_unknown_fields() {
1440 return _internal_metadata_.mutable_unknown_fields<std::string>();
1441 }
1442
default_instance()1443 static const GetResultProto& default_instance() {
1444 return *internal_default_instance();
1445 }
internal_default_instance()1446 static inline const GetResultProto* internal_default_instance() {
1447 return reinterpret_cast<const GetResultProto*>(
1448 &_GetResultProto_default_instance_);
1449 }
1450 static constexpr int kIndexInFileMessages =
1451 6;
1452
swap(GetResultProto & a,GetResultProto & b)1453 friend void swap(GetResultProto& a, GetResultProto& b) {
1454 a.Swap(&b);
1455 }
Swap(GetResultProto * other)1456 inline void Swap(GetResultProto* other) {
1457 if (other == this) return;
1458 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1459 if (GetOwningArena() != nullptr &&
1460 GetOwningArena() == other->GetOwningArena()) {
1461 #else // PROTOBUF_FORCE_COPY_IN_SWAP
1462 if (GetOwningArena() == other->GetOwningArena()) {
1463 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
1464 InternalSwap(other);
1465 } else {
1466 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1467 }
1468 }
1469 void UnsafeArenaSwap(GetResultProto* other) {
1470 if (other == this) return;
1471 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1472 InternalSwap(other);
1473 }
1474
1475 // implements Message ----------------------------------------------
1476
1477 GetResultProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1478 return CreateMaybeMessage<GetResultProto>(arena);
1479 }
1480 GetResultProto* New() const {
1481 return New(nullptr);
1482 }
1483 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
1484 void CopyFrom(const GetResultProto& from);
1485 void MergeFrom(const GetResultProto& from);
1486 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1487 bool IsInitialized() const final;
1488
1489 size_t ByteSizeLong() const final;
1490 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1491 ::uint8_t* _InternalSerialize(
1492 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1493 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1494
1495 private:
1496 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1497 void SharedDtor();
1498 void SetCachedSize(int size) const;
1499 void InternalSwap(GetResultProto* other);
1500
1501 private:
1502 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1503 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1504 return "icing.lib.GetResultProto";
1505 }
1506 protected:
1507 explicit GetResultProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1508 bool is_message_owned = false);
1509 public:
1510
1511 std::string GetTypeName() const final;
1512
1513 // nested types ----------------------------------------------------
1514
1515 // accessors -------------------------------------------------------
1516
1517 enum : int {
1518 kStatusFieldNumber = 1,
1519 kDocumentFieldNumber = 2,
1520 };
1521 // optional .icing.lib.StatusProto status = 1;
1522 bool has_status() const;
1523 private:
1524 bool _internal_has_status() const;
1525 public:
1526 void clear_status();
1527 const ::icing::lib::StatusProto& status() const;
1528 PROTOBUF_NODISCARD ::icing::lib::StatusProto* release_status();
1529 ::icing::lib::StatusProto* mutable_status();
1530 void set_allocated_status(::icing::lib::StatusProto* status);
1531 private:
1532 const ::icing::lib::StatusProto& _internal_status() const;
1533 ::icing::lib::StatusProto* _internal_mutable_status();
1534 public:
1535 void unsafe_arena_set_allocated_status(
1536 ::icing::lib::StatusProto* status);
1537 ::icing::lib::StatusProto* unsafe_arena_release_status();
1538
1539 // optional .icing.lib.DocumentProto document = 2;
1540 bool has_document() const;
1541 private:
1542 bool _internal_has_document() const;
1543 public:
1544 void clear_document();
1545 const ::icing::lib::DocumentProto& document() const;
1546 PROTOBUF_NODISCARD ::icing::lib::DocumentProto* release_document();
1547 ::icing::lib::DocumentProto* mutable_document();
1548 void set_allocated_document(::icing::lib::DocumentProto* document);
1549 private:
1550 const ::icing::lib::DocumentProto& _internal_document() const;
1551 ::icing::lib::DocumentProto* _internal_mutable_document();
1552 public:
1553 void unsafe_arena_set_allocated_document(
1554 ::icing::lib::DocumentProto* document);
1555 ::icing::lib::DocumentProto* unsafe_arena_release_document();
1556
1557 // @@protoc_insertion_point(class_scope:icing.lib.GetResultProto)
1558 private:
1559 class _Internal;
1560
1561 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1562 typedef void InternalArenaConstructable_;
1563 typedef void DestructorSkippable_;
1564 struct Impl_ {
1565 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
1566 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1567 ::icing::lib::StatusProto* status_;
1568 ::icing::lib::DocumentProto* document_;
1569 };
1570 union { Impl_ _impl_; };
1571 friend struct ::TableStruct_icing_2fproto_2fdocument_2eproto;
1572 };
1573 // -------------------------------------------------------------------
1574
1575 class GetAllNamespacesResultProto final :
1576 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:icing.lib.GetAllNamespacesResultProto) */ {
1577 public:
GetAllNamespacesResultProto()1578 inline GetAllNamespacesResultProto() : GetAllNamespacesResultProto(nullptr) {}
1579 ~GetAllNamespacesResultProto() override;
1580 explicit PROTOBUF_CONSTEXPR GetAllNamespacesResultProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1581
1582 GetAllNamespacesResultProto(const GetAllNamespacesResultProto& from);
GetAllNamespacesResultProto(GetAllNamespacesResultProto && from)1583 GetAllNamespacesResultProto(GetAllNamespacesResultProto&& from) noexcept
1584 : GetAllNamespacesResultProto() {
1585 *this = ::std::move(from);
1586 }
1587
1588 inline GetAllNamespacesResultProto& operator=(const GetAllNamespacesResultProto& from) {
1589 if (this == &from) return *this;
1590 CopyFrom(from);
1591 return *this;
1592 }
1593 inline GetAllNamespacesResultProto& operator=(GetAllNamespacesResultProto&& from) noexcept {
1594 if (this == &from) return *this;
1595 if (GetOwningArena() == from.GetOwningArena()
1596 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1597 && GetOwningArena() != nullptr
1598 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
1599 ) {
1600 InternalSwap(&from);
1601 } else {
1602 CopyFrom(from);
1603 }
1604 return *this;
1605 }
1606
unknown_fields()1607 inline const std::string& unknown_fields() const {
1608 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
1609 }
mutable_unknown_fields()1610 inline std::string* mutable_unknown_fields() {
1611 return _internal_metadata_.mutable_unknown_fields<std::string>();
1612 }
1613
default_instance()1614 static const GetAllNamespacesResultProto& default_instance() {
1615 return *internal_default_instance();
1616 }
internal_default_instance()1617 static inline const GetAllNamespacesResultProto* internal_default_instance() {
1618 return reinterpret_cast<const GetAllNamespacesResultProto*>(
1619 &_GetAllNamespacesResultProto_default_instance_);
1620 }
1621 static constexpr int kIndexInFileMessages =
1622 7;
1623
swap(GetAllNamespacesResultProto & a,GetAllNamespacesResultProto & b)1624 friend void swap(GetAllNamespacesResultProto& a, GetAllNamespacesResultProto& b) {
1625 a.Swap(&b);
1626 }
Swap(GetAllNamespacesResultProto * other)1627 inline void Swap(GetAllNamespacesResultProto* other) {
1628 if (other == this) return;
1629 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1630 if (GetOwningArena() != nullptr &&
1631 GetOwningArena() == other->GetOwningArena()) {
1632 #else // PROTOBUF_FORCE_COPY_IN_SWAP
1633 if (GetOwningArena() == other->GetOwningArena()) {
1634 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
1635 InternalSwap(other);
1636 } else {
1637 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1638 }
1639 }
1640 void UnsafeArenaSwap(GetAllNamespacesResultProto* other) {
1641 if (other == this) return;
1642 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1643 InternalSwap(other);
1644 }
1645
1646 // implements Message ----------------------------------------------
1647
1648 GetAllNamespacesResultProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1649 return CreateMaybeMessage<GetAllNamespacesResultProto>(arena);
1650 }
1651 GetAllNamespacesResultProto* New() const {
1652 return New(nullptr);
1653 }
1654 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
1655 void CopyFrom(const GetAllNamespacesResultProto& from);
1656 void MergeFrom(const GetAllNamespacesResultProto& from);
1657 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1658 bool IsInitialized() const final;
1659
1660 size_t ByteSizeLong() const final;
1661 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1662 ::uint8_t* _InternalSerialize(
1663 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1664 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1665
1666 private:
1667 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1668 void SharedDtor();
1669 void SetCachedSize(int size) const;
1670 void InternalSwap(GetAllNamespacesResultProto* other);
1671
1672 private:
1673 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1674 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1675 return "icing.lib.GetAllNamespacesResultProto";
1676 }
1677 protected:
1678 explicit GetAllNamespacesResultProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1679 bool is_message_owned = false);
1680 public:
1681
1682 std::string GetTypeName() const final;
1683
1684 // nested types ----------------------------------------------------
1685
1686 // accessors -------------------------------------------------------
1687
1688 enum : int {
1689 kNamespacesFieldNumber = 2,
1690 kStatusFieldNumber = 1,
1691 };
1692 // repeated string namespaces = 2;
1693 int namespaces_size() const;
1694 private:
1695 int _internal_namespaces_size() const;
1696 public:
1697 void clear_namespaces();
1698 const std::string& namespaces(int index) const;
1699 std::string* mutable_namespaces(int index);
1700 void set_namespaces(int index, const std::string& value);
1701 void set_namespaces(int index, std::string&& value);
1702 void set_namespaces(int index, const char* value);
1703 void set_namespaces(int index, const char* value, size_t size);
1704 std::string* add_namespaces();
1705 void add_namespaces(const std::string& value);
1706 void add_namespaces(std::string&& value);
1707 void add_namespaces(const char* value);
1708 void add_namespaces(const char* value, size_t size);
1709 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& namespaces() const;
1710 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_namespaces();
1711 private:
1712 const std::string& _internal_namespaces(int index) const;
1713 std::string* _internal_add_namespaces();
1714 public:
1715
1716 // optional .icing.lib.StatusProto status = 1;
1717 bool has_status() const;
1718 private:
1719 bool _internal_has_status() const;
1720 public:
1721 void clear_status();
1722 const ::icing::lib::StatusProto& status() const;
1723 PROTOBUF_NODISCARD ::icing::lib::StatusProto* release_status();
1724 ::icing::lib::StatusProto* mutable_status();
1725 void set_allocated_status(::icing::lib::StatusProto* status);
1726 private:
1727 const ::icing::lib::StatusProto& _internal_status() const;
1728 ::icing::lib::StatusProto* _internal_mutable_status();
1729 public:
1730 void unsafe_arena_set_allocated_status(
1731 ::icing::lib::StatusProto* status);
1732 ::icing::lib::StatusProto* unsafe_arena_release_status();
1733
1734 // @@protoc_insertion_point(class_scope:icing.lib.GetAllNamespacesResultProto)
1735 private:
1736 class _Internal;
1737
1738 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1739 typedef void InternalArenaConstructable_;
1740 typedef void DestructorSkippable_;
1741 struct Impl_ {
1742 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
1743 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1744 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> namespaces_;
1745 ::icing::lib::StatusProto* status_;
1746 };
1747 union { Impl_ _impl_; };
1748 friend struct ::TableStruct_icing_2fproto_2fdocument_2eproto;
1749 };
1750 // -------------------------------------------------------------------
1751
1752 class DeleteResultProto final :
1753 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:icing.lib.DeleteResultProto) */ {
1754 public:
DeleteResultProto()1755 inline DeleteResultProto() : DeleteResultProto(nullptr) {}
1756 ~DeleteResultProto() override;
1757 explicit PROTOBUF_CONSTEXPR DeleteResultProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1758
1759 DeleteResultProto(const DeleteResultProto& from);
DeleteResultProto(DeleteResultProto && from)1760 DeleteResultProto(DeleteResultProto&& from) noexcept
1761 : DeleteResultProto() {
1762 *this = ::std::move(from);
1763 }
1764
1765 inline DeleteResultProto& operator=(const DeleteResultProto& from) {
1766 if (this == &from) return *this;
1767 CopyFrom(from);
1768 return *this;
1769 }
1770 inline DeleteResultProto& operator=(DeleteResultProto&& from) noexcept {
1771 if (this == &from) return *this;
1772 if (GetOwningArena() == from.GetOwningArena()
1773 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1774 && GetOwningArena() != nullptr
1775 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
1776 ) {
1777 InternalSwap(&from);
1778 } else {
1779 CopyFrom(from);
1780 }
1781 return *this;
1782 }
1783
unknown_fields()1784 inline const std::string& unknown_fields() const {
1785 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
1786 }
mutable_unknown_fields()1787 inline std::string* mutable_unknown_fields() {
1788 return _internal_metadata_.mutable_unknown_fields<std::string>();
1789 }
1790
default_instance()1791 static const DeleteResultProto& default_instance() {
1792 return *internal_default_instance();
1793 }
internal_default_instance()1794 static inline const DeleteResultProto* internal_default_instance() {
1795 return reinterpret_cast<const DeleteResultProto*>(
1796 &_DeleteResultProto_default_instance_);
1797 }
1798 static constexpr int kIndexInFileMessages =
1799 8;
1800
swap(DeleteResultProto & a,DeleteResultProto & b)1801 friend void swap(DeleteResultProto& a, DeleteResultProto& b) {
1802 a.Swap(&b);
1803 }
Swap(DeleteResultProto * other)1804 inline void Swap(DeleteResultProto* other) {
1805 if (other == this) return;
1806 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1807 if (GetOwningArena() != nullptr &&
1808 GetOwningArena() == other->GetOwningArena()) {
1809 #else // PROTOBUF_FORCE_COPY_IN_SWAP
1810 if (GetOwningArena() == other->GetOwningArena()) {
1811 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
1812 InternalSwap(other);
1813 } else {
1814 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1815 }
1816 }
1817 void UnsafeArenaSwap(DeleteResultProto* other) {
1818 if (other == this) return;
1819 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1820 InternalSwap(other);
1821 }
1822
1823 // implements Message ----------------------------------------------
1824
1825 DeleteResultProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1826 return CreateMaybeMessage<DeleteResultProto>(arena);
1827 }
1828 DeleteResultProto* New() const {
1829 return New(nullptr);
1830 }
1831 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
1832 void CopyFrom(const DeleteResultProto& from);
1833 void MergeFrom(const DeleteResultProto& from);
1834 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1835 bool IsInitialized() const final;
1836
1837 size_t ByteSizeLong() const final;
1838 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1839 ::uint8_t* _InternalSerialize(
1840 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1841 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1842
1843 private:
1844 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1845 void SharedDtor();
1846 void SetCachedSize(int size) const;
1847 void InternalSwap(DeleteResultProto* other);
1848
1849 private:
1850 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1851 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1852 return "icing.lib.DeleteResultProto";
1853 }
1854 protected:
1855 explicit DeleteResultProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1856 bool is_message_owned = false);
1857 public:
1858
1859 std::string GetTypeName() const final;
1860
1861 // nested types ----------------------------------------------------
1862
1863 // accessors -------------------------------------------------------
1864
1865 enum : int {
1866 kStatusFieldNumber = 1,
1867 kDeleteStatsFieldNumber = 2,
1868 };
1869 // optional .icing.lib.StatusProto status = 1;
1870 bool has_status() const;
1871 private:
1872 bool _internal_has_status() const;
1873 public:
1874 void clear_status();
1875 const ::icing::lib::StatusProto& status() const;
1876 PROTOBUF_NODISCARD ::icing::lib::StatusProto* release_status();
1877 ::icing::lib::StatusProto* mutable_status();
1878 void set_allocated_status(::icing::lib::StatusProto* status);
1879 private:
1880 const ::icing::lib::StatusProto& _internal_status() const;
1881 ::icing::lib::StatusProto* _internal_mutable_status();
1882 public:
1883 void unsafe_arena_set_allocated_status(
1884 ::icing::lib::StatusProto* status);
1885 ::icing::lib::StatusProto* unsafe_arena_release_status();
1886
1887 // optional .icing.lib.DeleteStatsProto delete_stats = 2;
1888 bool has_delete_stats() const;
1889 private:
1890 bool _internal_has_delete_stats() const;
1891 public:
1892 void clear_delete_stats();
1893 const ::icing::lib::DeleteStatsProto& delete_stats() const;
1894 PROTOBUF_NODISCARD ::icing::lib::DeleteStatsProto* release_delete_stats();
1895 ::icing::lib::DeleteStatsProto* mutable_delete_stats();
1896 void set_allocated_delete_stats(::icing::lib::DeleteStatsProto* delete_stats);
1897 private:
1898 const ::icing::lib::DeleteStatsProto& _internal_delete_stats() const;
1899 ::icing::lib::DeleteStatsProto* _internal_mutable_delete_stats();
1900 public:
1901 void unsafe_arena_set_allocated_delete_stats(
1902 ::icing::lib::DeleteStatsProto* delete_stats);
1903 ::icing::lib::DeleteStatsProto* unsafe_arena_release_delete_stats();
1904
1905 // @@protoc_insertion_point(class_scope:icing.lib.DeleteResultProto)
1906 private:
1907 class _Internal;
1908
1909 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1910 typedef void InternalArenaConstructable_;
1911 typedef void DestructorSkippable_;
1912 struct Impl_ {
1913 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
1914 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1915 ::icing::lib::StatusProto* status_;
1916 ::icing::lib::DeleteStatsProto* delete_stats_;
1917 };
1918 union { Impl_ _impl_; };
1919 friend struct ::TableStruct_icing_2fproto_2fdocument_2eproto;
1920 };
1921 // -------------------------------------------------------------------
1922
1923 class DeleteByNamespaceResultProto final :
1924 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:icing.lib.DeleteByNamespaceResultProto) */ {
1925 public:
DeleteByNamespaceResultProto()1926 inline DeleteByNamespaceResultProto() : DeleteByNamespaceResultProto(nullptr) {}
1927 ~DeleteByNamespaceResultProto() override;
1928 explicit PROTOBUF_CONSTEXPR DeleteByNamespaceResultProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1929
1930 DeleteByNamespaceResultProto(const DeleteByNamespaceResultProto& from);
DeleteByNamespaceResultProto(DeleteByNamespaceResultProto && from)1931 DeleteByNamespaceResultProto(DeleteByNamespaceResultProto&& from) noexcept
1932 : DeleteByNamespaceResultProto() {
1933 *this = ::std::move(from);
1934 }
1935
1936 inline DeleteByNamespaceResultProto& operator=(const DeleteByNamespaceResultProto& from) {
1937 if (this == &from) return *this;
1938 CopyFrom(from);
1939 return *this;
1940 }
1941 inline DeleteByNamespaceResultProto& operator=(DeleteByNamespaceResultProto&& from) noexcept {
1942 if (this == &from) return *this;
1943 if (GetOwningArena() == from.GetOwningArena()
1944 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1945 && GetOwningArena() != nullptr
1946 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
1947 ) {
1948 InternalSwap(&from);
1949 } else {
1950 CopyFrom(from);
1951 }
1952 return *this;
1953 }
1954
unknown_fields()1955 inline const std::string& unknown_fields() const {
1956 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
1957 }
mutable_unknown_fields()1958 inline std::string* mutable_unknown_fields() {
1959 return _internal_metadata_.mutable_unknown_fields<std::string>();
1960 }
1961
default_instance()1962 static const DeleteByNamespaceResultProto& default_instance() {
1963 return *internal_default_instance();
1964 }
internal_default_instance()1965 static inline const DeleteByNamespaceResultProto* internal_default_instance() {
1966 return reinterpret_cast<const DeleteByNamespaceResultProto*>(
1967 &_DeleteByNamespaceResultProto_default_instance_);
1968 }
1969 static constexpr int kIndexInFileMessages =
1970 9;
1971
swap(DeleteByNamespaceResultProto & a,DeleteByNamespaceResultProto & b)1972 friend void swap(DeleteByNamespaceResultProto& a, DeleteByNamespaceResultProto& b) {
1973 a.Swap(&b);
1974 }
Swap(DeleteByNamespaceResultProto * other)1975 inline void Swap(DeleteByNamespaceResultProto* other) {
1976 if (other == this) return;
1977 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1978 if (GetOwningArena() != nullptr &&
1979 GetOwningArena() == other->GetOwningArena()) {
1980 #else // PROTOBUF_FORCE_COPY_IN_SWAP
1981 if (GetOwningArena() == other->GetOwningArena()) {
1982 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
1983 InternalSwap(other);
1984 } else {
1985 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1986 }
1987 }
1988 void UnsafeArenaSwap(DeleteByNamespaceResultProto* other) {
1989 if (other == this) return;
1990 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1991 InternalSwap(other);
1992 }
1993
1994 // implements Message ----------------------------------------------
1995
1996 DeleteByNamespaceResultProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1997 return CreateMaybeMessage<DeleteByNamespaceResultProto>(arena);
1998 }
1999 DeleteByNamespaceResultProto* New() const {
2000 return New(nullptr);
2001 }
2002 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
2003 void CopyFrom(const DeleteByNamespaceResultProto& from);
2004 void MergeFrom(const DeleteByNamespaceResultProto& from);
2005 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
2006 bool IsInitialized() const final;
2007
2008 size_t ByteSizeLong() const final;
2009 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
2010 ::uint8_t* _InternalSerialize(
2011 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
2012 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
2013
2014 private:
2015 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
2016 void SharedDtor();
2017 void SetCachedSize(int size) const;
2018 void InternalSwap(DeleteByNamespaceResultProto* other);
2019
2020 private:
2021 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
2022 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
2023 return "icing.lib.DeleteByNamespaceResultProto";
2024 }
2025 protected:
2026 explicit DeleteByNamespaceResultProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2027 bool is_message_owned = false);
2028 public:
2029
2030 std::string GetTypeName() const final;
2031
2032 // nested types ----------------------------------------------------
2033
2034 // accessors -------------------------------------------------------
2035
2036 enum : int {
2037 kStatusFieldNumber = 1,
2038 kDeleteStatsFieldNumber = 2,
2039 };
2040 // optional .icing.lib.StatusProto status = 1;
2041 bool has_status() const;
2042 private:
2043 bool _internal_has_status() const;
2044 public:
2045 void clear_status();
2046 const ::icing::lib::StatusProto& status() const;
2047 PROTOBUF_NODISCARD ::icing::lib::StatusProto* release_status();
2048 ::icing::lib::StatusProto* mutable_status();
2049 void set_allocated_status(::icing::lib::StatusProto* status);
2050 private:
2051 const ::icing::lib::StatusProto& _internal_status() const;
2052 ::icing::lib::StatusProto* _internal_mutable_status();
2053 public:
2054 void unsafe_arena_set_allocated_status(
2055 ::icing::lib::StatusProto* status);
2056 ::icing::lib::StatusProto* unsafe_arena_release_status();
2057
2058 // optional .icing.lib.DeleteStatsProto delete_stats = 2;
2059 bool has_delete_stats() const;
2060 private:
2061 bool _internal_has_delete_stats() const;
2062 public:
2063 void clear_delete_stats();
2064 const ::icing::lib::DeleteStatsProto& delete_stats() const;
2065 PROTOBUF_NODISCARD ::icing::lib::DeleteStatsProto* release_delete_stats();
2066 ::icing::lib::DeleteStatsProto* mutable_delete_stats();
2067 void set_allocated_delete_stats(::icing::lib::DeleteStatsProto* delete_stats);
2068 private:
2069 const ::icing::lib::DeleteStatsProto& _internal_delete_stats() const;
2070 ::icing::lib::DeleteStatsProto* _internal_mutable_delete_stats();
2071 public:
2072 void unsafe_arena_set_allocated_delete_stats(
2073 ::icing::lib::DeleteStatsProto* delete_stats);
2074 ::icing::lib::DeleteStatsProto* unsafe_arena_release_delete_stats();
2075
2076 // @@protoc_insertion_point(class_scope:icing.lib.DeleteByNamespaceResultProto)
2077 private:
2078 class _Internal;
2079
2080 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
2081 typedef void InternalArenaConstructable_;
2082 typedef void DestructorSkippable_;
2083 struct Impl_ {
2084 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
2085 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2086 ::icing::lib::StatusProto* status_;
2087 ::icing::lib::DeleteStatsProto* delete_stats_;
2088 };
2089 union { Impl_ _impl_; };
2090 friend struct ::TableStruct_icing_2fproto_2fdocument_2eproto;
2091 };
2092 // -------------------------------------------------------------------
2093
2094 class DeleteBySchemaTypeResultProto final :
2095 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:icing.lib.DeleteBySchemaTypeResultProto) */ {
2096 public:
DeleteBySchemaTypeResultProto()2097 inline DeleteBySchemaTypeResultProto() : DeleteBySchemaTypeResultProto(nullptr) {}
2098 ~DeleteBySchemaTypeResultProto() override;
2099 explicit PROTOBUF_CONSTEXPR DeleteBySchemaTypeResultProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
2100
2101 DeleteBySchemaTypeResultProto(const DeleteBySchemaTypeResultProto& from);
DeleteBySchemaTypeResultProto(DeleteBySchemaTypeResultProto && from)2102 DeleteBySchemaTypeResultProto(DeleteBySchemaTypeResultProto&& from) noexcept
2103 : DeleteBySchemaTypeResultProto() {
2104 *this = ::std::move(from);
2105 }
2106
2107 inline DeleteBySchemaTypeResultProto& operator=(const DeleteBySchemaTypeResultProto& from) {
2108 if (this == &from) return *this;
2109 CopyFrom(from);
2110 return *this;
2111 }
2112 inline DeleteBySchemaTypeResultProto& operator=(DeleteBySchemaTypeResultProto&& from) noexcept {
2113 if (this == &from) return *this;
2114 if (GetOwningArena() == from.GetOwningArena()
2115 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
2116 && GetOwningArena() != nullptr
2117 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
2118 ) {
2119 InternalSwap(&from);
2120 } else {
2121 CopyFrom(from);
2122 }
2123 return *this;
2124 }
2125
unknown_fields()2126 inline const std::string& unknown_fields() const {
2127 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
2128 }
mutable_unknown_fields()2129 inline std::string* mutable_unknown_fields() {
2130 return _internal_metadata_.mutable_unknown_fields<std::string>();
2131 }
2132
default_instance()2133 static const DeleteBySchemaTypeResultProto& default_instance() {
2134 return *internal_default_instance();
2135 }
internal_default_instance()2136 static inline const DeleteBySchemaTypeResultProto* internal_default_instance() {
2137 return reinterpret_cast<const DeleteBySchemaTypeResultProto*>(
2138 &_DeleteBySchemaTypeResultProto_default_instance_);
2139 }
2140 static constexpr int kIndexInFileMessages =
2141 10;
2142
swap(DeleteBySchemaTypeResultProto & a,DeleteBySchemaTypeResultProto & b)2143 friend void swap(DeleteBySchemaTypeResultProto& a, DeleteBySchemaTypeResultProto& b) {
2144 a.Swap(&b);
2145 }
Swap(DeleteBySchemaTypeResultProto * other)2146 inline void Swap(DeleteBySchemaTypeResultProto* other) {
2147 if (other == this) return;
2148 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
2149 if (GetOwningArena() != nullptr &&
2150 GetOwningArena() == other->GetOwningArena()) {
2151 #else // PROTOBUF_FORCE_COPY_IN_SWAP
2152 if (GetOwningArena() == other->GetOwningArena()) {
2153 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
2154 InternalSwap(other);
2155 } else {
2156 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
2157 }
2158 }
2159 void UnsafeArenaSwap(DeleteBySchemaTypeResultProto* other) {
2160 if (other == this) return;
2161 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
2162 InternalSwap(other);
2163 }
2164
2165 // implements Message ----------------------------------------------
2166
2167 DeleteBySchemaTypeResultProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
2168 return CreateMaybeMessage<DeleteBySchemaTypeResultProto>(arena);
2169 }
2170 DeleteBySchemaTypeResultProto* New() const {
2171 return New(nullptr);
2172 }
2173 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
2174 void CopyFrom(const DeleteBySchemaTypeResultProto& from);
2175 void MergeFrom(const DeleteBySchemaTypeResultProto& from);
2176 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
2177 bool IsInitialized() const final;
2178
2179 size_t ByteSizeLong() const final;
2180 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
2181 ::uint8_t* _InternalSerialize(
2182 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
2183 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
2184
2185 private:
2186 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
2187 void SharedDtor();
2188 void SetCachedSize(int size) const;
2189 void InternalSwap(DeleteBySchemaTypeResultProto* other);
2190
2191 private:
2192 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
2193 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
2194 return "icing.lib.DeleteBySchemaTypeResultProto";
2195 }
2196 protected:
2197 explicit DeleteBySchemaTypeResultProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2198 bool is_message_owned = false);
2199 public:
2200
2201 std::string GetTypeName() const final;
2202
2203 // nested types ----------------------------------------------------
2204
2205 // accessors -------------------------------------------------------
2206
2207 enum : int {
2208 kStatusFieldNumber = 1,
2209 kDeleteStatsFieldNumber = 2,
2210 };
2211 // optional .icing.lib.StatusProto status = 1;
2212 bool has_status() const;
2213 private:
2214 bool _internal_has_status() const;
2215 public:
2216 void clear_status();
2217 const ::icing::lib::StatusProto& status() const;
2218 PROTOBUF_NODISCARD ::icing::lib::StatusProto* release_status();
2219 ::icing::lib::StatusProto* mutable_status();
2220 void set_allocated_status(::icing::lib::StatusProto* status);
2221 private:
2222 const ::icing::lib::StatusProto& _internal_status() const;
2223 ::icing::lib::StatusProto* _internal_mutable_status();
2224 public:
2225 void unsafe_arena_set_allocated_status(
2226 ::icing::lib::StatusProto* status);
2227 ::icing::lib::StatusProto* unsafe_arena_release_status();
2228
2229 // optional .icing.lib.DeleteStatsProto delete_stats = 2;
2230 bool has_delete_stats() const;
2231 private:
2232 bool _internal_has_delete_stats() const;
2233 public:
2234 void clear_delete_stats();
2235 const ::icing::lib::DeleteStatsProto& delete_stats() const;
2236 PROTOBUF_NODISCARD ::icing::lib::DeleteStatsProto* release_delete_stats();
2237 ::icing::lib::DeleteStatsProto* mutable_delete_stats();
2238 void set_allocated_delete_stats(::icing::lib::DeleteStatsProto* delete_stats);
2239 private:
2240 const ::icing::lib::DeleteStatsProto& _internal_delete_stats() const;
2241 ::icing::lib::DeleteStatsProto* _internal_mutable_delete_stats();
2242 public:
2243 void unsafe_arena_set_allocated_delete_stats(
2244 ::icing::lib::DeleteStatsProto* delete_stats);
2245 ::icing::lib::DeleteStatsProto* unsafe_arena_release_delete_stats();
2246
2247 // @@protoc_insertion_point(class_scope:icing.lib.DeleteBySchemaTypeResultProto)
2248 private:
2249 class _Internal;
2250
2251 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
2252 typedef void InternalArenaConstructable_;
2253 typedef void DestructorSkippable_;
2254 struct Impl_ {
2255 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
2256 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2257 ::icing::lib::StatusProto* status_;
2258 ::icing::lib::DeleteStatsProto* delete_stats_;
2259 };
2260 union { Impl_ _impl_; };
2261 friend struct ::TableStruct_icing_2fproto_2fdocument_2eproto;
2262 };
2263 // -------------------------------------------------------------------
2264
2265 class DeleteByQueryResultProto_DocumentGroupInfo final :
2266 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:icing.lib.DeleteByQueryResultProto.DocumentGroupInfo) */ {
2267 public:
DeleteByQueryResultProto_DocumentGroupInfo()2268 inline DeleteByQueryResultProto_DocumentGroupInfo() : DeleteByQueryResultProto_DocumentGroupInfo(nullptr) {}
2269 ~DeleteByQueryResultProto_DocumentGroupInfo() override;
2270 explicit PROTOBUF_CONSTEXPR DeleteByQueryResultProto_DocumentGroupInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
2271
2272 DeleteByQueryResultProto_DocumentGroupInfo(const DeleteByQueryResultProto_DocumentGroupInfo& from);
DeleteByQueryResultProto_DocumentGroupInfo(DeleteByQueryResultProto_DocumentGroupInfo && from)2273 DeleteByQueryResultProto_DocumentGroupInfo(DeleteByQueryResultProto_DocumentGroupInfo&& from) noexcept
2274 : DeleteByQueryResultProto_DocumentGroupInfo() {
2275 *this = ::std::move(from);
2276 }
2277
2278 inline DeleteByQueryResultProto_DocumentGroupInfo& operator=(const DeleteByQueryResultProto_DocumentGroupInfo& from) {
2279 if (this == &from) return *this;
2280 CopyFrom(from);
2281 return *this;
2282 }
2283 inline DeleteByQueryResultProto_DocumentGroupInfo& operator=(DeleteByQueryResultProto_DocumentGroupInfo&& from) noexcept {
2284 if (this == &from) return *this;
2285 if (GetOwningArena() == from.GetOwningArena()
2286 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
2287 && GetOwningArena() != nullptr
2288 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
2289 ) {
2290 InternalSwap(&from);
2291 } else {
2292 CopyFrom(from);
2293 }
2294 return *this;
2295 }
2296
unknown_fields()2297 inline const std::string& unknown_fields() const {
2298 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
2299 }
mutable_unknown_fields()2300 inline std::string* mutable_unknown_fields() {
2301 return _internal_metadata_.mutable_unknown_fields<std::string>();
2302 }
2303
default_instance()2304 static const DeleteByQueryResultProto_DocumentGroupInfo& default_instance() {
2305 return *internal_default_instance();
2306 }
internal_default_instance()2307 static inline const DeleteByQueryResultProto_DocumentGroupInfo* internal_default_instance() {
2308 return reinterpret_cast<const DeleteByQueryResultProto_DocumentGroupInfo*>(
2309 &_DeleteByQueryResultProto_DocumentGroupInfo_default_instance_);
2310 }
2311 static constexpr int kIndexInFileMessages =
2312 11;
2313
swap(DeleteByQueryResultProto_DocumentGroupInfo & a,DeleteByQueryResultProto_DocumentGroupInfo & b)2314 friend void swap(DeleteByQueryResultProto_DocumentGroupInfo& a, DeleteByQueryResultProto_DocumentGroupInfo& b) {
2315 a.Swap(&b);
2316 }
Swap(DeleteByQueryResultProto_DocumentGroupInfo * other)2317 inline void Swap(DeleteByQueryResultProto_DocumentGroupInfo* other) {
2318 if (other == this) return;
2319 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
2320 if (GetOwningArena() != nullptr &&
2321 GetOwningArena() == other->GetOwningArena()) {
2322 #else // PROTOBUF_FORCE_COPY_IN_SWAP
2323 if (GetOwningArena() == other->GetOwningArena()) {
2324 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
2325 InternalSwap(other);
2326 } else {
2327 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
2328 }
2329 }
2330 void UnsafeArenaSwap(DeleteByQueryResultProto_DocumentGroupInfo* other) {
2331 if (other == this) return;
2332 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
2333 InternalSwap(other);
2334 }
2335
2336 // implements Message ----------------------------------------------
2337
2338 DeleteByQueryResultProto_DocumentGroupInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
2339 return CreateMaybeMessage<DeleteByQueryResultProto_DocumentGroupInfo>(arena);
2340 }
2341 DeleteByQueryResultProto_DocumentGroupInfo* New() const {
2342 return New(nullptr);
2343 }
2344 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
2345 void CopyFrom(const DeleteByQueryResultProto_DocumentGroupInfo& from);
2346 void MergeFrom(const DeleteByQueryResultProto_DocumentGroupInfo& from);
2347 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
2348 bool IsInitialized() const final;
2349
2350 size_t ByteSizeLong() const final;
2351 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
2352 ::uint8_t* _InternalSerialize(
2353 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
2354 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
2355
2356 private:
2357 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
2358 void SharedDtor();
2359 void SetCachedSize(int size) const;
2360 void InternalSwap(DeleteByQueryResultProto_DocumentGroupInfo* other);
2361
2362 private:
2363 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
2364 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
2365 return "icing.lib.DeleteByQueryResultProto.DocumentGroupInfo";
2366 }
2367 protected:
2368 explicit DeleteByQueryResultProto_DocumentGroupInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2369 bool is_message_owned = false);
2370 public:
2371
2372 std::string GetTypeName() const final;
2373
2374 // nested types ----------------------------------------------------
2375
2376 // accessors -------------------------------------------------------
2377
2378 enum : int {
2379 kUrisFieldNumber = 3,
2380 kNamespaceFieldNumber = 1,
2381 kSchemaFieldNumber = 2,
2382 };
2383 // repeated string uris = 3;
2384 int uris_size() const;
2385 private:
2386 int _internal_uris_size() const;
2387 public:
2388 void clear_uris();
2389 const std::string& uris(int index) const;
2390 std::string* mutable_uris(int index);
2391 void set_uris(int index, const std::string& value);
2392 void set_uris(int index, std::string&& value);
2393 void set_uris(int index, const char* value);
2394 void set_uris(int index, const char* value, size_t size);
2395 std::string* add_uris();
2396 void add_uris(const std::string& value);
2397 void add_uris(std::string&& value);
2398 void add_uris(const char* value);
2399 void add_uris(const char* value, size_t size);
2400 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& uris() const;
2401 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_uris();
2402 private:
2403 const std::string& _internal_uris(int index) const;
2404 std::string* _internal_add_uris();
2405 public:
2406
2407 // optional string namespace = 1;
2408 bool has_namespace_() const;
2409 private:
2410 bool _internal_has_namespace_() const;
2411 public:
2412 void clear_namespace_();
2413 const std::string& namespace_() const;
2414 template <typename ArgT0 = const std::string&, typename... ArgT>
2415 void set_namespace_(ArgT0&& arg0, ArgT... args);
2416 std::string* mutable_namespace_();
2417 PROTOBUF_NODISCARD std::string* release_namespace_();
2418 void set_allocated_namespace_(std::string* namespace_);
2419 private:
2420 const std::string& _internal_namespace_() const;
2421 inline PROTOBUF_ALWAYS_INLINE void _internal_set_namespace_(const std::string& value);
2422 std::string* _internal_mutable_namespace_();
2423 public:
2424
2425 // optional string schema = 2;
2426 bool has_schema() const;
2427 private:
2428 bool _internal_has_schema() const;
2429 public:
2430 void clear_schema();
2431 const std::string& schema() const;
2432 template <typename ArgT0 = const std::string&, typename... ArgT>
2433 void set_schema(ArgT0&& arg0, ArgT... args);
2434 std::string* mutable_schema();
2435 PROTOBUF_NODISCARD std::string* release_schema();
2436 void set_allocated_schema(std::string* schema);
2437 private:
2438 const std::string& _internal_schema() const;
2439 inline PROTOBUF_ALWAYS_INLINE void _internal_set_schema(const std::string& value);
2440 std::string* _internal_mutable_schema();
2441 public:
2442
2443 // @@protoc_insertion_point(class_scope:icing.lib.DeleteByQueryResultProto.DocumentGroupInfo)
2444 private:
2445 class _Internal;
2446
2447 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
2448 typedef void InternalArenaConstructable_;
2449 typedef void DestructorSkippable_;
2450 struct Impl_ {
2451 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
2452 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2453 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> uris_;
2454 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr namespace__;
2455 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr schema_;
2456 };
2457 union { Impl_ _impl_; };
2458 friend struct ::TableStruct_icing_2fproto_2fdocument_2eproto;
2459 };
2460 // -------------------------------------------------------------------
2461
2462 class DeleteByQueryResultProto final :
2463 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:icing.lib.DeleteByQueryResultProto) */ {
2464 public:
DeleteByQueryResultProto()2465 inline DeleteByQueryResultProto() : DeleteByQueryResultProto(nullptr) {}
2466 ~DeleteByQueryResultProto() override;
2467 explicit PROTOBUF_CONSTEXPR DeleteByQueryResultProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
2468
2469 DeleteByQueryResultProto(const DeleteByQueryResultProto& from);
DeleteByQueryResultProto(DeleteByQueryResultProto && from)2470 DeleteByQueryResultProto(DeleteByQueryResultProto&& from) noexcept
2471 : DeleteByQueryResultProto() {
2472 *this = ::std::move(from);
2473 }
2474
2475 inline DeleteByQueryResultProto& operator=(const DeleteByQueryResultProto& from) {
2476 if (this == &from) return *this;
2477 CopyFrom(from);
2478 return *this;
2479 }
2480 inline DeleteByQueryResultProto& operator=(DeleteByQueryResultProto&& from) noexcept {
2481 if (this == &from) return *this;
2482 if (GetOwningArena() == from.GetOwningArena()
2483 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
2484 && GetOwningArena() != nullptr
2485 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
2486 ) {
2487 InternalSwap(&from);
2488 } else {
2489 CopyFrom(from);
2490 }
2491 return *this;
2492 }
2493
unknown_fields()2494 inline const std::string& unknown_fields() const {
2495 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
2496 }
mutable_unknown_fields()2497 inline std::string* mutable_unknown_fields() {
2498 return _internal_metadata_.mutable_unknown_fields<std::string>();
2499 }
2500
default_instance()2501 static const DeleteByQueryResultProto& default_instance() {
2502 return *internal_default_instance();
2503 }
internal_default_instance()2504 static inline const DeleteByQueryResultProto* internal_default_instance() {
2505 return reinterpret_cast<const DeleteByQueryResultProto*>(
2506 &_DeleteByQueryResultProto_default_instance_);
2507 }
2508 static constexpr int kIndexInFileMessages =
2509 12;
2510
swap(DeleteByQueryResultProto & a,DeleteByQueryResultProto & b)2511 friend void swap(DeleteByQueryResultProto& a, DeleteByQueryResultProto& b) {
2512 a.Swap(&b);
2513 }
Swap(DeleteByQueryResultProto * other)2514 inline void Swap(DeleteByQueryResultProto* other) {
2515 if (other == this) return;
2516 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
2517 if (GetOwningArena() != nullptr &&
2518 GetOwningArena() == other->GetOwningArena()) {
2519 #else // PROTOBUF_FORCE_COPY_IN_SWAP
2520 if (GetOwningArena() == other->GetOwningArena()) {
2521 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
2522 InternalSwap(other);
2523 } else {
2524 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
2525 }
2526 }
2527 void UnsafeArenaSwap(DeleteByQueryResultProto* other) {
2528 if (other == this) return;
2529 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
2530 InternalSwap(other);
2531 }
2532
2533 // implements Message ----------------------------------------------
2534
2535 DeleteByQueryResultProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
2536 return CreateMaybeMessage<DeleteByQueryResultProto>(arena);
2537 }
2538 DeleteByQueryResultProto* New() const {
2539 return New(nullptr);
2540 }
2541 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
2542 void CopyFrom(const DeleteByQueryResultProto& from);
2543 void MergeFrom(const DeleteByQueryResultProto& from);
2544 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
2545 bool IsInitialized() const final;
2546
2547 size_t ByteSizeLong() const final;
2548 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
2549 ::uint8_t* _InternalSerialize(
2550 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
2551 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
2552
2553 private:
2554 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
2555 void SharedDtor();
2556 void SetCachedSize(int size) const;
2557 void InternalSwap(DeleteByQueryResultProto* other);
2558
2559 private:
2560 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
2561 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
2562 return "icing.lib.DeleteByQueryResultProto";
2563 }
2564 protected:
2565 explicit DeleteByQueryResultProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2566 bool is_message_owned = false);
2567 public:
2568
2569 std::string GetTypeName() const final;
2570
2571 // nested types ----------------------------------------------------
2572
2573 typedef DeleteByQueryResultProto_DocumentGroupInfo DocumentGroupInfo;
2574
2575 // accessors -------------------------------------------------------
2576
2577 enum : int {
2578 kDeletedDocumentsFieldNumber = 4,
2579 kStatusFieldNumber = 1,
2580 kDeleteByQueryStatsFieldNumber = 3,
2581 };
2582 // repeated .icing.lib.DeleteByQueryResultProto.DocumentGroupInfo deleted_documents = 4;
2583 int deleted_documents_size() const;
2584 private:
2585 int _internal_deleted_documents_size() const;
2586 public:
2587 void clear_deleted_documents();
2588 ::icing::lib::DeleteByQueryResultProto_DocumentGroupInfo* mutable_deleted_documents(int index);
2589 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::DeleteByQueryResultProto_DocumentGroupInfo >*
2590 mutable_deleted_documents();
2591 private:
2592 const ::icing::lib::DeleteByQueryResultProto_DocumentGroupInfo& _internal_deleted_documents(int index) const;
2593 ::icing::lib::DeleteByQueryResultProto_DocumentGroupInfo* _internal_add_deleted_documents();
2594 public:
2595 const ::icing::lib::DeleteByQueryResultProto_DocumentGroupInfo& deleted_documents(int index) const;
2596 ::icing::lib::DeleteByQueryResultProto_DocumentGroupInfo* add_deleted_documents();
2597 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::DeleteByQueryResultProto_DocumentGroupInfo >&
2598 deleted_documents() const;
2599
2600 // optional .icing.lib.StatusProto status = 1;
2601 bool has_status() const;
2602 private:
2603 bool _internal_has_status() const;
2604 public:
2605 void clear_status();
2606 const ::icing::lib::StatusProto& status() const;
2607 PROTOBUF_NODISCARD ::icing::lib::StatusProto* release_status();
2608 ::icing::lib::StatusProto* mutable_status();
2609 void set_allocated_status(::icing::lib::StatusProto* status);
2610 private:
2611 const ::icing::lib::StatusProto& _internal_status() const;
2612 ::icing::lib::StatusProto* _internal_mutable_status();
2613 public:
2614 void unsafe_arena_set_allocated_status(
2615 ::icing::lib::StatusProto* status);
2616 ::icing::lib::StatusProto* unsafe_arena_release_status();
2617
2618 // optional .icing.lib.DeleteByQueryStatsProto delete_by_query_stats = 3;
2619 bool has_delete_by_query_stats() const;
2620 private:
2621 bool _internal_has_delete_by_query_stats() const;
2622 public:
2623 void clear_delete_by_query_stats();
2624 const ::icing::lib::DeleteByQueryStatsProto& delete_by_query_stats() const;
2625 PROTOBUF_NODISCARD ::icing::lib::DeleteByQueryStatsProto* release_delete_by_query_stats();
2626 ::icing::lib::DeleteByQueryStatsProto* mutable_delete_by_query_stats();
2627 void set_allocated_delete_by_query_stats(::icing::lib::DeleteByQueryStatsProto* delete_by_query_stats);
2628 private:
2629 const ::icing::lib::DeleteByQueryStatsProto& _internal_delete_by_query_stats() const;
2630 ::icing::lib::DeleteByQueryStatsProto* _internal_mutable_delete_by_query_stats();
2631 public:
2632 void unsafe_arena_set_allocated_delete_by_query_stats(
2633 ::icing::lib::DeleteByQueryStatsProto* delete_by_query_stats);
2634 ::icing::lib::DeleteByQueryStatsProto* unsafe_arena_release_delete_by_query_stats();
2635
2636 // @@protoc_insertion_point(class_scope:icing.lib.DeleteByQueryResultProto)
2637 private:
2638 class _Internal;
2639
2640 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
2641 typedef void InternalArenaConstructable_;
2642 typedef void DestructorSkippable_;
2643 struct Impl_ {
2644 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
2645 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2646 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::DeleteByQueryResultProto_DocumentGroupInfo > deleted_documents_;
2647 ::icing::lib::StatusProto* status_;
2648 ::icing::lib::DeleteByQueryStatsProto* delete_by_query_stats_;
2649 };
2650 union { Impl_ _impl_; };
2651 friend struct ::TableStruct_icing_2fproto_2fdocument_2eproto;
2652 };
2653 // ===================================================================
2654
2655
2656 // ===================================================================
2657
2658 #ifdef __GNUC__
2659 #pragma GCC diagnostic push
2660 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
2661 #endif // __GNUC__
2662 // DocumentProto_InternalFields
2663
2664 // optional int32 length_in_tokens = 1;
_internal_has_length_in_tokens()2665 inline bool DocumentProto_InternalFields::_internal_has_length_in_tokens() const {
2666 bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
2667 return value;
2668 }
has_length_in_tokens()2669 inline bool DocumentProto_InternalFields::has_length_in_tokens() const {
2670 return _internal_has_length_in_tokens();
2671 }
clear_length_in_tokens()2672 inline void DocumentProto_InternalFields::clear_length_in_tokens() {
2673 _impl_.length_in_tokens_ = 0;
2674 _impl_._has_bits_[0] &= ~0x00000001u;
2675 }
_internal_length_in_tokens()2676 inline ::int32_t DocumentProto_InternalFields::_internal_length_in_tokens() const {
2677 return _impl_.length_in_tokens_;
2678 }
length_in_tokens()2679 inline ::int32_t DocumentProto_InternalFields::length_in_tokens() const {
2680 // @@protoc_insertion_point(field_get:icing.lib.DocumentProto.InternalFields.length_in_tokens)
2681 return _internal_length_in_tokens();
2682 }
_internal_set_length_in_tokens(::int32_t value)2683 inline void DocumentProto_InternalFields::_internal_set_length_in_tokens(::int32_t value) {
2684 _impl_._has_bits_[0] |= 0x00000001u;
2685 _impl_.length_in_tokens_ = value;
2686 }
set_length_in_tokens(::int32_t value)2687 inline void DocumentProto_InternalFields::set_length_in_tokens(::int32_t value) {
2688 _internal_set_length_in_tokens(value);
2689 // @@protoc_insertion_point(field_set:icing.lib.DocumentProto.InternalFields.length_in_tokens)
2690 }
2691
2692 // -------------------------------------------------------------------
2693
2694 // DocumentProto
2695
2696 // optional string namespace = 1;
_internal_has_namespace_()2697 inline bool DocumentProto::_internal_has_namespace_() const {
2698 bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
2699 return value;
2700 }
has_namespace_()2701 inline bool DocumentProto::has_namespace_() const {
2702 return _internal_has_namespace_();
2703 }
clear_namespace_()2704 inline void DocumentProto::clear_namespace_() {
2705 _impl_.namespace__.ClearToEmpty();
2706 _impl_._has_bits_[0] &= ~0x00000001u;
2707 }
namespace_()2708 inline const std::string& DocumentProto::namespace_() const {
2709 // @@protoc_insertion_point(field_get:icing.lib.DocumentProto.namespace)
2710 return _internal_namespace_();
2711 }
2712 template <typename ArgT0, typename... ArgT>
2713 inline PROTOBUF_ALWAYS_INLINE
set_namespace_(ArgT0 && arg0,ArgT...args)2714 void DocumentProto::set_namespace_(ArgT0&& arg0, ArgT... args) {
2715 _impl_._has_bits_[0] |= 0x00000001u;
2716 _impl_.namespace__.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
2717 // @@protoc_insertion_point(field_set:icing.lib.DocumentProto.namespace)
2718 }
mutable_namespace_()2719 inline std::string* DocumentProto::mutable_namespace_() {
2720 std::string* _s = _internal_mutable_namespace_();
2721 // @@protoc_insertion_point(field_mutable:icing.lib.DocumentProto.namespace)
2722 return _s;
2723 }
_internal_namespace_()2724 inline const std::string& DocumentProto::_internal_namespace_() const {
2725 return _impl_.namespace__.Get();
2726 }
_internal_set_namespace_(const std::string & value)2727 inline void DocumentProto::_internal_set_namespace_(const std::string& value) {
2728 _impl_._has_bits_[0] |= 0x00000001u;
2729 _impl_.namespace__.Set(value, GetArenaForAllocation());
2730 }
_internal_mutable_namespace_()2731 inline std::string* DocumentProto::_internal_mutable_namespace_() {
2732 _impl_._has_bits_[0] |= 0x00000001u;
2733 return _impl_.namespace__.Mutable(GetArenaForAllocation());
2734 }
release_namespace_()2735 inline std::string* DocumentProto::release_namespace_() {
2736 // @@protoc_insertion_point(field_release:icing.lib.DocumentProto.namespace)
2737 if (!_internal_has_namespace_()) {
2738 return nullptr;
2739 }
2740 _impl_._has_bits_[0] &= ~0x00000001u;
2741 auto* p = _impl_.namespace__.Release();
2742 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2743 if (_impl_.namespace__.IsDefault()) {
2744 _impl_.namespace__.Set("", GetArenaForAllocation());
2745 }
2746 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2747 return p;
2748 }
set_allocated_namespace_(std::string * namespace_)2749 inline void DocumentProto::set_allocated_namespace_(std::string* namespace_) {
2750 if (namespace_ != nullptr) {
2751 _impl_._has_bits_[0] |= 0x00000001u;
2752 } else {
2753 _impl_._has_bits_[0] &= ~0x00000001u;
2754 }
2755 _impl_.namespace__.SetAllocated(namespace_, GetArenaForAllocation());
2756 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2757 if (_impl_.namespace__.IsDefault()) {
2758 _impl_.namespace__.Set("", GetArenaForAllocation());
2759 }
2760 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2761 // @@protoc_insertion_point(field_set_allocated:icing.lib.DocumentProto.namespace)
2762 }
2763
2764 // optional string uri = 2;
_internal_has_uri()2765 inline bool DocumentProto::_internal_has_uri() const {
2766 bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
2767 return value;
2768 }
has_uri()2769 inline bool DocumentProto::has_uri() const {
2770 return _internal_has_uri();
2771 }
clear_uri()2772 inline void DocumentProto::clear_uri() {
2773 _impl_.uri_.ClearToEmpty();
2774 _impl_._has_bits_[0] &= ~0x00000002u;
2775 }
uri()2776 inline const std::string& DocumentProto::uri() const {
2777 // @@protoc_insertion_point(field_get:icing.lib.DocumentProto.uri)
2778 return _internal_uri();
2779 }
2780 template <typename ArgT0, typename... ArgT>
2781 inline PROTOBUF_ALWAYS_INLINE
set_uri(ArgT0 && arg0,ArgT...args)2782 void DocumentProto::set_uri(ArgT0&& arg0, ArgT... args) {
2783 _impl_._has_bits_[0] |= 0x00000002u;
2784 _impl_.uri_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
2785 // @@protoc_insertion_point(field_set:icing.lib.DocumentProto.uri)
2786 }
mutable_uri()2787 inline std::string* DocumentProto::mutable_uri() {
2788 std::string* _s = _internal_mutable_uri();
2789 // @@protoc_insertion_point(field_mutable:icing.lib.DocumentProto.uri)
2790 return _s;
2791 }
_internal_uri()2792 inline const std::string& DocumentProto::_internal_uri() const {
2793 return _impl_.uri_.Get();
2794 }
_internal_set_uri(const std::string & value)2795 inline void DocumentProto::_internal_set_uri(const std::string& value) {
2796 _impl_._has_bits_[0] |= 0x00000002u;
2797 _impl_.uri_.Set(value, GetArenaForAllocation());
2798 }
_internal_mutable_uri()2799 inline std::string* DocumentProto::_internal_mutable_uri() {
2800 _impl_._has_bits_[0] |= 0x00000002u;
2801 return _impl_.uri_.Mutable(GetArenaForAllocation());
2802 }
release_uri()2803 inline std::string* DocumentProto::release_uri() {
2804 // @@protoc_insertion_point(field_release:icing.lib.DocumentProto.uri)
2805 if (!_internal_has_uri()) {
2806 return nullptr;
2807 }
2808 _impl_._has_bits_[0] &= ~0x00000002u;
2809 auto* p = _impl_.uri_.Release();
2810 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2811 if (_impl_.uri_.IsDefault()) {
2812 _impl_.uri_.Set("", GetArenaForAllocation());
2813 }
2814 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2815 return p;
2816 }
set_allocated_uri(std::string * uri)2817 inline void DocumentProto::set_allocated_uri(std::string* uri) {
2818 if (uri != nullptr) {
2819 _impl_._has_bits_[0] |= 0x00000002u;
2820 } else {
2821 _impl_._has_bits_[0] &= ~0x00000002u;
2822 }
2823 _impl_.uri_.SetAllocated(uri, GetArenaForAllocation());
2824 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2825 if (_impl_.uri_.IsDefault()) {
2826 _impl_.uri_.Set("", GetArenaForAllocation());
2827 }
2828 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2829 // @@protoc_insertion_point(field_set_allocated:icing.lib.DocumentProto.uri)
2830 }
2831
2832 // optional string schema = 3;
_internal_has_schema()2833 inline bool DocumentProto::_internal_has_schema() const {
2834 bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
2835 return value;
2836 }
has_schema()2837 inline bool DocumentProto::has_schema() const {
2838 return _internal_has_schema();
2839 }
clear_schema()2840 inline void DocumentProto::clear_schema() {
2841 _impl_.schema_.ClearToEmpty();
2842 _impl_._has_bits_[0] &= ~0x00000004u;
2843 }
schema()2844 inline const std::string& DocumentProto::schema() const {
2845 // @@protoc_insertion_point(field_get:icing.lib.DocumentProto.schema)
2846 return _internal_schema();
2847 }
2848 template <typename ArgT0, typename... ArgT>
2849 inline PROTOBUF_ALWAYS_INLINE
set_schema(ArgT0 && arg0,ArgT...args)2850 void DocumentProto::set_schema(ArgT0&& arg0, ArgT... args) {
2851 _impl_._has_bits_[0] |= 0x00000004u;
2852 _impl_.schema_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
2853 // @@protoc_insertion_point(field_set:icing.lib.DocumentProto.schema)
2854 }
mutable_schema()2855 inline std::string* DocumentProto::mutable_schema() {
2856 std::string* _s = _internal_mutable_schema();
2857 // @@protoc_insertion_point(field_mutable:icing.lib.DocumentProto.schema)
2858 return _s;
2859 }
_internal_schema()2860 inline const std::string& DocumentProto::_internal_schema() const {
2861 return _impl_.schema_.Get();
2862 }
_internal_set_schema(const std::string & value)2863 inline void DocumentProto::_internal_set_schema(const std::string& value) {
2864 _impl_._has_bits_[0] |= 0x00000004u;
2865 _impl_.schema_.Set(value, GetArenaForAllocation());
2866 }
_internal_mutable_schema()2867 inline std::string* DocumentProto::_internal_mutable_schema() {
2868 _impl_._has_bits_[0] |= 0x00000004u;
2869 return _impl_.schema_.Mutable(GetArenaForAllocation());
2870 }
release_schema()2871 inline std::string* DocumentProto::release_schema() {
2872 // @@protoc_insertion_point(field_release:icing.lib.DocumentProto.schema)
2873 if (!_internal_has_schema()) {
2874 return nullptr;
2875 }
2876 _impl_._has_bits_[0] &= ~0x00000004u;
2877 auto* p = _impl_.schema_.Release();
2878 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2879 if (_impl_.schema_.IsDefault()) {
2880 _impl_.schema_.Set("", GetArenaForAllocation());
2881 }
2882 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2883 return p;
2884 }
set_allocated_schema(std::string * schema)2885 inline void DocumentProto::set_allocated_schema(std::string* schema) {
2886 if (schema != nullptr) {
2887 _impl_._has_bits_[0] |= 0x00000004u;
2888 } else {
2889 _impl_._has_bits_[0] &= ~0x00000004u;
2890 }
2891 _impl_.schema_.SetAllocated(schema, GetArenaForAllocation());
2892 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2893 if (_impl_.schema_.IsDefault()) {
2894 _impl_.schema_.Set("", GetArenaForAllocation());
2895 }
2896 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2897 // @@protoc_insertion_point(field_set_allocated:icing.lib.DocumentProto.schema)
2898 }
2899
2900 // optional int64 creation_timestamp_ms = 4;
_internal_has_creation_timestamp_ms()2901 inline bool DocumentProto::_internal_has_creation_timestamp_ms() const {
2902 bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
2903 return value;
2904 }
has_creation_timestamp_ms()2905 inline bool DocumentProto::has_creation_timestamp_ms() const {
2906 return _internal_has_creation_timestamp_ms();
2907 }
clear_creation_timestamp_ms()2908 inline void DocumentProto::clear_creation_timestamp_ms() {
2909 _impl_.creation_timestamp_ms_ = ::int64_t{0};
2910 _impl_._has_bits_[0] &= ~0x00000010u;
2911 }
_internal_creation_timestamp_ms()2912 inline ::int64_t DocumentProto::_internal_creation_timestamp_ms() const {
2913 return _impl_.creation_timestamp_ms_;
2914 }
creation_timestamp_ms()2915 inline ::int64_t DocumentProto::creation_timestamp_ms() const {
2916 // @@protoc_insertion_point(field_get:icing.lib.DocumentProto.creation_timestamp_ms)
2917 return _internal_creation_timestamp_ms();
2918 }
_internal_set_creation_timestamp_ms(::int64_t value)2919 inline void DocumentProto::_internal_set_creation_timestamp_ms(::int64_t value) {
2920 _impl_._has_bits_[0] |= 0x00000010u;
2921 _impl_.creation_timestamp_ms_ = value;
2922 }
set_creation_timestamp_ms(::int64_t value)2923 inline void DocumentProto::set_creation_timestamp_ms(::int64_t value) {
2924 _internal_set_creation_timestamp_ms(value);
2925 // @@protoc_insertion_point(field_set:icing.lib.DocumentProto.creation_timestamp_ms)
2926 }
2927
2928 // repeated .icing.lib.PropertyProto properties = 5;
_internal_properties_size()2929 inline int DocumentProto::_internal_properties_size() const {
2930 return _impl_.properties_.size();
2931 }
properties_size()2932 inline int DocumentProto::properties_size() const {
2933 return _internal_properties_size();
2934 }
clear_properties()2935 inline void DocumentProto::clear_properties() {
2936 _impl_.properties_.Clear();
2937 }
mutable_properties(int index)2938 inline ::icing::lib::PropertyProto* DocumentProto::mutable_properties(int index) {
2939 // @@protoc_insertion_point(field_mutable:icing.lib.DocumentProto.properties)
2940 return _impl_.properties_.Mutable(index);
2941 }
2942 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::PropertyProto >*
mutable_properties()2943 DocumentProto::mutable_properties() {
2944 // @@protoc_insertion_point(field_mutable_list:icing.lib.DocumentProto.properties)
2945 return &_impl_.properties_;
2946 }
_internal_properties(int index)2947 inline const ::icing::lib::PropertyProto& DocumentProto::_internal_properties(int index) const {
2948 return _impl_.properties_.Get(index);
2949 }
properties(int index)2950 inline const ::icing::lib::PropertyProto& DocumentProto::properties(int index) const {
2951 // @@protoc_insertion_point(field_get:icing.lib.DocumentProto.properties)
2952 return _internal_properties(index);
2953 }
_internal_add_properties()2954 inline ::icing::lib::PropertyProto* DocumentProto::_internal_add_properties() {
2955 return _impl_.properties_.Add();
2956 }
add_properties()2957 inline ::icing::lib::PropertyProto* DocumentProto::add_properties() {
2958 ::icing::lib::PropertyProto* _add = _internal_add_properties();
2959 // @@protoc_insertion_point(field_add:icing.lib.DocumentProto.properties)
2960 return _add;
2961 }
2962 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::PropertyProto >&
properties()2963 DocumentProto::properties() const {
2964 // @@protoc_insertion_point(field_list:icing.lib.DocumentProto.properties)
2965 return _impl_.properties_;
2966 }
2967
2968 // optional int32 score = 7 [default = 0];
_internal_has_score()2969 inline bool DocumentProto::_internal_has_score() const {
2970 bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
2971 return value;
2972 }
has_score()2973 inline bool DocumentProto::has_score() const {
2974 return _internal_has_score();
2975 }
clear_score()2976 inline void DocumentProto::clear_score() {
2977 _impl_.score_ = 0;
2978 _impl_._has_bits_[0] &= ~0x00000040u;
2979 }
_internal_score()2980 inline ::int32_t DocumentProto::_internal_score() const {
2981 return _impl_.score_;
2982 }
score()2983 inline ::int32_t DocumentProto::score() const {
2984 // @@protoc_insertion_point(field_get:icing.lib.DocumentProto.score)
2985 return _internal_score();
2986 }
_internal_set_score(::int32_t value)2987 inline void DocumentProto::_internal_set_score(::int32_t value) {
2988 _impl_._has_bits_[0] |= 0x00000040u;
2989 _impl_.score_ = value;
2990 }
set_score(::int32_t value)2991 inline void DocumentProto::set_score(::int32_t value) {
2992 _internal_set_score(value);
2993 // @@protoc_insertion_point(field_set:icing.lib.DocumentProto.score)
2994 }
2995
2996 // optional int64 ttl_ms = 8 [default = 0];
_internal_has_ttl_ms()2997 inline bool DocumentProto::_internal_has_ttl_ms() const {
2998 bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
2999 return value;
3000 }
has_ttl_ms()3001 inline bool DocumentProto::has_ttl_ms() const {
3002 return _internal_has_ttl_ms();
3003 }
clear_ttl_ms()3004 inline void DocumentProto::clear_ttl_ms() {
3005 _impl_.ttl_ms_ = ::int64_t{0};
3006 _impl_._has_bits_[0] &= ~0x00000020u;
3007 }
_internal_ttl_ms()3008 inline ::int64_t DocumentProto::_internal_ttl_ms() const {
3009 return _impl_.ttl_ms_;
3010 }
ttl_ms()3011 inline ::int64_t DocumentProto::ttl_ms() const {
3012 // @@protoc_insertion_point(field_get:icing.lib.DocumentProto.ttl_ms)
3013 return _internal_ttl_ms();
3014 }
_internal_set_ttl_ms(::int64_t value)3015 inline void DocumentProto::_internal_set_ttl_ms(::int64_t value) {
3016 _impl_._has_bits_[0] |= 0x00000020u;
3017 _impl_.ttl_ms_ = value;
3018 }
set_ttl_ms(::int64_t value)3019 inline void DocumentProto::set_ttl_ms(::int64_t value) {
3020 _internal_set_ttl_ms(value);
3021 // @@protoc_insertion_point(field_set:icing.lib.DocumentProto.ttl_ms)
3022 }
3023
3024 // optional .icing.lib.DocumentProto.InternalFields internal_fields = 9;
_internal_has_internal_fields()3025 inline bool DocumentProto::_internal_has_internal_fields() const {
3026 bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
3027 PROTOBUF_ASSUME(!value || _impl_.internal_fields_ != nullptr);
3028 return value;
3029 }
has_internal_fields()3030 inline bool DocumentProto::has_internal_fields() const {
3031 return _internal_has_internal_fields();
3032 }
clear_internal_fields()3033 inline void DocumentProto::clear_internal_fields() {
3034 if (_impl_.internal_fields_ != nullptr) _impl_.internal_fields_->Clear();
3035 _impl_._has_bits_[0] &= ~0x00000008u;
3036 }
_internal_internal_fields()3037 inline const ::icing::lib::DocumentProto_InternalFields& DocumentProto::_internal_internal_fields() const {
3038 const ::icing::lib::DocumentProto_InternalFields* p = _impl_.internal_fields_;
3039 return p != nullptr ? *p : reinterpret_cast<const ::icing::lib::DocumentProto_InternalFields&>(
3040 ::icing::lib::_DocumentProto_InternalFields_default_instance_);
3041 }
internal_fields()3042 inline const ::icing::lib::DocumentProto_InternalFields& DocumentProto::internal_fields() const {
3043 // @@protoc_insertion_point(field_get:icing.lib.DocumentProto.internal_fields)
3044 return _internal_internal_fields();
3045 }
unsafe_arena_set_allocated_internal_fields(::icing::lib::DocumentProto_InternalFields * internal_fields)3046 inline void DocumentProto::unsafe_arena_set_allocated_internal_fields(
3047 ::icing::lib::DocumentProto_InternalFields* internal_fields) {
3048 if (GetArenaForAllocation() == nullptr) {
3049 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.internal_fields_);
3050 }
3051 _impl_.internal_fields_ = internal_fields;
3052 if (internal_fields) {
3053 _impl_._has_bits_[0] |= 0x00000008u;
3054 } else {
3055 _impl_._has_bits_[0] &= ~0x00000008u;
3056 }
3057 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:icing.lib.DocumentProto.internal_fields)
3058 }
release_internal_fields()3059 inline ::icing::lib::DocumentProto_InternalFields* DocumentProto::release_internal_fields() {
3060 _impl_._has_bits_[0] &= ~0x00000008u;
3061 ::icing::lib::DocumentProto_InternalFields* temp = _impl_.internal_fields_;
3062 _impl_.internal_fields_ = nullptr;
3063 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
3064 auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
3065 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
3066 if (GetArenaForAllocation() == nullptr) { delete old; }
3067 #else // PROTOBUF_FORCE_COPY_IN_RELEASE
3068 if (GetArenaForAllocation() != nullptr) {
3069 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
3070 }
3071 #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
3072 return temp;
3073 }
unsafe_arena_release_internal_fields()3074 inline ::icing::lib::DocumentProto_InternalFields* DocumentProto::unsafe_arena_release_internal_fields() {
3075 // @@protoc_insertion_point(field_release:icing.lib.DocumentProto.internal_fields)
3076 _impl_._has_bits_[0] &= ~0x00000008u;
3077 ::icing::lib::DocumentProto_InternalFields* temp = _impl_.internal_fields_;
3078 _impl_.internal_fields_ = nullptr;
3079 return temp;
3080 }
_internal_mutable_internal_fields()3081 inline ::icing::lib::DocumentProto_InternalFields* DocumentProto::_internal_mutable_internal_fields() {
3082 _impl_._has_bits_[0] |= 0x00000008u;
3083 if (_impl_.internal_fields_ == nullptr) {
3084 auto* p = CreateMaybeMessage<::icing::lib::DocumentProto_InternalFields>(GetArenaForAllocation());
3085 _impl_.internal_fields_ = p;
3086 }
3087 return _impl_.internal_fields_;
3088 }
mutable_internal_fields()3089 inline ::icing::lib::DocumentProto_InternalFields* DocumentProto::mutable_internal_fields() {
3090 ::icing::lib::DocumentProto_InternalFields* _msg = _internal_mutable_internal_fields();
3091 // @@protoc_insertion_point(field_mutable:icing.lib.DocumentProto.internal_fields)
3092 return _msg;
3093 }
set_allocated_internal_fields(::icing::lib::DocumentProto_InternalFields * internal_fields)3094 inline void DocumentProto::set_allocated_internal_fields(::icing::lib::DocumentProto_InternalFields* internal_fields) {
3095 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
3096 if (message_arena == nullptr) {
3097 delete _impl_.internal_fields_;
3098 }
3099 if (internal_fields) {
3100 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
3101 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(internal_fields);
3102 if (message_arena != submessage_arena) {
3103 internal_fields = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
3104 message_arena, internal_fields, submessage_arena);
3105 }
3106 _impl_._has_bits_[0] |= 0x00000008u;
3107 } else {
3108 _impl_._has_bits_[0] &= ~0x00000008u;
3109 }
3110 _impl_.internal_fields_ = internal_fields;
3111 // @@protoc_insertion_point(field_set_allocated:icing.lib.DocumentProto.internal_fields)
3112 }
3113
3114 // -------------------------------------------------------------------
3115
3116 // PropertyProto_VectorProto
3117
3118 // repeated float values = 1 [packed = true];
_internal_values_size()3119 inline int PropertyProto_VectorProto::_internal_values_size() const {
3120 return _impl_.values_.size();
3121 }
values_size()3122 inline int PropertyProto_VectorProto::values_size() const {
3123 return _internal_values_size();
3124 }
clear_values()3125 inline void PropertyProto_VectorProto::clear_values() {
3126 _impl_.values_.Clear();
3127 }
_internal_values(int index)3128 inline float PropertyProto_VectorProto::_internal_values(int index) const {
3129 return _impl_.values_.Get(index);
3130 }
values(int index)3131 inline float PropertyProto_VectorProto::values(int index) const {
3132 // @@protoc_insertion_point(field_get:icing.lib.PropertyProto.VectorProto.values)
3133 return _internal_values(index);
3134 }
set_values(int index,float value)3135 inline void PropertyProto_VectorProto::set_values(int index, float value) {
3136 _impl_.values_.Set(index, value);
3137 // @@protoc_insertion_point(field_set:icing.lib.PropertyProto.VectorProto.values)
3138 }
_internal_add_values(float value)3139 inline void PropertyProto_VectorProto::_internal_add_values(float value) {
3140 _impl_.values_.Add(value);
3141 }
add_values(float value)3142 inline void PropertyProto_VectorProto::add_values(float value) {
3143 _internal_add_values(value);
3144 // @@protoc_insertion_point(field_add:icing.lib.PropertyProto.VectorProto.values)
3145 }
3146 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
_internal_values()3147 PropertyProto_VectorProto::_internal_values() const {
3148 return _impl_.values_;
3149 }
3150 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
values()3151 PropertyProto_VectorProto::values() const {
3152 // @@protoc_insertion_point(field_list:icing.lib.PropertyProto.VectorProto.values)
3153 return _internal_values();
3154 }
3155 inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
_internal_mutable_values()3156 PropertyProto_VectorProto::_internal_mutable_values() {
3157 return &_impl_.values_;
3158 }
3159 inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
mutable_values()3160 PropertyProto_VectorProto::mutable_values() {
3161 // @@protoc_insertion_point(field_mutable_list:icing.lib.PropertyProto.VectorProto.values)
3162 return _internal_mutable_values();
3163 }
3164
3165 // optional string model_signature = 2;
_internal_has_model_signature()3166 inline bool PropertyProto_VectorProto::_internal_has_model_signature() const {
3167 bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
3168 return value;
3169 }
has_model_signature()3170 inline bool PropertyProto_VectorProto::has_model_signature() const {
3171 return _internal_has_model_signature();
3172 }
clear_model_signature()3173 inline void PropertyProto_VectorProto::clear_model_signature() {
3174 _impl_.model_signature_.ClearToEmpty();
3175 _impl_._has_bits_[0] &= ~0x00000001u;
3176 }
model_signature()3177 inline const std::string& PropertyProto_VectorProto::model_signature() const {
3178 // @@protoc_insertion_point(field_get:icing.lib.PropertyProto.VectorProto.model_signature)
3179 return _internal_model_signature();
3180 }
3181 template <typename ArgT0, typename... ArgT>
3182 inline PROTOBUF_ALWAYS_INLINE
set_model_signature(ArgT0 && arg0,ArgT...args)3183 void PropertyProto_VectorProto::set_model_signature(ArgT0&& arg0, ArgT... args) {
3184 _impl_._has_bits_[0] |= 0x00000001u;
3185 _impl_.model_signature_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
3186 // @@protoc_insertion_point(field_set:icing.lib.PropertyProto.VectorProto.model_signature)
3187 }
mutable_model_signature()3188 inline std::string* PropertyProto_VectorProto::mutable_model_signature() {
3189 std::string* _s = _internal_mutable_model_signature();
3190 // @@protoc_insertion_point(field_mutable:icing.lib.PropertyProto.VectorProto.model_signature)
3191 return _s;
3192 }
_internal_model_signature()3193 inline const std::string& PropertyProto_VectorProto::_internal_model_signature() const {
3194 return _impl_.model_signature_.Get();
3195 }
_internal_set_model_signature(const std::string & value)3196 inline void PropertyProto_VectorProto::_internal_set_model_signature(const std::string& value) {
3197 _impl_._has_bits_[0] |= 0x00000001u;
3198 _impl_.model_signature_.Set(value, GetArenaForAllocation());
3199 }
_internal_mutable_model_signature()3200 inline std::string* PropertyProto_VectorProto::_internal_mutable_model_signature() {
3201 _impl_._has_bits_[0] |= 0x00000001u;
3202 return _impl_.model_signature_.Mutable(GetArenaForAllocation());
3203 }
release_model_signature()3204 inline std::string* PropertyProto_VectorProto::release_model_signature() {
3205 // @@protoc_insertion_point(field_release:icing.lib.PropertyProto.VectorProto.model_signature)
3206 if (!_internal_has_model_signature()) {
3207 return nullptr;
3208 }
3209 _impl_._has_bits_[0] &= ~0x00000001u;
3210 auto* p = _impl_.model_signature_.Release();
3211 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3212 if (_impl_.model_signature_.IsDefault()) {
3213 _impl_.model_signature_.Set("", GetArenaForAllocation());
3214 }
3215 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3216 return p;
3217 }
set_allocated_model_signature(std::string * model_signature)3218 inline void PropertyProto_VectorProto::set_allocated_model_signature(std::string* model_signature) {
3219 if (model_signature != nullptr) {
3220 _impl_._has_bits_[0] |= 0x00000001u;
3221 } else {
3222 _impl_._has_bits_[0] &= ~0x00000001u;
3223 }
3224 _impl_.model_signature_.SetAllocated(model_signature, GetArenaForAllocation());
3225 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3226 if (_impl_.model_signature_.IsDefault()) {
3227 _impl_.model_signature_.Set("", GetArenaForAllocation());
3228 }
3229 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3230 // @@protoc_insertion_point(field_set_allocated:icing.lib.PropertyProto.VectorProto.model_signature)
3231 }
3232
3233 // -------------------------------------------------------------------
3234
3235 // PropertyProto_BlobHandleProto
3236
3237 // optional bytes digest = 1;
_internal_has_digest()3238 inline bool PropertyProto_BlobHandleProto::_internal_has_digest() const {
3239 bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
3240 return value;
3241 }
has_digest()3242 inline bool PropertyProto_BlobHandleProto::has_digest() const {
3243 return _internal_has_digest();
3244 }
clear_digest()3245 inline void PropertyProto_BlobHandleProto::clear_digest() {
3246 _impl_.digest_.ClearToEmpty();
3247 _impl_._has_bits_[0] &= ~0x00000001u;
3248 }
digest()3249 inline const std::string& PropertyProto_BlobHandleProto::digest() const {
3250 // @@protoc_insertion_point(field_get:icing.lib.PropertyProto.BlobHandleProto.digest)
3251 return _internal_digest();
3252 }
3253 template <typename ArgT0, typename... ArgT>
3254 inline PROTOBUF_ALWAYS_INLINE
set_digest(ArgT0 && arg0,ArgT...args)3255 void PropertyProto_BlobHandleProto::set_digest(ArgT0&& arg0, ArgT... args) {
3256 _impl_._has_bits_[0] |= 0x00000001u;
3257 _impl_.digest_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
3258 // @@protoc_insertion_point(field_set:icing.lib.PropertyProto.BlobHandleProto.digest)
3259 }
mutable_digest()3260 inline std::string* PropertyProto_BlobHandleProto::mutable_digest() {
3261 std::string* _s = _internal_mutable_digest();
3262 // @@protoc_insertion_point(field_mutable:icing.lib.PropertyProto.BlobHandleProto.digest)
3263 return _s;
3264 }
_internal_digest()3265 inline const std::string& PropertyProto_BlobHandleProto::_internal_digest() const {
3266 return _impl_.digest_.Get();
3267 }
_internal_set_digest(const std::string & value)3268 inline void PropertyProto_BlobHandleProto::_internal_set_digest(const std::string& value) {
3269 _impl_._has_bits_[0] |= 0x00000001u;
3270 _impl_.digest_.Set(value, GetArenaForAllocation());
3271 }
_internal_mutable_digest()3272 inline std::string* PropertyProto_BlobHandleProto::_internal_mutable_digest() {
3273 _impl_._has_bits_[0] |= 0x00000001u;
3274 return _impl_.digest_.Mutable(GetArenaForAllocation());
3275 }
release_digest()3276 inline std::string* PropertyProto_BlobHandleProto::release_digest() {
3277 // @@protoc_insertion_point(field_release:icing.lib.PropertyProto.BlobHandleProto.digest)
3278 if (!_internal_has_digest()) {
3279 return nullptr;
3280 }
3281 _impl_._has_bits_[0] &= ~0x00000001u;
3282 auto* p = _impl_.digest_.Release();
3283 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3284 if (_impl_.digest_.IsDefault()) {
3285 _impl_.digest_.Set("", GetArenaForAllocation());
3286 }
3287 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3288 return p;
3289 }
set_allocated_digest(std::string * digest)3290 inline void PropertyProto_BlobHandleProto::set_allocated_digest(std::string* digest) {
3291 if (digest != nullptr) {
3292 _impl_._has_bits_[0] |= 0x00000001u;
3293 } else {
3294 _impl_._has_bits_[0] &= ~0x00000001u;
3295 }
3296 _impl_.digest_.SetAllocated(digest, GetArenaForAllocation());
3297 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3298 if (_impl_.digest_.IsDefault()) {
3299 _impl_.digest_.Set("", GetArenaForAllocation());
3300 }
3301 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3302 // @@protoc_insertion_point(field_set_allocated:icing.lib.PropertyProto.BlobHandleProto.digest)
3303 }
3304
3305 // optional string namespace = 3;
_internal_has_namespace_()3306 inline bool PropertyProto_BlobHandleProto::_internal_has_namespace_() const {
3307 bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
3308 return value;
3309 }
has_namespace_()3310 inline bool PropertyProto_BlobHandleProto::has_namespace_() const {
3311 return _internal_has_namespace_();
3312 }
clear_namespace_()3313 inline void PropertyProto_BlobHandleProto::clear_namespace_() {
3314 _impl_.namespace__.ClearToEmpty();
3315 _impl_._has_bits_[0] &= ~0x00000002u;
3316 }
namespace_()3317 inline const std::string& PropertyProto_BlobHandleProto::namespace_() const {
3318 // @@protoc_insertion_point(field_get:icing.lib.PropertyProto.BlobHandleProto.namespace)
3319 return _internal_namespace_();
3320 }
3321 template <typename ArgT0, typename... ArgT>
3322 inline PROTOBUF_ALWAYS_INLINE
set_namespace_(ArgT0 && arg0,ArgT...args)3323 void PropertyProto_BlobHandleProto::set_namespace_(ArgT0&& arg0, ArgT... args) {
3324 _impl_._has_bits_[0] |= 0x00000002u;
3325 _impl_.namespace__.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
3326 // @@protoc_insertion_point(field_set:icing.lib.PropertyProto.BlobHandleProto.namespace)
3327 }
mutable_namespace_()3328 inline std::string* PropertyProto_BlobHandleProto::mutable_namespace_() {
3329 std::string* _s = _internal_mutable_namespace_();
3330 // @@protoc_insertion_point(field_mutable:icing.lib.PropertyProto.BlobHandleProto.namespace)
3331 return _s;
3332 }
_internal_namespace_()3333 inline const std::string& PropertyProto_BlobHandleProto::_internal_namespace_() const {
3334 return _impl_.namespace__.Get();
3335 }
_internal_set_namespace_(const std::string & value)3336 inline void PropertyProto_BlobHandleProto::_internal_set_namespace_(const std::string& value) {
3337 _impl_._has_bits_[0] |= 0x00000002u;
3338 _impl_.namespace__.Set(value, GetArenaForAllocation());
3339 }
_internal_mutable_namespace_()3340 inline std::string* PropertyProto_BlobHandleProto::_internal_mutable_namespace_() {
3341 _impl_._has_bits_[0] |= 0x00000002u;
3342 return _impl_.namespace__.Mutable(GetArenaForAllocation());
3343 }
release_namespace_()3344 inline std::string* PropertyProto_BlobHandleProto::release_namespace_() {
3345 // @@protoc_insertion_point(field_release:icing.lib.PropertyProto.BlobHandleProto.namespace)
3346 if (!_internal_has_namespace_()) {
3347 return nullptr;
3348 }
3349 _impl_._has_bits_[0] &= ~0x00000002u;
3350 auto* p = _impl_.namespace__.Release();
3351 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3352 if (_impl_.namespace__.IsDefault()) {
3353 _impl_.namespace__.Set("", GetArenaForAllocation());
3354 }
3355 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3356 return p;
3357 }
set_allocated_namespace_(std::string * namespace_)3358 inline void PropertyProto_BlobHandleProto::set_allocated_namespace_(std::string* namespace_) {
3359 if (namespace_ != nullptr) {
3360 _impl_._has_bits_[0] |= 0x00000002u;
3361 } else {
3362 _impl_._has_bits_[0] &= ~0x00000002u;
3363 }
3364 _impl_.namespace__.SetAllocated(namespace_, GetArenaForAllocation());
3365 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3366 if (_impl_.namespace__.IsDefault()) {
3367 _impl_.namespace__.Set("", GetArenaForAllocation());
3368 }
3369 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3370 // @@protoc_insertion_point(field_set_allocated:icing.lib.PropertyProto.BlobHandleProto.namespace)
3371 }
3372
3373 // -------------------------------------------------------------------
3374
3375 // PropertyProto
3376
3377 // optional string name = 1;
_internal_has_name()3378 inline bool PropertyProto::_internal_has_name() const {
3379 bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
3380 return value;
3381 }
has_name()3382 inline bool PropertyProto::has_name() const {
3383 return _internal_has_name();
3384 }
clear_name()3385 inline void PropertyProto::clear_name() {
3386 _impl_.name_.ClearToEmpty();
3387 _impl_._has_bits_[0] &= ~0x00000001u;
3388 }
name()3389 inline const std::string& PropertyProto::name() const {
3390 // @@protoc_insertion_point(field_get:icing.lib.PropertyProto.name)
3391 return _internal_name();
3392 }
3393 template <typename ArgT0, typename... ArgT>
3394 inline PROTOBUF_ALWAYS_INLINE
set_name(ArgT0 && arg0,ArgT...args)3395 void PropertyProto::set_name(ArgT0&& arg0, ArgT... args) {
3396 _impl_._has_bits_[0] |= 0x00000001u;
3397 _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
3398 // @@protoc_insertion_point(field_set:icing.lib.PropertyProto.name)
3399 }
mutable_name()3400 inline std::string* PropertyProto::mutable_name() {
3401 std::string* _s = _internal_mutable_name();
3402 // @@protoc_insertion_point(field_mutable:icing.lib.PropertyProto.name)
3403 return _s;
3404 }
_internal_name()3405 inline const std::string& PropertyProto::_internal_name() const {
3406 return _impl_.name_.Get();
3407 }
_internal_set_name(const std::string & value)3408 inline void PropertyProto::_internal_set_name(const std::string& value) {
3409 _impl_._has_bits_[0] |= 0x00000001u;
3410 _impl_.name_.Set(value, GetArenaForAllocation());
3411 }
_internal_mutable_name()3412 inline std::string* PropertyProto::_internal_mutable_name() {
3413 _impl_._has_bits_[0] |= 0x00000001u;
3414 return _impl_.name_.Mutable(GetArenaForAllocation());
3415 }
release_name()3416 inline std::string* PropertyProto::release_name() {
3417 // @@protoc_insertion_point(field_release:icing.lib.PropertyProto.name)
3418 if (!_internal_has_name()) {
3419 return nullptr;
3420 }
3421 _impl_._has_bits_[0] &= ~0x00000001u;
3422 auto* p = _impl_.name_.Release();
3423 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3424 if (_impl_.name_.IsDefault()) {
3425 _impl_.name_.Set("", GetArenaForAllocation());
3426 }
3427 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3428 return p;
3429 }
set_allocated_name(std::string * name)3430 inline void PropertyProto::set_allocated_name(std::string* name) {
3431 if (name != nullptr) {
3432 _impl_._has_bits_[0] |= 0x00000001u;
3433 } else {
3434 _impl_._has_bits_[0] &= ~0x00000001u;
3435 }
3436 _impl_.name_.SetAllocated(name, GetArenaForAllocation());
3437 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3438 if (_impl_.name_.IsDefault()) {
3439 _impl_.name_.Set("", GetArenaForAllocation());
3440 }
3441 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3442 // @@protoc_insertion_point(field_set_allocated:icing.lib.PropertyProto.name)
3443 }
3444
3445 // repeated string string_values = 2;
_internal_string_values_size()3446 inline int PropertyProto::_internal_string_values_size() const {
3447 return _impl_.string_values_.size();
3448 }
string_values_size()3449 inline int PropertyProto::string_values_size() const {
3450 return _internal_string_values_size();
3451 }
clear_string_values()3452 inline void PropertyProto::clear_string_values() {
3453 _impl_.string_values_.Clear();
3454 }
add_string_values()3455 inline std::string* PropertyProto::add_string_values() {
3456 std::string* _s = _internal_add_string_values();
3457 // @@protoc_insertion_point(field_add_mutable:icing.lib.PropertyProto.string_values)
3458 return _s;
3459 }
_internal_string_values(int index)3460 inline const std::string& PropertyProto::_internal_string_values(int index) const {
3461 return _impl_.string_values_.Get(index);
3462 }
string_values(int index)3463 inline const std::string& PropertyProto::string_values(int index) const {
3464 // @@protoc_insertion_point(field_get:icing.lib.PropertyProto.string_values)
3465 return _internal_string_values(index);
3466 }
mutable_string_values(int index)3467 inline std::string* PropertyProto::mutable_string_values(int index) {
3468 // @@protoc_insertion_point(field_mutable:icing.lib.PropertyProto.string_values)
3469 return _impl_.string_values_.Mutable(index);
3470 }
set_string_values(int index,const std::string & value)3471 inline void PropertyProto::set_string_values(int index, const std::string& value) {
3472 _impl_.string_values_.Mutable(index)->assign(value);
3473 // @@protoc_insertion_point(field_set:icing.lib.PropertyProto.string_values)
3474 }
set_string_values(int index,std::string && value)3475 inline void PropertyProto::set_string_values(int index, std::string&& value) {
3476 _impl_.string_values_.Mutable(index)->assign(std::move(value));
3477 // @@protoc_insertion_point(field_set:icing.lib.PropertyProto.string_values)
3478 }
set_string_values(int index,const char * value)3479 inline void PropertyProto::set_string_values(int index, const char* value) {
3480 GOOGLE_DCHECK(value != nullptr);
3481 _impl_.string_values_.Mutable(index)->assign(value);
3482 // @@protoc_insertion_point(field_set_char:icing.lib.PropertyProto.string_values)
3483 }
set_string_values(int index,const char * value,size_t size)3484 inline void PropertyProto::set_string_values(int index, const char* value, size_t size) {
3485 _impl_.string_values_.Mutable(index)->assign(
3486 reinterpret_cast<const char*>(value), size);
3487 // @@protoc_insertion_point(field_set_pointer:icing.lib.PropertyProto.string_values)
3488 }
_internal_add_string_values()3489 inline std::string* PropertyProto::_internal_add_string_values() {
3490 return _impl_.string_values_.Add();
3491 }
add_string_values(const std::string & value)3492 inline void PropertyProto::add_string_values(const std::string& value) {
3493 _impl_.string_values_.Add()->assign(value);
3494 // @@protoc_insertion_point(field_add:icing.lib.PropertyProto.string_values)
3495 }
add_string_values(std::string && value)3496 inline void PropertyProto::add_string_values(std::string&& value) {
3497 _impl_.string_values_.Add(std::move(value));
3498 // @@protoc_insertion_point(field_add:icing.lib.PropertyProto.string_values)
3499 }
add_string_values(const char * value)3500 inline void PropertyProto::add_string_values(const char* value) {
3501 GOOGLE_DCHECK(value != nullptr);
3502 _impl_.string_values_.Add()->assign(value);
3503 // @@protoc_insertion_point(field_add_char:icing.lib.PropertyProto.string_values)
3504 }
add_string_values(const char * value,size_t size)3505 inline void PropertyProto::add_string_values(const char* value, size_t size) {
3506 _impl_.string_values_.Add()->assign(reinterpret_cast<const char*>(value), size);
3507 // @@protoc_insertion_point(field_add_pointer:icing.lib.PropertyProto.string_values)
3508 }
3509 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
string_values()3510 PropertyProto::string_values() const {
3511 // @@protoc_insertion_point(field_list:icing.lib.PropertyProto.string_values)
3512 return _impl_.string_values_;
3513 }
3514 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
mutable_string_values()3515 PropertyProto::mutable_string_values() {
3516 // @@protoc_insertion_point(field_mutable_list:icing.lib.PropertyProto.string_values)
3517 return &_impl_.string_values_;
3518 }
3519
3520 // repeated int64 int64_values = 3;
_internal_int64_values_size()3521 inline int PropertyProto::_internal_int64_values_size() const {
3522 return _impl_.int64_values_.size();
3523 }
int64_values_size()3524 inline int PropertyProto::int64_values_size() const {
3525 return _internal_int64_values_size();
3526 }
clear_int64_values()3527 inline void PropertyProto::clear_int64_values() {
3528 _impl_.int64_values_.Clear();
3529 }
_internal_int64_values(int index)3530 inline ::int64_t PropertyProto::_internal_int64_values(int index) const {
3531 return _impl_.int64_values_.Get(index);
3532 }
int64_values(int index)3533 inline ::int64_t PropertyProto::int64_values(int index) const {
3534 // @@protoc_insertion_point(field_get:icing.lib.PropertyProto.int64_values)
3535 return _internal_int64_values(index);
3536 }
set_int64_values(int index,::int64_t value)3537 inline void PropertyProto::set_int64_values(int index, ::int64_t value) {
3538 _impl_.int64_values_.Set(index, value);
3539 // @@protoc_insertion_point(field_set:icing.lib.PropertyProto.int64_values)
3540 }
_internal_add_int64_values(::int64_t value)3541 inline void PropertyProto::_internal_add_int64_values(::int64_t value) {
3542 _impl_.int64_values_.Add(value);
3543 }
add_int64_values(::int64_t value)3544 inline void PropertyProto::add_int64_values(::int64_t value) {
3545 _internal_add_int64_values(value);
3546 // @@protoc_insertion_point(field_add:icing.lib.PropertyProto.int64_values)
3547 }
3548 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int64_t >&
_internal_int64_values()3549 PropertyProto::_internal_int64_values() const {
3550 return _impl_.int64_values_;
3551 }
3552 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int64_t >&
int64_values()3553 PropertyProto::int64_values() const {
3554 // @@protoc_insertion_point(field_list:icing.lib.PropertyProto.int64_values)
3555 return _internal_int64_values();
3556 }
3557 inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int64_t >*
_internal_mutable_int64_values()3558 PropertyProto::_internal_mutable_int64_values() {
3559 return &_impl_.int64_values_;
3560 }
3561 inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int64_t >*
mutable_int64_values()3562 PropertyProto::mutable_int64_values() {
3563 // @@protoc_insertion_point(field_mutable_list:icing.lib.PropertyProto.int64_values)
3564 return _internal_mutable_int64_values();
3565 }
3566
3567 // repeated double double_values = 4;
_internal_double_values_size()3568 inline int PropertyProto::_internal_double_values_size() const {
3569 return _impl_.double_values_.size();
3570 }
double_values_size()3571 inline int PropertyProto::double_values_size() const {
3572 return _internal_double_values_size();
3573 }
clear_double_values()3574 inline void PropertyProto::clear_double_values() {
3575 _impl_.double_values_.Clear();
3576 }
_internal_double_values(int index)3577 inline double PropertyProto::_internal_double_values(int index) const {
3578 return _impl_.double_values_.Get(index);
3579 }
double_values(int index)3580 inline double PropertyProto::double_values(int index) const {
3581 // @@protoc_insertion_point(field_get:icing.lib.PropertyProto.double_values)
3582 return _internal_double_values(index);
3583 }
set_double_values(int index,double value)3584 inline void PropertyProto::set_double_values(int index, double value) {
3585 _impl_.double_values_.Set(index, value);
3586 // @@protoc_insertion_point(field_set:icing.lib.PropertyProto.double_values)
3587 }
_internal_add_double_values(double value)3588 inline void PropertyProto::_internal_add_double_values(double value) {
3589 _impl_.double_values_.Add(value);
3590 }
add_double_values(double value)3591 inline void PropertyProto::add_double_values(double value) {
3592 _internal_add_double_values(value);
3593 // @@protoc_insertion_point(field_add:icing.lib.PropertyProto.double_values)
3594 }
3595 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
_internal_double_values()3596 PropertyProto::_internal_double_values() const {
3597 return _impl_.double_values_;
3598 }
3599 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
double_values()3600 PropertyProto::double_values() const {
3601 // @@protoc_insertion_point(field_list:icing.lib.PropertyProto.double_values)
3602 return _internal_double_values();
3603 }
3604 inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
_internal_mutable_double_values()3605 PropertyProto::_internal_mutable_double_values() {
3606 return &_impl_.double_values_;
3607 }
3608 inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
mutable_double_values()3609 PropertyProto::mutable_double_values() {
3610 // @@protoc_insertion_point(field_mutable_list:icing.lib.PropertyProto.double_values)
3611 return _internal_mutable_double_values();
3612 }
3613
3614 // repeated bool boolean_values = 5;
_internal_boolean_values_size()3615 inline int PropertyProto::_internal_boolean_values_size() const {
3616 return _impl_.boolean_values_.size();
3617 }
boolean_values_size()3618 inline int PropertyProto::boolean_values_size() const {
3619 return _internal_boolean_values_size();
3620 }
clear_boolean_values()3621 inline void PropertyProto::clear_boolean_values() {
3622 _impl_.boolean_values_.Clear();
3623 }
_internal_boolean_values(int index)3624 inline bool PropertyProto::_internal_boolean_values(int index) const {
3625 return _impl_.boolean_values_.Get(index);
3626 }
boolean_values(int index)3627 inline bool PropertyProto::boolean_values(int index) const {
3628 // @@protoc_insertion_point(field_get:icing.lib.PropertyProto.boolean_values)
3629 return _internal_boolean_values(index);
3630 }
set_boolean_values(int index,bool value)3631 inline void PropertyProto::set_boolean_values(int index, bool value) {
3632 _impl_.boolean_values_.Set(index, value);
3633 // @@protoc_insertion_point(field_set:icing.lib.PropertyProto.boolean_values)
3634 }
_internal_add_boolean_values(bool value)3635 inline void PropertyProto::_internal_add_boolean_values(bool value) {
3636 _impl_.boolean_values_.Add(value);
3637 }
add_boolean_values(bool value)3638 inline void PropertyProto::add_boolean_values(bool value) {
3639 _internal_add_boolean_values(value);
3640 // @@protoc_insertion_point(field_add:icing.lib.PropertyProto.boolean_values)
3641 }
3642 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >&
_internal_boolean_values()3643 PropertyProto::_internal_boolean_values() const {
3644 return _impl_.boolean_values_;
3645 }
3646 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >&
boolean_values()3647 PropertyProto::boolean_values() const {
3648 // @@protoc_insertion_point(field_list:icing.lib.PropertyProto.boolean_values)
3649 return _internal_boolean_values();
3650 }
3651 inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >*
_internal_mutable_boolean_values()3652 PropertyProto::_internal_mutable_boolean_values() {
3653 return &_impl_.boolean_values_;
3654 }
3655 inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >*
mutable_boolean_values()3656 PropertyProto::mutable_boolean_values() {
3657 // @@protoc_insertion_point(field_mutable_list:icing.lib.PropertyProto.boolean_values)
3658 return _internal_mutable_boolean_values();
3659 }
3660
3661 // repeated bytes bytes_values = 6;
_internal_bytes_values_size()3662 inline int PropertyProto::_internal_bytes_values_size() const {
3663 return _impl_.bytes_values_.size();
3664 }
bytes_values_size()3665 inline int PropertyProto::bytes_values_size() const {
3666 return _internal_bytes_values_size();
3667 }
clear_bytes_values()3668 inline void PropertyProto::clear_bytes_values() {
3669 _impl_.bytes_values_.Clear();
3670 }
add_bytes_values()3671 inline std::string* PropertyProto::add_bytes_values() {
3672 std::string* _s = _internal_add_bytes_values();
3673 // @@protoc_insertion_point(field_add_mutable:icing.lib.PropertyProto.bytes_values)
3674 return _s;
3675 }
_internal_bytes_values(int index)3676 inline const std::string& PropertyProto::_internal_bytes_values(int index) const {
3677 return _impl_.bytes_values_.Get(index);
3678 }
bytes_values(int index)3679 inline const std::string& PropertyProto::bytes_values(int index) const {
3680 // @@protoc_insertion_point(field_get:icing.lib.PropertyProto.bytes_values)
3681 return _internal_bytes_values(index);
3682 }
mutable_bytes_values(int index)3683 inline std::string* PropertyProto::mutable_bytes_values(int index) {
3684 // @@protoc_insertion_point(field_mutable:icing.lib.PropertyProto.bytes_values)
3685 return _impl_.bytes_values_.Mutable(index);
3686 }
set_bytes_values(int index,const std::string & value)3687 inline void PropertyProto::set_bytes_values(int index, const std::string& value) {
3688 _impl_.bytes_values_.Mutable(index)->assign(value);
3689 // @@protoc_insertion_point(field_set:icing.lib.PropertyProto.bytes_values)
3690 }
set_bytes_values(int index,std::string && value)3691 inline void PropertyProto::set_bytes_values(int index, std::string&& value) {
3692 _impl_.bytes_values_.Mutable(index)->assign(std::move(value));
3693 // @@protoc_insertion_point(field_set:icing.lib.PropertyProto.bytes_values)
3694 }
set_bytes_values(int index,const char * value)3695 inline void PropertyProto::set_bytes_values(int index, const char* value) {
3696 GOOGLE_DCHECK(value != nullptr);
3697 _impl_.bytes_values_.Mutable(index)->assign(value);
3698 // @@protoc_insertion_point(field_set_char:icing.lib.PropertyProto.bytes_values)
3699 }
set_bytes_values(int index,const void * value,size_t size)3700 inline void PropertyProto::set_bytes_values(int index, const void* value, size_t size) {
3701 _impl_.bytes_values_.Mutable(index)->assign(
3702 reinterpret_cast<const char*>(value), size);
3703 // @@protoc_insertion_point(field_set_pointer:icing.lib.PropertyProto.bytes_values)
3704 }
_internal_add_bytes_values()3705 inline std::string* PropertyProto::_internal_add_bytes_values() {
3706 return _impl_.bytes_values_.Add();
3707 }
add_bytes_values(const std::string & value)3708 inline void PropertyProto::add_bytes_values(const std::string& value) {
3709 _impl_.bytes_values_.Add()->assign(value);
3710 // @@protoc_insertion_point(field_add:icing.lib.PropertyProto.bytes_values)
3711 }
add_bytes_values(std::string && value)3712 inline void PropertyProto::add_bytes_values(std::string&& value) {
3713 _impl_.bytes_values_.Add(std::move(value));
3714 // @@protoc_insertion_point(field_add:icing.lib.PropertyProto.bytes_values)
3715 }
add_bytes_values(const char * value)3716 inline void PropertyProto::add_bytes_values(const char* value) {
3717 GOOGLE_DCHECK(value != nullptr);
3718 _impl_.bytes_values_.Add()->assign(value);
3719 // @@protoc_insertion_point(field_add_char:icing.lib.PropertyProto.bytes_values)
3720 }
add_bytes_values(const void * value,size_t size)3721 inline void PropertyProto::add_bytes_values(const void* value, size_t size) {
3722 _impl_.bytes_values_.Add()->assign(reinterpret_cast<const char*>(value), size);
3723 // @@protoc_insertion_point(field_add_pointer:icing.lib.PropertyProto.bytes_values)
3724 }
3725 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
bytes_values()3726 PropertyProto::bytes_values() const {
3727 // @@protoc_insertion_point(field_list:icing.lib.PropertyProto.bytes_values)
3728 return _impl_.bytes_values_;
3729 }
3730 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
mutable_bytes_values()3731 PropertyProto::mutable_bytes_values() {
3732 // @@protoc_insertion_point(field_mutable_list:icing.lib.PropertyProto.bytes_values)
3733 return &_impl_.bytes_values_;
3734 }
3735
3736 // repeated .icing.lib.DocumentProto document_values = 7;
_internal_document_values_size()3737 inline int PropertyProto::_internal_document_values_size() const {
3738 return _impl_.document_values_.size();
3739 }
document_values_size()3740 inline int PropertyProto::document_values_size() const {
3741 return _internal_document_values_size();
3742 }
clear_document_values()3743 inline void PropertyProto::clear_document_values() {
3744 _impl_.document_values_.Clear();
3745 }
mutable_document_values(int index)3746 inline ::icing::lib::DocumentProto* PropertyProto::mutable_document_values(int index) {
3747 // @@protoc_insertion_point(field_mutable:icing.lib.PropertyProto.document_values)
3748 return _impl_.document_values_.Mutable(index);
3749 }
3750 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::DocumentProto >*
mutable_document_values()3751 PropertyProto::mutable_document_values() {
3752 // @@protoc_insertion_point(field_mutable_list:icing.lib.PropertyProto.document_values)
3753 return &_impl_.document_values_;
3754 }
_internal_document_values(int index)3755 inline const ::icing::lib::DocumentProto& PropertyProto::_internal_document_values(int index) const {
3756 return _impl_.document_values_.Get(index);
3757 }
document_values(int index)3758 inline const ::icing::lib::DocumentProto& PropertyProto::document_values(int index) const {
3759 // @@protoc_insertion_point(field_get:icing.lib.PropertyProto.document_values)
3760 return _internal_document_values(index);
3761 }
_internal_add_document_values()3762 inline ::icing::lib::DocumentProto* PropertyProto::_internal_add_document_values() {
3763 return _impl_.document_values_.Add();
3764 }
add_document_values()3765 inline ::icing::lib::DocumentProto* PropertyProto::add_document_values() {
3766 ::icing::lib::DocumentProto* _add = _internal_add_document_values();
3767 // @@protoc_insertion_point(field_add:icing.lib.PropertyProto.document_values)
3768 return _add;
3769 }
3770 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::DocumentProto >&
document_values()3771 PropertyProto::document_values() const {
3772 // @@protoc_insertion_point(field_list:icing.lib.PropertyProto.document_values)
3773 return _impl_.document_values_;
3774 }
3775
3776 // repeated .icing.lib.PropertyProto.VectorProto vector_values = 8;
_internal_vector_values_size()3777 inline int PropertyProto::_internal_vector_values_size() const {
3778 return _impl_.vector_values_.size();
3779 }
vector_values_size()3780 inline int PropertyProto::vector_values_size() const {
3781 return _internal_vector_values_size();
3782 }
clear_vector_values()3783 inline void PropertyProto::clear_vector_values() {
3784 _impl_.vector_values_.Clear();
3785 }
mutable_vector_values(int index)3786 inline ::icing::lib::PropertyProto_VectorProto* PropertyProto::mutable_vector_values(int index) {
3787 // @@protoc_insertion_point(field_mutable:icing.lib.PropertyProto.vector_values)
3788 return _impl_.vector_values_.Mutable(index);
3789 }
3790 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::PropertyProto_VectorProto >*
mutable_vector_values()3791 PropertyProto::mutable_vector_values() {
3792 // @@protoc_insertion_point(field_mutable_list:icing.lib.PropertyProto.vector_values)
3793 return &_impl_.vector_values_;
3794 }
_internal_vector_values(int index)3795 inline const ::icing::lib::PropertyProto_VectorProto& PropertyProto::_internal_vector_values(int index) const {
3796 return _impl_.vector_values_.Get(index);
3797 }
vector_values(int index)3798 inline const ::icing::lib::PropertyProto_VectorProto& PropertyProto::vector_values(int index) const {
3799 // @@protoc_insertion_point(field_get:icing.lib.PropertyProto.vector_values)
3800 return _internal_vector_values(index);
3801 }
_internal_add_vector_values()3802 inline ::icing::lib::PropertyProto_VectorProto* PropertyProto::_internal_add_vector_values() {
3803 return _impl_.vector_values_.Add();
3804 }
add_vector_values()3805 inline ::icing::lib::PropertyProto_VectorProto* PropertyProto::add_vector_values() {
3806 ::icing::lib::PropertyProto_VectorProto* _add = _internal_add_vector_values();
3807 // @@protoc_insertion_point(field_add:icing.lib.PropertyProto.vector_values)
3808 return _add;
3809 }
3810 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::PropertyProto_VectorProto >&
vector_values()3811 PropertyProto::vector_values() const {
3812 // @@protoc_insertion_point(field_list:icing.lib.PropertyProto.vector_values)
3813 return _impl_.vector_values_;
3814 }
3815
3816 // repeated .icing.lib.PropertyProto.BlobHandleProto blob_handle_values = 9;
_internal_blob_handle_values_size()3817 inline int PropertyProto::_internal_blob_handle_values_size() const {
3818 return _impl_.blob_handle_values_.size();
3819 }
blob_handle_values_size()3820 inline int PropertyProto::blob_handle_values_size() const {
3821 return _internal_blob_handle_values_size();
3822 }
clear_blob_handle_values()3823 inline void PropertyProto::clear_blob_handle_values() {
3824 _impl_.blob_handle_values_.Clear();
3825 }
mutable_blob_handle_values(int index)3826 inline ::icing::lib::PropertyProto_BlobHandleProto* PropertyProto::mutable_blob_handle_values(int index) {
3827 // @@protoc_insertion_point(field_mutable:icing.lib.PropertyProto.blob_handle_values)
3828 return _impl_.blob_handle_values_.Mutable(index);
3829 }
3830 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::PropertyProto_BlobHandleProto >*
mutable_blob_handle_values()3831 PropertyProto::mutable_blob_handle_values() {
3832 // @@protoc_insertion_point(field_mutable_list:icing.lib.PropertyProto.blob_handle_values)
3833 return &_impl_.blob_handle_values_;
3834 }
_internal_blob_handle_values(int index)3835 inline const ::icing::lib::PropertyProto_BlobHandleProto& PropertyProto::_internal_blob_handle_values(int index) const {
3836 return _impl_.blob_handle_values_.Get(index);
3837 }
blob_handle_values(int index)3838 inline const ::icing::lib::PropertyProto_BlobHandleProto& PropertyProto::blob_handle_values(int index) const {
3839 // @@protoc_insertion_point(field_get:icing.lib.PropertyProto.blob_handle_values)
3840 return _internal_blob_handle_values(index);
3841 }
_internal_add_blob_handle_values()3842 inline ::icing::lib::PropertyProto_BlobHandleProto* PropertyProto::_internal_add_blob_handle_values() {
3843 return _impl_.blob_handle_values_.Add();
3844 }
add_blob_handle_values()3845 inline ::icing::lib::PropertyProto_BlobHandleProto* PropertyProto::add_blob_handle_values() {
3846 ::icing::lib::PropertyProto_BlobHandleProto* _add = _internal_add_blob_handle_values();
3847 // @@protoc_insertion_point(field_add:icing.lib.PropertyProto.blob_handle_values)
3848 return _add;
3849 }
3850 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::PropertyProto_BlobHandleProto >&
blob_handle_values()3851 PropertyProto::blob_handle_values() const {
3852 // @@protoc_insertion_point(field_list:icing.lib.PropertyProto.blob_handle_values)
3853 return _impl_.blob_handle_values_;
3854 }
3855
3856 // -------------------------------------------------------------------
3857
3858 // PutResultProto
3859
3860 // optional .icing.lib.StatusProto status = 1;
_internal_has_status()3861 inline bool PutResultProto::_internal_has_status() const {
3862 bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
3863 PROTOBUF_ASSUME(!value || _impl_.status_ != nullptr);
3864 return value;
3865 }
has_status()3866 inline bool PutResultProto::has_status() const {
3867 return _internal_has_status();
3868 }
_internal_status()3869 inline const ::icing::lib::StatusProto& PutResultProto::_internal_status() const {
3870 const ::icing::lib::StatusProto* p = _impl_.status_;
3871 return p != nullptr ? *p : reinterpret_cast<const ::icing::lib::StatusProto&>(
3872 ::icing::lib::_StatusProto_default_instance_);
3873 }
status()3874 inline const ::icing::lib::StatusProto& PutResultProto::status() const {
3875 // @@protoc_insertion_point(field_get:icing.lib.PutResultProto.status)
3876 return _internal_status();
3877 }
unsafe_arena_set_allocated_status(::icing::lib::StatusProto * status)3878 inline void PutResultProto::unsafe_arena_set_allocated_status(
3879 ::icing::lib::StatusProto* status) {
3880 if (GetArenaForAllocation() == nullptr) {
3881 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.status_);
3882 }
3883 _impl_.status_ = status;
3884 if (status) {
3885 _impl_._has_bits_[0] |= 0x00000001u;
3886 } else {
3887 _impl_._has_bits_[0] &= ~0x00000001u;
3888 }
3889 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:icing.lib.PutResultProto.status)
3890 }
release_status()3891 inline ::icing::lib::StatusProto* PutResultProto::release_status() {
3892 _impl_._has_bits_[0] &= ~0x00000001u;
3893 ::icing::lib::StatusProto* temp = _impl_.status_;
3894 _impl_.status_ = nullptr;
3895 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
3896 auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
3897 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
3898 if (GetArenaForAllocation() == nullptr) { delete old; }
3899 #else // PROTOBUF_FORCE_COPY_IN_RELEASE
3900 if (GetArenaForAllocation() != nullptr) {
3901 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
3902 }
3903 #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
3904 return temp;
3905 }
unsafe_arena_release_status()3906 inline ::icing::lib::StatusProto* PutResultProto::unsafe_arena_release_status() {
3907 // @@protoc_insertion_point(field_release:icing.lib.PutResultProto.status)
3908 _impl_._has_bits_[0] &= ~0x00000001u;
3909 ::icing::lib::StatusProto* temp = _impl_.status_;
3910 _impl_.status_ = nullptr;
3911 return temp;
3912 }
_internal_mutable_status()3913 inline ::icing::lib::StatusProto* PutResultProto::_internal_mutable_status() {
3914 _impl_._has_bits_[0] |= 0x00000001u;
3915 if (_impl_.status_ == nullptr) {
3916 auto* p = CreateMaybeMessage<::icing::lib::StatusProto>(GetArenaForAllocation());
3917 _impl_.status_ = p;
3918 }
3919 return _impl_.status_;
3920 }
mutable_status()3921 inline ::icing::lib::StatusProto* PutResultProto::mutable_status() {
3922 ::icing::lib::StatusProto* _msg = _internal_mutable_status();
3923 // @@protoc_insertion_point(field_mutable:icing.lib.PutResultProto.status)
3924 return _msg;
3925 }
set_allocated_status(::icing::lib::StatusProto * status)3926 inline void PutResultProto::set_allocated_status(::icing::lib::StatusProto* status) {
3927 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
3928 if (message_arena == nullptr) {
3929 delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.status_);
3930 }
3931 if (status) {
3932 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
3933 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
3934 reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(status));
3935 if (message_arena != submessage_arena) {
3936 status = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
3937 message_arena, status, submessage_arena);
3938 }
3939 _impl_._has_bits_[0] |= 0x00000001u;
3940 } else {
3941 _impl_._has_bits_[0] &= ~0x00000001u;
3942 }
3943 _impl_.status_ = status;
3944 // @@protoc_insertion_point(field_set_allocated:icing.lib.PutResultProto.status)
3945 }
3946
3947 // optional .icing.lib.PutDocumentStatsProto put_document_stats = 2;
_internal_has_put_document_stats()3948 inline bool PutResultProto::_internal_has_put_document_stats() const {
3949 bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
3950 PROTOBUF_ASSUME(!value || _impl_.put_document_stats_ != nullptr);
3951 return value;
3952 }
has_put_document_stats()3953 inline bool PutResultProto::has_put_document_stats() const {
3954 return _internal_has_put_document_stats();
3955 }
_internal_put_document_stats()3956 inline const ::icing::lib::PutDocumentStatsProto& PutResultProto::_internal_put_document_stats() const {
3957 const ::icing::lib::PutDocumentStatsProto* p = _impl_.put_document_stats_;
3958 return p != nullptr ? *p : reinterpret_cast<const ::icing::lib::PutDocumentStatsProto&>(
3959 ::icing::lib::_PutDocumentStatsProto_default_instance_);
3960 }
put_document_stats()3961 inline const ::icing::lib::PutDocumentStatsProto& PutResultProto::put_document_stats() const {
3962 // @@protoc_insertion_point(field_get:icing.lib.PutResultProto.put_document_stats)
3963 return _internal_put_document_stats();
3964 }
unsafe_arena_set_allocated_put_document_stats(::icing::lib::PutDocumentStatsProto * put_document_stats)3965 inline void PutResultProto::unsafe_arena_set_allocated_put_document_stats(
3966 ::icing::lib::PutDocumentStatsProto* put_document_stats) {
3967 if (GetArenaForAllocation() == nullptr) {
3968 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.put_document_stats_);
3969 }
3970 _impl_.put_document_stats_ = put_document_stats;
3971 if (put_document_stats) {
3972 _impl_._has_bits_[0] |= 0x00000002u;
3973 } else {
3974 _impl_._has_bits_[0] &= ~0x00000002u;
3975 }
3976 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:icing.lib.PutResultProto.put_document_stats)
3977 }
release_put_document_stats()3978 inline ::icing::lib::PutDocumentStatsProto* PutResultProto::release_put_document_stats() {
3979 _impl_._has_bits_[0] &= ~0x00000002u;
3980 ::icing::lib::PutDocumentStatsProto* temp = _impl_.put_document_stats_;
3981 _impl_.put_document_stats_ = nullptr;
3982 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
3983 auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
3984 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
3985 if (GetArenaForAllocation() == nullptr) { delete old; }
3986 #else // PROTOBUF_FORCE_COPY_IN_RELEASE
3987 if (GetArenaForAllocation() != nullptr) {
3988 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
3989 }
3990 #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
3991 return temp;
3992 }
unsafe_arena_release_put_document_stats()3993 inline ::icing::lib::PutDocumentStatsProto* PutResultProto::unsafe_arena_release_put_document_stats() {
3994 // @@protoc_insertion_point(field_release:icing.lib.PutResultProto.put_document_stats)
3995 _impl_._has_bits_[0] &= ~0x00000002u;
3996 ::icing::lib::PutDocumentStatsProto* temp = _impl_.put_document_stats_;
3997 _impl_.put_document_stats_ = nullptr;
3998 return temp;
3999 }
_internal_mutable_put_document_stats()4000 inline ::icing::lib::PutDocumentStatsProto* PutResultProto::_internal_mutable_put_document_stats() {
4001 _impl_._has_bits_[0] |= 0x00000002u;
4002 if (_impl_.put_document_stats_ == nullptr) {
4003 auto* p = CreateMaybeMessage<::icing::lib::PutDocumentStatsProto>(GetArenaForAllocation());
4004 _impl_.put_document_stats_ = p;
4005 }
4006 return _impl_.put_document_stats_;
4007 }
mutable_put_document_stats()4008 inline ::icing::lib::PutDocumentStatsProto* PutResultProto::mutable_put_document_stats() {
4009 ::icing::lib::PutDocumentStatsProto* _msg = _internal_mutable_put_document_stats();
4010 // @@protoc_insertion_point(field_mutable:icing.lib.PutResultProto.put_document_stats)
4011 return _msg;
4012 }
set_allocated_put_document_stats(::icing::lib::PutDocumentStatsProto * put_document_stats)4013 inline void PutResultProto::set_allocated_put_document_stats(::icing::lib::PutDocumentStatsProto* put_document_stats) {
4014 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
4015 if (message_arena == nullptr) {
4016 delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.put_document_stats_);
4017 }
4018 if (put_document_stats) {
4019 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
4020 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
4021 reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(put_document_stats));
4022 if (message_arena != submessage_arena) {
4023 put_document_stats = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
4024 message_arena, put_document_stats, submessage_arena);
4025 }
4026 _impl_._has_bits_[0] |= 0x00000002u;
4027 } else {
4028 _impl_._has_bits_[0] &= ~0x00000002u;
4029 }
4030 _impl_.put_document_stats_ = put_document_stats;
4031 // @@protoc_insertion_point(field_set_allocated:icing.lib.PutResultProto.put_document_stats)
4032 }
4033
4034 // optional bool was_replacement = 3;
_internal_has_was_replacement()4035 inline bool PutResultProto::_internal_has_was_replacement() const {
4036 bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
4037 return value;
4038 }
has_was_replacement()4039 inline bool PutResultProto::has_was_replacement() const {
4040 return _internal_has_was_replacement();
4041 }
clear_was_replacement()4042 inline void PutResultProto::clear_was_replacement() {
4043 _impl_.was_replacement_ = false;
4044 _impl_._has_bits_[0] &= ~0x00000004u;
4045 }
_internal_was_replacement()4046 inline bool PutResultProto::_internal_was_replacement() const {
4047 return _impl_.was_replacement_;
4048 }
was_replacement()4049 inline bool PutResultProto::was_replacement() const {
4050 // @@protoc_insertion_point(field_get:icing.lib.PutResultProto.was_replacement)
4051 return _internal_was_replacement();
4052 }
_internal_set_was_replacement(bool value)4053 inline void PutResultProto::_internal_set_was_replacement(bool value) {
4054 _impl_._has_bits_[0] |= 0x00000004u;
4055 _impl_.was_replacement_ = value;
4056 }
set_was_replacement(bool value)4057 inline void PutResultProto::set_was_replacement(bool value) {
4058 _internal_set_was_replacement(value);
4059 // @@protoc_insertion_point(field_set:icing.lib.PutResultProto.was_replacement)
4060 }
4061
4062 // -------------------------------------------------------------------
4063
4064 // GetResultProto
4065
4066 // optional .icing.lib.StatusProto status = 1;
_internal_has_status()4067 inline bool GetResultProto::_internal_has_status() const {
4068 bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
4069 PROTOBUF_ASSUME(!value || _impl_.status_ != nullptr);
4070 return value;
4071 }
has_status()4072 inline bool GetResultProto::has_status() const {
4073 return _internal_has_status();
4074 }
_internal_status()4075