1 // Generated by the protocol buffer compiler.  DO NOT EDIT!
2 // source: icing/proto/storage.proto
3 
4 #ifndef GOOGLE_PROTOBUF_INCLUDED_icing_2fproto_2fstorage_2eproto
5 #define GOOGLE_PROTOBUF_INCLUDED_icing_2fproto_2fstorage_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/status.pb.h"
33 // @@protoc_insertion_point(includes)
34 #include <google/protobuf/port_def.inc>
35 #define PROTOBUF_INTERNAL_EXPORT_icing_2fproto_2fstorage_2eproto
36 PROTOBUF_NAMESPACE_OPEN
37 namespace internal {
38 class AnyMetadata;
39 }  // namespace internal
40 PROTOBUF_NAMESPACE_CLOSE
41 
42 // Internal implementation detail -- do not use these members.
43 struct TableStruct_icing_2fproto_2fstorage_2eproto {
44   static const ::uint32_t offsets[];
45 };
46 namespace icing {
47 namespace lib {
48 class DocumentStorageInfoProto;
49 struct DocumentStorageInfoProtoDefaultTypeInternal;
50 extern DocumentStorageInfoProtoDefaultTypeInternal _DocumentStorageInfoProto_default_instance_;
51 class IndexStorageInfoProto;
52 struct IndexStorageInfoProtoDefaultTypeInternal;
53 extern IndexStorageInfoProtoDefaultTypeInternal _IndexStorageInfoProto_default_instance_;
54 class NamespaceBlobStorageInfoProto;
55 struct NamespaceBlobStorageInfoProtoDefaultTypeInternal;
56 extern NamespaceBlobStorageInfoProtoDefaultTypeInternal _NamespaceBlobStorageInfoProto_default_instance_;
57 class NamespaceStorageInfoProto;
58 struct NamespaceStorageInfoProtoDefaultTypeInternal;
59 extern NamespaceStorageInfoProtoDefaultTypeInternal _NamespaceStorageInfoProto_default_instance_;
60 class SchemaStoreStorageInfoProto;
61 struct SchemaStoreStorageInfoProtoDefaultTypeInternal;
62 extern SchemaStoreStorageInfoProtoDefaultTypeInternal _SchemaStoreStorageInfoProto_default_instance_;
63 class StorageInfoProto;
64 struct StorageInfoProtoDefaultTypeInternal;
65 extern StorageInfoProtoDefaultTypeInternal _StorageInfoProto_default_instance_;
66 class StorageInfoResultProto;
67 struct StorageInfoResultProtoDefaultTypeInternal;
68 extern StorageInfoResultProtoDefaultTypeInternal _StorageInfoResultProto_default_instance_;
69 }  // namespace lib
70 }  // namespace icing
71 PROTOBUF_NAMESPACE_OPEN
72 template<> ::icing::lib::DocumentStorageInfoProto* Arena::CreateMaybeMessage<::icing::lib::DocumentStorageInfoProto>(Arena*);
73 template<> ::icing::lib::IndexStorageInfoProto* Arena::CreateMaybeMessage<::icing::lib::IndexStorageInfoProto>(Arena*);
74 template<> ::icing::lib::NamespaceBlobStorageInfoProto* Arena::CreateMaybeMessage<::icing::lib::NamespaceBlobStorageInfoProto>(Arena*);
75 template<> ::icing::lib::NamespaceStorageInfoProto* Arena::CreateMaybeMessage<::icing::lib::NamespaceStorageInfoProto>(Arena*);
76 template<> ::icing::lib::SchemaStoreStorageInfoProto* Arena::CreateMaybeMessage<::icing::lib::SchemaStoreStorageInfoProto>(Arena*);
77 template<> ::icing::lib::StorageInfoProto* Arena::CreateMaybeMessage<::icing::lib::StorageInfoProto>(Arena*);
78 template<> ::icing::lib::StorageInfoResultProto* Arena::CreateMaybeMessage<::icing::lib::StorageInfoResultProto>(Arena*);
79 PROTOBUF_NAMESPACE_CLOSE
80 namespace icing {
81 namespace lib {
82 
83 // ===================================================================
84 
85 class NamespaceStorageInfoProto final :
86     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:icing.lib.NamespaceStorageInfoProto) */ {
87  public:
NamespaceStorageInfoProto()88   inline NamespaceStorageInfoProto() : NamespaceStorageInfoProto(nullptr) {}
89   ~NamespaceStorageInfoProto() override;
90   explicit PROTOBUF_CONSTEXPR NamespaceStorageInfoProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
91 
92   NamespaceStorageInfoProto(const NamespaceStorageInfoProto& from);
NamespaceStorageInfoProto(NamespaceStorageInfoProto && from)93   NamespaceStorageInfoProto(NamespaceStorageInfoProto&& from) noexcept
94     : NamespaceStorageInfoProto() {
95     *this = ::std::move(from);
96   }
97 
98   inline NamespaceStorageInfoProto& operator=(const NamespaceStorageInfoProto& from) {
99     if (this == &from) return *this;
100     CopyFrom(from);
101     return *this;
102   }
103   inline NamespaceStorageInfoProto& operator=(NamespaceStorageInfoProto&& from) noexcept {
104     if (this == &from) return *this;
105     if (GetOwningArena() == from.GetOwningArena()
106   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
107         && GetOwningArena() != nullptr
108   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
109     ) {
110       InternalSwap(&from);
111     } else {
112       CopyFrom(from);
113     }
114     return *this;
115   }
116 
unknown_fields()117   inline const std::string& unknown_fields() const {
118     return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
119   }
mutable_unknown_fields()120   inline std::string* mutable_unknown_fields() {
121     return _internal_metadata_.mutable_unknown_fields<std::string>();
122   }
123 
default_instance()124   static const NamespaceStorageInfoProto& default_instance() {
125     return *internal_default_instance();
126   }
internal_default_instance()127   static inline const NamespaceStorageInfoProto* internal_default_instance() {
128     return reinterpret_cast<const NamespaceStorageInfoProto*>(
129                &_NamespaceStorageInfoProto_default_instance_);
130   }
131   static constexpr int kIndexInFileMessages =
132     0;
133 
swap(NamespaceStorageInfoProto & a,NamespaceStorageInfoProto & b)134   friend void swap(NamespaceStorageInfoProto& a, NamespaceStorageInfoProto& b) {
135     a.Swap(&b);
136   }
Swap(NamespaceStorageInfoProto * other)137   inline void Swap(NamespaceStorageInfoProto* other) {
138     if (other == this) return;
139   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
140     if (GetOwningArena() != nullptr &&
141         GetOwningArena() == other->GetOwningArena()) {
142    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
143     if (GetOwningArena() == other->GetOwningArena()) {
144   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
145       InternalSwap(other);
146     } else {
147       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
148     }
149   }
150   void UnsafeArenaSwap(NamespaceStorageInfoProto* other) {
151     if (other == this) return;
152     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
153     InternalSwap(other);
154   }
155 
156   // implements Message ----------------------------------------------
157 
158   NamespaceStorageInfoProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
159     return CreateMaybeMessage<NamespaceStorageInfoProto>(arena);
160   }
161   NamespaceStorageInfoProto* New() const {
162     return New(nullptr);
163   }
164   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
165   void CopyFrom(const NamespaceStorageInfoProto& from);
166   void MergeFrom(const NamespaceStorageInfoProto& from);
167   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
168   bool IsInitialized() const final;
169 
170   size_t ByteSizeLong() const final;
171   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
172   ::uint8_t* _InternalSerialize(
173       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
174   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
175 
176   private:
177   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
178   void SharedDtor();
179   void SetCachedSize(int size) const;
180   void InternalSwap(NamespaceStorageInfoProto* other);
181 
182   private:
183   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
184   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
185     return "icing.lib.NamespaceStorageInfoProto";
186   }
187   protected:
188   explicit NamespaceStorageInfoProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
189                        bool is_message_owned = false);
190   public:
191 
192   std::string GetTypeName() const final;
193 
194   // nested types ----------------------------------------------------
195 
196   // accessors -------------------------------------------------------
197 
198   enum : int {
199     kNamespaceFieldNumber = 1,
200     kNumAliveDocumentsFieldNumber = 2,
201     kNumExpiredDocumentsFieldNumber = 3,
202     kNumAliveDocumentsUsageType1FieldNumber = 4,
203     kNumAliveDocumentsUsageType2FieldNumber = 5,
204     kNumAliveDocumentsUsageType3FieldNumber = 6,
205     kNumExpiredDocumentsUsageType1FieldNumber = 7,
206     kNumExpiredDocumentsUsageType2FieldNumber = 8,
207     kNumExpiredDocumentsUsageType3FieldNumber = 9,
208   };
209   // optional string namespace = 1;
210   bool has_namespace_() const;
211   private:
212   bool _internal_has_namespace_() const;
213   public:
214   void clear_namespace_();
215   const std::string& namespace_() const;
216   template <typename ArgT0 = const std::string&, typename... ArgT>
217   void set_namespace_(ArgT0&& arg0, ArgT... args);
218   std::string* mutable_namespace_();
219   PROTOBUF_NODISCARD std::string* release_namespace_();
220   void set_allocated_namespace_(std::string* namespace_);
221   private:
222   const std::string& _internal_namespace_() const;
223   inline PROTOBUF_ALWAYS_INLINE void _internal_set_namespace_(const std::string& value);
224   std::string* _internal_mutable_namespace_();
225   public:
226 
227   // optional int32 num_alive_documents = 2;
228   bool has_num_alive_documents() const;
229   private:
230   bool _internal_has_num_alive_documents() const;
231   public:
232   void clear_num_alive_documents();
233   ::int32_t num_alive_documents() const;
234   void set_num_alive_documents(::int32_t value);
235   private:
236   ::int32_t _internal_num_alive_documents() const;
237   void _internal_set_num_alive_documents(::int32_t value);
238   public:
239 
240   // optional int32 num_expired_documents = 3;
241   bool has_num_expired_documents() const;
242   private:
243   bool _internal_has_num_expired_documents() const;
244   public:
245   void clear_num_expired_documents();
246   ::int32_t num_expired_documents() const;
247   void set_num_expired_documents(::int32_t value);
248   private:
249   ::int32_t _internal_num_expired_documents() const;
250   void _internal_set_num_expired_documents(::int32_t value);
251   public:
252 
253   // optional int32 num_alive_documents_usage_type1 = 4;
254   bool has_num_alive_documents_usage_type1() const;
255   private:
256   bool _internal_has_num_alive_documents_usage_type1() const;
257   public:
258   void clear_num_alive_documents_usage_type1();
259   ::int32_t num_alive_documents_usage_type1() const;
260   void set_num_alive_documents_usage_type1(::int32_t value);
261   private:
262   ::int32_t _internal_num_alive_documents_usage_type1() const;
263   void _internal_set_num_alive_documents_usage_type1(::int32_t value);
264   public:
265 
266   // optional int32 num_alive_documents_usage_type2 = 5;
267   bool has_num_alive_documents_usage_type2() const;
268   private:
269   bool _internal_has_num_alive_documents_usage_type2() const;
270   public:
271   void clear_num_alive_documents_usage_type2();
272   ::int32_t num_alive_documents_usage_type2() const;
273   void set_num_alive_documents_usage_type2(::int32_t value);
274   private:
275   ::int32_t _internal_num_alive_documents_usage_type2() const;
276   void _internal_set_num_alive_documents_usage_type2(::int32_t value);
277   public:
278 
279   // optional int32 num_alive_documents_usage_type3 = 6;
280   bool has_num_alive_documents_usage_type3() const;
281   private:
282   bool _internal_has_num_alive_documents_usage_type3() const;
283   public:
284   void clear_num_alive_documents_usage_type3();
285   ::int32_t num_alive_documents_usage_type3() const;
286   void set_num_alive_documents_usage_type3(::int32_t value);
287   private:
288   ::int32_t _internal_num_alive_documents_usage_type3() const;
289   void _internal_set_num_alive_documents_usage_type3(::int32_t value);
290   public:
291 
292   // optional int32 num_expired_documents_usage_type1 = 7;
293   bool has_num_expired_documents_usage_type1() const;
294   private:
295   bool _internal_has_num_expired_documents_usage_type1() const;
296   public:
297   void clear_num_expired_documents_usage_type1();
298   ::int32_t num_expired_documents_usage_type1() const;
299   void set_num_expired_documents_usage_type1(::int32_t value);
300   private:
301   ::int32_t _internal_num_expired_documents_usage_type1() const;
302   void _internal_set_num_expired_documents_usage_type1(::int32_t value);
303   public:
304 
305   // optional int32 num_expired_documents_usage_type2 = 8;
306   bool has_num_expired_documents_usage_type2() const;
307   private:
308   bool _internal_has_num_expired_documents_usage_type2() const;
309   public:
310   void clear_num_expired_documents_usage_type2();
311   ::int32_t num_expired_documents_usage_type2() const;
312   void set_num_expired_documents_usage_type2(::int32_t value);
313   private:
314   ::int32_t _internal_num_expired_documents_usage_type2() const;
315   void _internal_set_num_expired_documents_usage_type2(::int32_t value);
316   public:
317 
318   // optional int32 num_expired_documents_usage_type3 = 9;
319   bool has_num_expired_documents_usage_type3() const;
320   private:
321   bool _internal_has_num_expired_documents_usage_type3() const;
322   public:
323   void clear_num_expired_documents_usage_type3();
324   ::int32_t num_expired_documents_usage_type3() const;
325   void set_num_expired_documents_usage_type3(::int32_t value);
326   private:
327   ::int32_t _internal_num_expired_documents_usage_type3() const;
328   void _internal_set_num_expired_documents_usage_type3(::int32_t value);
329   public:
330 
331   // @@protoc_insertion_point(class_scope:icing.lib.NamespaceStorageInfoProto)
332  private:
333   class _Internal;
334 
335   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
336   typedef void InternalArenaConstructable_;
337   typedef void DestructorSkippable_;
338   struct Impl_ {
339     ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
340     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
341     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr namespace__;
342     ::int32_t num_alive_documents_;
343     ::int32_t num_expired_documents_;
344     ::int32_t num_alive_documents_usage_type1_;
345     ::int32_t num_alive_documents_usage_type2_;
346     ::int32_t num_alive_documents_usage_type3_;
347     ::int32_t num_expired_documents_usage_type1_;
348     ::int32_t num_expired_documents_usage_type2_;
349     ::int32_t num_expired_documents_usage_type3_;
350   };
351   union { Impl_ _impl_; };
352   friend struct ::TableStruct_icing_2fproto_2fstorage_2eproto;
353 };
354 // -------------------------------------------------------------------
355 
356 class DocumentStorageInfoProto final :
357     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:icing.lib.DocumentStorageInfoProto) */ {
358  public:
DocumentStorageInfoProto()359   inline DocumentStorageInfoProto() : DocumentStorageInfoProto(nullptr) {}
360   ~DocumentStorageInfoProto() override;
361   explicit PROTOBUF_CONSTEXPR DocumentStorageInfoProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
362 
363   DocumentStorageInfoProto(const DocumentStorageInfoProto& from);
DocumentStorageInfoProto(DocumentStorageInfoProto && from)364   DocumentStorageInfoProto(DocumentStorageInfoProto&& from) noexcept
365     : DocumentStorageInfoProto() {
366     *this = ::std::move(from);
367   }
368 
369   inline DocumentStorageInfoProto& operator=(const DocumentStorageInfoProto& from) {
370     if (this == &from) return *this;
371     CopyFrom(from);
372     return *this;
373   }
374   inline DocumentStorageInfoProto& operator=(DocumentStorageInfoProto&& from) noexcept {
375     if (this == &from) return *this;
376     if (GetOwningArena() == from.GetOwningArena()
377   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
378         && GetOwningArena() != nullptr
379   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
380     ) {
381       InternalSwap(&from);
382     } else {
383       CopyFrom(from);
384     }
385     return *this;
386   }
387 
unknown_fields()388   inline const std::string& unknown_fields() const {
389     return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
390   }
mutable_unknown_fields()391   inline std::string* mutable_unknown_fields() {
392     return _internal_metadata_.mutable_unknown_fields<std::string>();
393   }
394 
default_instance()395   static const DocumentStorageInfoProto& default_instance() {
396     return *internal_default_instance();
397   }
internal_default_instance()398   static inline const DocumentStorageInfoProto* internal_default_instance() {
399     return reinterpret_cast<const DocumentStorageInfoProto*>(
400                &_DocumentStorageInfoProto_default_instance_);
401   }
402   static constexpr int kIndexInFileMessages =
403     1;
404 
swap(DocumentStorageInfoProto & a,DocumentStorageInfoProto & b)405   friend void swap(DocumentStorageInfoProto& a, DocumentStorageInfoProto& b) {
406     a.Swap(&b);
407   }
Swap(DocumentStorageInfoProto * other)408   inline void Swap(DocumentStorageInfoProto* other) {
409     if (other == this) return;
410   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
411     if (GetOwningArena() != nullptr &&
412         GetOwningArena() == other->GetOwningArena()) {
413    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
414     if (GetOwningArena() == other->GetOwningArena()) {
415   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
416       InternalSwap(other);
417     } else {
418       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
419     }
420   }
421   void UnsafeArenaSwap(DocumentStorageInfoProto* other) {
422     if (other == this) return;
423     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
424     InternalSwap(other);
425   }
426 
427   // implements Message ----------------------------------------------
428 
429   DocumentStorageInfoProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
430     return CreateMaybeMessage<DocumentStorageInfoProto>(arena);
431   }
432   DocumentStorageInfoProto* New() const {
433     return New(nullptr);
434   }
435   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
436   void CopyFrom(const DocumentStorageInfoProto& from);
437   void MergeFrom(const DocumentStorageInfoProto& from);
438   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
439   bool IsInitialized() const final;
440 
441   size_t ByteSizeLong() const final;
442   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
443   ::uint8_t* _InternalSerialize(
444       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
445   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
446 
447   private:
448   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
449   void SharedDtor();
450   void SetCachedSize(int size) const;
451   void InternalSwap(DocumentStorageInfoProto* other);
452 
453   private:
454   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
455   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
456     return "icing.lib.DocumentStorageInfoProto";
457   }
458   protected:
459   explicit DocumentStorageInfoProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
460                        bool is_message_owned = false);
461   public:
462 
463   std::string GetTypeName() const final;
464 
465   // nested types ----------------------------------------------------
466 
467   // accessors -------------------------------------------------------
468 
469   enum : int {
470     kNamespaceStorageInfoFieldNumber = 14,
471     kNumAliveDocumentsFieldNumber = 1,
472     kNumDeletedDocumentsFieldNumber = 2,
473     kDocumentStoreSizeFieldNumber = 4,
474     kDocumentLogSizeFieldNumber = 5,
475     kKeyMapperSizeFieldNumber = 6,
476     kDocumentIdMapperSizeFieldNumber = 7,
477     kScoreCacheSizeFieldNumber = 8,
478     kNumExpiredDocumentsFieldNumber = 3,
479     kNumNamespacesFieldNumber = 13,
480     kFilterCacheSizeFieldNumber = 9,
481     kCorpusMapperSizeFieldNumber = 10,
482     kCorpusScoreCacheSizeFieldNumber = 11,
483     kNamespaceIdMapperSizeFieldNumber = 12,
484     kScorablePropertyCacheSizeFieldNumber = 15,
485   };
486   // repeated .icing.lib.NamespaceStorageInfoProto namespace_storage_info = 14;
487   int namespace_storage_info_size() const;
488   private:
489   int _internal_namespace_storage_info_size() const;
490   public:
491   void clear_namespace_storage_info();
492   ::icing::lib::NamespaceStorageInfoProto* mutable_namespace_storage_info(int index);
493   ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::NamespaceStorageInfoProto >*
494       mutable_namespace_storage_info();
495   private:
496   const ::icing::lib::NamespaceStorageInfoProto& _internal_namespace_storage_info(int index) const;
497   ::icing::lib::NamespaceStorageInfoProto* _internal_add_namespace_storage_info();
498   public:
499   const ::icing::lib::NamespaceStorageInfoProto& namespace_storage_info(int index) const;
500   ::icing::lib::NamespaceStorageInfoProto* add_namespace_storage_info();
501   const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::NamespaceStorageInfoProto >&
502       namespace_storage_info() const;
503 
504   // optional int32 num_alive_documents = 1;
505   bool has_num_alive_documents() const;
506   private:
507   bool _internal_has_num_alive_documents() const;
508   public:
509   void clear_num_alive_documents();
510   ::int32_t num_alive_documents() const;
511   void set_num_alive_documents(::int32_t value);
512   private:
513   ::int32_t _internal_num_alive_documents() const;
514   void _internal_set_num_alive_documents(::int32_t value);
515   public:
516 
517   // optional int32 num_deleted_documents = 2;
518   bool has_num_deleted_documents() const;
519   private:
520   bool _internal_has_num_deleted_documents() const;
521   public:
522   void clear_num_deleted_documents();
523   ::int32_t num_deleted_documents() const;
524   void set_num_deleted_documents(::int32_t value);
525   private:
526   ::int32_t _internal_num_deleted_documents() const;
527   void _internal_set_num_deleted_documents(::int32_t value);
528   public:
529 
530   // optional int64 document_store_size = 4;
531   bool has_document_store_size() const;
532   private:
533   bool _internal_has_document_store_size() const;
534   public:
535   void clear_document_store_size();
536   ::int64_t document_store_size() const;
537   void set_document_store_size(::int64_t value);
538   private:
539   ::int64_t _internal_document_store_size() const;
540   void _internal_set_document_store_size(::int64_t value);
541   public:
542 
543   // optional int64 document_log_size = 5;
544   bool has_document_log_size() const;
545   private:
546   bool _internal_has_document_log_size() const;
547   public:
548   void clear_document_log_size();
549   ::int64_t document_log_size() const;
550   void set_document_log_size(::int64_t value);
551   private:
552   ::int64_t _internal_document_log_size() const;
553   void _internal_set_document_log_size(::int64_t value);
554   public:
555 
556   // optional int64 key_mapper_size = 6;
557   bool has_key_mapper_size() const;
558   private:
559   bool _internal_has_key_mapper_size() const;
560   public:
561   void clear_key_mapper_size();
562   ::int64_t key_mapper_size() const;
563   void set_key_mapper_size(::int64_t value);
564   private:
565   ::int64_t _internal_key_mapper_size() const;
566   void _internal_set_key_mapper_size(::int64_t value);
567   public:
568 
569   // optional int64 document_id_mapper_size = 7;
570   bool has_document_id_mapper_size() const;
571   private:
572   bool _internal_has_document_id_mapper_size() const;
573   public:
574   void clear_document_id_mapper_size();
575   ::int64_t document_id_mapper_size() const;
576   void set_document_id_mapper_size(::int64_t value);
577   private:
578   ::int64_t _internal_document_id_mapper_size() const;
579   void _internal_set_document_id_mapper_size(::int64_t value);
580   public:
581 
582   // optional int64 score_cache_size = 8;
583   bool has_score_cache_size() const;
584   private:
585   bool _internal_has_score_cache_size() const;
586   public:
587   void clear_score_cache_size();
588   ::int64_t score_cache_size() const;
589   void set_score_cache_size(::int64_t value);
590   private:
591   ::int64_t _internal_score_cache_size() const;
592   void _internal_set_score_cache_size(::int64_t value);
593   public:
594 
595   // optional int32 num_expired_documents = 3;
596   bool has_num_expired_documents() const;
597   private:
598   bool _internal_has_num_expired_documents() const;
599   public:
600   void clear_num_expired_documents();
601   ::int32_t num_expired_documents() const;
602   void set_num_expired_documents(::int32_t value);
603   private:
604   ::int32_t _internal_num_expired_documents() const;
605   void _internal_set_num_expired_documents(::int32_t value);
606   public:
607 
608   // optional int32 num_namespaces = 13;
609   bool has_num_namespaces() const;
610   private:
611   bool _internal_has_num_namespaces() const;
612   public:
613   void clear_num_namespaces();
614   ::int32_t num_namespaces() const;
615   void set_num_namespaces(::int32_t value);
616   private:
617   ::int32_t _internal_num_namespaces() const;
618   void _internal_set_num_namespaces(::int32_t value);
619   public:
620 
621   // optional int64 filter_cache_size = 9;
622   bool has_filter_cache_size() const;
623   private:
624   bool _internal_has_filter_cache_size() const;
625   public:
626   void clear_filter_cache_size();
627   ::int64_t filter_cache_size() const;
628   void set_filter_cache_size(::int64_t value);
629   private:
630   ::int64_t _internal_filter_cache_size() const;
631   void _internal_set_filter_cache_size(::int64_t value);
632   public:
633 
634   // optional int64 corpus_mapper_size = 10;
635   bool has_corpus_mapper_size() const;
636   private:
637   bool _internal_has_corpus_mapper_size() const;
638   public:
639   void clear_corpus_mapper_size();
640   ::int64_t corpus_mapper_size() const;
641   void set_corpus_mapper_size(::int64_t value);
642   private:
643   ::int64_t _internal_corpus_mapper_size() const;
644   void _internal_set_corpus_mapper_size(::int64_t value);
645   public:
646 
647   // optional int64 corpus_score_cache_size = 11;
648   bool has_corpus_score_cache_size() const;
649   private:
650   bool _internal_has_corpus_score_cache_size() const;
651   public:
652   void clear_corpus_score_cache_size();
653   ::int64_t corpus_score_cache_size() const;
654   void set_corpus_score_cache_size(::int64_t value);
655   private:
656   ::int64_t _internal_corpus_score_cache_size() const;
657   void _internal_set_corpus_score_cache_size(::int64_t value);
658   public:
659 
660   // optional int64 namespace_id_mapper_size = 12;
661   bool has_namespace_id_mapper_size() const;
662   private:
663   bool _internal_has_namespace_id_mapper_size() const;
664   public:
665   void clear_namespace_id_mapper_size();
666   ::int64_t namespace_id_mapper_size() const;
667   void set_namespace_id_mapper_size(::int64_t value);
668   private:
669   ::int64_t _internal_namespace_id_mapper_size() const;
670   void _internal_set_namespace_id_mapper_size(::int64_t value);
671   public:
672 
673   // optional int64 scorable_property_cache_size = 15;
674   bool has_scorable_property_cache_size() const;
675   private:
676   bool _internal_has_scorable_property_cache_size() const;
677   public:
678   void clear_scorable_property_cache_size();
679   ::int64_t scorable_property_cache_size() const;
680   void set_scorable_property_cache_size(::int64_t value);
681   private:
682   ::int64_t _internal_scorable_property_cache_size() const;
683   void _internal_set_scorable_property_cache_size(::int64_t value);
684   public:
685 
686   // @@protoc_insertion_point(class_scope:icing.lib.DocumentStorageInfoProto)
687  private:
688   class _Internal;
689 
690   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
691   typedef void InternalArenaConstructable_;
692   typedef void DestructorSkippable_;
693   struct Impl_ {
694     ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
695     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
696     ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::NamespaceStorageInfoProto > namespace_storage_info_;
697     ::int32_t num_alive_documents_;
698     ::int32_t num_deleted_documents_;
699     ::int64_t document_store_size_;
700     ::int64_t document_log_size_;
701     ::int64_t key_mapper_size_;
702     ::int64_t document_id_mapper_size_;
703     ::int64_t score_cache_size_;
704     ::int32_t num_expired_documents_;
705     ::int32_t num_namespaces_;
706     ::int64_t filter_cache_size_;
707     ::int64_t corpus_mapper_size_;
708     ::int64_t corpus_score_cache_size_;
709     ::int64_t namespace_id_mapper_size_;
710     ::int64_t scorable_property_cache_size_;
711   };
712   union { Impl_ _impl_; };
713   friend struct ::TableStruct_icing_2fproto_2fstorage_2eproto;
714 };
715 // -------------------------------------------------------------------
716 
717 class SchemaStoreStorageInfoProto final :
718     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:icing.lib.SchemaStoreStorageInfoProto) */ {
719  public:
SchemaStoreStorageInfoProto()720   inline SchemaStoreStorageInfoProto() : SchemaStoreStorageInfoProto(nullptr) {}
721   ~SchemaStoreStorageInfoProto() override;
722   explicit PROTOBUF_CONSTEXPR SchemaStoreStorageInfoProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
723 
724   SchemaStoreStorageInfoProto(const SchemaStoreStorageInfoProto& from);
SchemaStoreStorageInfoProto(SchemaStoreStorageInfoProto && from)725   SchemaStoreStorageInfoProto(SchemaStoreStorageInfoProto&& from) noexcept
726     : SchemaStoreStorageInfoProto() {
727     *this = ::std::move(from);
728   }
729 
730   inline SchemaStoreStorageInfoProto& operator=(const SchemaStoreStorageInfoProto& from) {
731     if (this == &from) return *this;
732     CopyFrom(from);
733     return *this;
734   }
735   inline SchemaStoreStorageInfoProto& operator=(SchemaStoreStorageInfoProto&& from) noexcept {
736     if (this == &from) return *this;
737     if (GetOwningArena() == from.GetOwningArena()
738   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
739         && GetOwningArena() != nullptr
740   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
741     ) {
742       InternalSwap(&from);
743     } else {
744       CopyFrom(from);
745     }
746     return *this;
747   }
748 
unknown_fields()749   inline const std::string& unknown_fields() const {
750     return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
751   }
mutable_unknown_fields()752   inline std::string* mutable_unknown_fields() {
753     return _internal_metadata_.mutable_unknown_fields<std::string>();
754   }
755 
default_instance()756   static const SchemaStoreStorageInfoProto& default_instance() {
757     return *internal_default_instance();
758   }
internal_default_instance()759   static inline const SchemaStoreStorageInfoProto* internal_default_instance() {
760     return reinterpret_cast<const SchemaStoreStorageInfoProto*>(
761                &_SchemaStoreStorageInfoProto_default_instance_);
762   }
763   static constexpr int kIndexInFileMessages =
764     2;
765 
swap(SchemaStoreStorageInfoProto & a,SchemaStoreStorageInfoProto & b)766   friend void swap(SchemaStoreStorageInfoProto& a, SchemaStoreStorageInfoProto& b) {
767     a.Swap(&b);
768   }
Swap(SchemaStoreStorageInfoProto * other)769   inline void Swap(SchemaStoreStorageInfoProto* other) {
770     if (other == this) return;
771   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
772     if (GetOwningArena() != nullptr &&
773         GetOwningArena() == other->GetOwningArena()) {
774    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
775     if (GetOwningArena() == other->GetOwningArena()) {
776   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
777       InternalSwap(other);
778     } else {
779       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
780     }
781   }
782   void UnsafeArenaSwap(SchemaStoreStorageInfoProto* other) {
783     if (other == this) return;
784     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
785     InternalSwap(other);
786   }
787 
788   // implements Message ----------------------------------------------
789 
790   SchemaStoreStorageInfoProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
791     return CreateMaybeMessage<SchemaStoreStorageInfoProto>(arena);
792   }
793   SchemaStoreStorageInfoProto* New() const {
794     return New(nullptr);
795   }
796   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
797   void CopyFrom(const SchemaStoreStorageInfoProto& from);
798   void MergeFrom(const SchemaStoreStorageInfoProto& from);
799   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
800   bool IsInitialized() const final;
801 
802   size_t ByteSizeLong() const final;
803   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
804   ::uint8_t* _InternalSerialize(
805       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
806   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
807 
808   private:
809   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
810   void SharedDtor();
811   void SetCachedSize(int size) const;
812   void InternalSwap(SchemaStoreStorageInfoProto* other);
813 
814   private:
815   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
816   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
817     return "icing.lib.SchemaStoreStorageInfoProto";
818   }
819   protected:
820   explicit SchemaStoreStorageInfoProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
821                        bool is_message_owned = false);
822   public:
823 
824   std::string GetTypeName() const final;
825 
826   // nested types ----------------------------------------------------
827 
828   // accessors -------------------------------------------------------
829 
830   enum : int {
831     kSchemaStoreSizeFieldNumber = 1,
832     kNumSchemaTypesFieldNumber = 2,
833     kNumTotalSectionsFieldNumber = 3,
834     kNumSchemaTypesSectionsExhaustedFieldNumber = 4,
835   };
836   // optional int64 schema_store_size = 1;
837   bool has_schema_store_size() const;
838   private:
839   bool _internal_has_schema_store_size() const;
840   public:
841   void clear_schema_store_size();
842   ::int64_t schema_store_size() const;
843   void set_schema_store_size(::int64_t value);
844   private:
845   ::int64_t _internal_schema_store_size() const;
846   void _internal_set_schema_store_size(::int64_t value);
847   public:
848 
849   // optional int32 num_schema_types = 2;
850   bool has_num_schema_types() const;
851   private:
852   bool _internal_has_num_schema_types() const;
853   public:
854   void clear_num_schema_types();
855   ::int32_t num_schema_types() const;
856   void set_num_schema_types(::int32_t value);
857   private:
858   ::int32_t _internal_num_schema_types() const;
859   void _internal_set_num_schema_types(::int32_t value);
860   public:
861 
862   // optional int32 num_total_sections = 3;
863   bool has_num_total_sections() const;
864   private:
865   bool _internal_has_num_total_sections() const;
866   public:
867   void clear_num_total_sections();
868   ::int32_t num_total_sections() const;
869   void set_num_total_sections(::int32_t value);
870   private:
871   ::int32_t _internal_num_total_sections() const;
872   void _internal_set_num_total_sections(::int32_t value);
873   public:
874 
875   // optional int32 num_schema_types_sections_exhausted = 4;
876   bool has_num_schema_types_sections_exhausted() const;
877   private:
878   bool _internal_has_num_schema_types_sections_exhausted() const;
879   public:
880   void clear_num_schema_types_sections_exhausted();
881   ::int32_t num_schema_types_sections_exhausted() const;
882   void set_num_schema_types_sections_exhausted(::int32_t value);
883   private:
884   ::int32_t _internal_num_schema_types_sections_exhausted() const;
885   void _internal_set_num_schema_types_sections_exhausted(::int32_t value);
886   public:
887 
888   // @@protoc_insertion_point(class_scope:icing.lib.SchemaStoreStorageInfoProto)
889  private:
890   class _Internal;
891 
892   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
893   typedef void InternalArenaConstructable_;
894   typedef void DestructorSkippable_;
895   struct Impl_ {
896     ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
897     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
898     ::int64_t schema_store_size_;
899     ::int32_t num_schema_types_;
900     ::int32_t num_total_sections_;
901     ::int32_t num_schema_types_sections_exhausted_;
902   };
903   union { Impl_ _impl_; };
904   friend struct ::TableStruct_icing_2fproto_2fstorage_2eproto;
905 };
906 // -------------------------------------------------------------------
907 
908 class IndexStorageInfoProto final :
909     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:icing.lib.IndexStorageInfoProto) */ {
910  public:
IndexStorageInfoProto()911   inline IndexStorageInfoProto() : IndexStorageInfoProto(nullptr) {}
912   ~IndexStorageInfoProto() override;
913   explicit PROTOBUF_CONSTEXPR IndexStorageInfoProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
914 
915   IndexStorageInfoProto(const IndexStorageInfoProto& from);
IndexStorageInfoProto(IndexStorageInfoProto && from)916   IndexStorageInfoProto(IndexStorageInfoProto&& from) noexcept
917     : IndexStorageInfoProto() {
918     *this = ::std::move(from);
919   }
920 
921   inline IndexStorageInfoProto& operator=(const IndexStorageInfoProto& from) {
922     if (this == &from) return *this;
923     CopyFrom(from);
924     return *this;
925   }
926   inline IndexStorageInfoProto& operator=(IndexStorageInfoProto&& from) noexcept {
927     if (this == &from) return *this;
928     if (GetOwningArena() == from.GetOwningArena()
929   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
930         && GetOwningArena() != nullptr
931   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
932     ) {
933       InternalSwap(&from);
934     } else {
935       CopyFrom(from);
936     }
937     return *this;
938   }
939 
unknown_fields()940   inline const std::string& unknown_fields() const {
941     return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
942   }
mutable_unknown_fields()943   inline std::string* mutable_unknown_fields() {
944     return _internal_metadata_.mutable_unknown_fields<std::string>();
945   }
946 
default_instance()947   static const IndexStorageInfoProto& default_instance() {
948     return *internal_default_instance();
949   }
internal_default_instance()950   static inline const IndexStorageInfoProto* internal_default_instance() {
951     return reinterpret_cast<const IndexStorageInfoProto*>(
952                &_IndexStorageInfoProto_default_instance_);
953   }
954   static constexpr int kIndexInFileMessages =
955     3;
956 
swap(IndexStorageInfoProto & a,IndexStorageInfoProto & b)957   friend void swap(IndexStorageInfoProto& a, IndexStorageInfoProto& b) {
958     a.Swap(&b);
959   }
Swap(IndexStorageInfoProto * other)960   inline void Swap(IndexStorageInfoProto* other) {
961     if (other == this) return;
962   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
963     if (GetOwningArena() != nullptr &&
964         GetOwningArena() == other->GetOwningArena()) {
965    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
966     if (GetOwningArena() == other->GetOwningArena()) {
967   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
968       InternalSwap(other);
969     } else {
970       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
971     }
972   }
973   void UnsafeArenaSwap(IndexStorageInfoProto* other) {
974     if (other == this) return;
975     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
976     InternalSwap(other);
977   }
978 
979   // implements Message ----------------------------------------------
980 
981   IndexStorageInfoProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
982     return CreateMaybeMessage<IndexStorageInfoProto>(arena);
983   }
984   IndexStorageInfoProto* New() const {
985     return New(nullptr);
986   }
987   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
988   void CopyFrom(const IndexStorageInfoProto& from);
989   void MergeFrom(const IndexStorageInfoProto& from);
990   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
991   bool IsInitialized() const final;
992 
993   size_t ByteSizeLong() const final;
994   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
995   ::uint8_t* _InternalSerialize(
996       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
997   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
998 
999   private:
1000   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1001   void SharedDtor();
1002   void SetCachedSize(int size) const;
1003   void InternalSwap(IndexStorageInfoProto* other);
1004 
1005   private:
1006   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1007   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1008     return "icing.lib.IndexStorageInfoProto";
1009   }
1010   protected:
1011   explicit IndexStorageInfoProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1012                        bool is_message_owned = false);
1013   public:
1014 
1015   std::string GetTypeName() const final;
1016 
1017   // nested types ----------------------------------------------------
1018 
1019   // accessors -------------------------------------------------------
1020 
1021   enum : int {
1022     kIndexSizeFieldNumber = 1,
1023     kLiteIndexLexiconSizeFieldNumber = 2,
1024     kLiteIndexHitBufferSizeFieldNumber = 3,
1025     kMainIndexLexiconSizeFieldNumber = 4,
1026     kMainIndexStorageSizeFieldNumber = 5,
1027     kMainIndexBlockSizeFieldNumber = 6,
1028     kNumBlocksFieldNumber = 7,
1029     kMinFreeFractionFieldNumber = 8,
1030   };
1031   // optional int64 index_size = 1;
1032   bool has_index_size() const;
1033   private:
1034   bool _internal_has_index_size() const;
1035   public:
1036   void clear_index_size();
1037   ::int64_t index_size() const;
1038   void set_index_size(::int64_t value);
1039   private:
1040   ::int64_t _internal_index_size() const;
1041   void _internal_set_index_size(::int64_t value);
1042   public:
1043 
1044   // optional int64 lite_index_lexicon_size = 2;
1045   bool has_lite_index_lexicon_size() const;
1046   private:
1047   bool _internal_has_lite_index_lexicon_size() const;
1048   public:
1049   void clear_lite_index_lexicon_size();
1050   ::int64_t lite_index_lexicon_size() const;
1051   void set_lite_index_lexicon_size(::int64_t value);
1052   private:
1053   ::int64_t _internal_lite_index_lexicon_size() const;
1054   void _internal_set_lite_index_lexicon_size(::int64_t value);
1055   public:
1056 
1057   // optional int64 lite_index_hit_buffer_size = 3;
1058   bool has_lite_index_hit_buffer_size() const;
1059   private:
1060   bool _internal_has_lite_index_hit_buffer_size() const;
1061   public:
1062   void clear_lite_index_hit_buffer_size();
1063   ::int64_t lite_index_hit_buffer_size() const;
1064   void set_lite_index_hit_buffer_size(::int64_t value);
1065   private:
1066   ::int64_t _internal_lite_index_hit_buffer_size() const;
1067   void _internal_set_lite_index_hit_buffer_size(::int64_t value);
1068   public:
1069 
1070   // optional int64 main_index_lexicon_size = 4;
1071   bool has_main_index_lexicon_size() const;
1072   private:
1073   bool _internal_has_main_index_lexicon_size() const;
1074   public:
1075   void clear_main_index_lexicon_size();
1076   ::int64_t main_index_lexicon_size() const;
1077   void set_main_index_lexicon_size(::int64_t value);
1078   private:
1079   ::int64_t _internal_main_index_lexicon_size() const;
1080   void _internal_set_main_index_lexicon_size(::int64_t value);
1081   public:
1082 
1083   // optional int64 main_index_storage_size = 5;
1084   bool has_main_index_storage_size() const;
1085   private:
1086   bool _internal_has_main_index_storage_size() const;
1087   public:
1088   void clear_main_index_storage_size();
1089   ::int64_t main_index_storage_size() const;
1090   void set_main_index_storage_size(::int64_t value);
1091   private:
1092   ::int64_t _internal_main_index_storage_size() const;
1093   void _internal_set_main_index_storage_size(::int64_t value);
1094   public:
1095 
1096   // optional int64 main_index_block_size = 6;
1097   bool has_main_index_block_size() const;
1098   private:
1099   bool _internal_has_main_index_block_size() const;
1100   public:
1101   void clear_main_index_block_size();
1102   ::int64_t main_index_block_size() const;
1103   void set_main_index_block_size(::int64_t value);
1104   private:
1105   ::int64_t _internal_main_index_block_size() const;
1106   void _internal_set_main_index_block_size(::int64_t value);
1107   public:
1108 
1109   // optional int32 num_blocks = 7;
1110   bool has_num_blocks() const;
1111   private:
1112   bool _internal_has_num_blocks() const;
1113   public:
1114   void clear_num_blocks();
1115   ::int32_t num_blocks() const;
1116   void set_num_blocks(::int32_t value);
1117   private:
1118   ::int32_t _internal_num_blocks() const;
1119   void _internal_set_num_blocks(::int32_t value);
1120   public:
1121 
1122   // optional float min_free_fraction = 8;
1123   bool has_min_free_fraction() const;
1124   private:
1125   bool _internal_has_min_free_fraction() const;
1126   public:
1127   void clear_min_free_fraction();
1128   float min_free_fraction() const;
1129   void set_min_free_fraction(float value);
1130   private:
1131   float _internal_min_free_fraction() const;
1132   void _internal_set_min_free_fraction(float value);
1133   public:
1134 
1135   // @@protoc_insertion_point(class_scope:icing.lib.IndexStorageInfoProto)
1136  private:
1137   class _Internal;
1138 
1139   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1140   typedef void InternalArenaConstructable_;
1141   typedef void DestructorSkippable_;
1142   struct Impl_ {
1143     ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
1144     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1145     ::int64_t index_size_;
1146     ::int64_t lite_index_lexicon_size_;
1147     ::int64_t lite_index_hit_buffer_size_;
1148     ::int64_t main_index_lexicon_size_;
1149     ::int64_t main_index_storage_size_;
1150     ::int64_t main_index_block_size_;
1151     ::int32_t num_blocks_;
1152     float min_free_fraction_;
1153   };
1154   union { Impl_ _impl_; };
1155   friend struct ::TableStruct_icing_2fproto_2fstorage_2eproto;
1156 };
1157 // -------------------------------------------------------------------
1158 
1159 class NamespaceBlobStorageInfoProto final :
1160     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:icing.lib.NamespaceBlobStorageInfoProto) */ {
1161  public:
NamespaceBlobStorageInfoProto()1162   inline NamespaceBlobStorageInfoProto() : NamespaceBlobStorageInfoProto(nullptr) {}
1163   ~NamespaceBlobStorageInfoProto() override;
1164   explicit PROTOBUF_CONSTEXPR NamespaceBlobStorageInfoProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1165 
1166   NamespaceBlobStorageInfoProto(const NamespaceBlobStorageInfoProto& from);
NamespaceBlobStorageInfoProto(NamespaceBlobStorageInfoProto && from)1167   NamespaceBlobStorageInfoProto(NamespaceBlobStorageInfoProto&& from) noexcept
1168     : NamespaceBlobStorageInfoProto() {
1169     *this = ::std::move(from);
1170   }
1171 
1172   inline NamespaceBlobStorageInfoProto& operator=(const NamespaceBlobStorageInfoProto& from) {
1173     if (this == &from) return *this;
1174     CopyFrom(from);
1175     return *this;
1176   }
1177   inline NamespaceBlobStorageInfoProto& operator=(NamespaceBlobStorageInfoProto&& from) noexcept {
1178     if (this == &from) return *this;
1179     if (GetOwningArena() == from.GetOwningArena()
1180   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1181         && GetOwningArena() != nullptr
1182   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
1183     ) {
1184       InternalSwap(&from);
1185     } else {
1186       CopyFrom(from);
1187     }
1188     return *this;
1189   }
1190 
unknown_fields()1191   inline const std::string& unknown_fields() const {
1192     return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
1193   }
mutable_unknown_fields()1194   inline std::string* mutable_unknown_fields() {
1195     return _internal_metadata_.mutable_unknown_fields<std::string>();
1196   }
1197 
default_instance()1198   static const NamespaceBlobStorageInfoProto& default_instance() {
1199     return *internal_default_instance();
1200   }
internal_default_instance()1201   static inline const NamespaceBlobStorageInfoProto* internal_default_instance() {
1202     return reinterpret_cast<const NamespaceBlobStorageInfoProto*>(
1203                &_NamespaceBlobStorageInfoProto_default_instance_);
1204   }
1205   static constexpr int kIndexInFileMessages =
1206     4;
1207 
swap(NamespaceBlobStorageInfoProto & a,NamespaceBlobStorageInfoProto & b)1208   friend void swap(NamespaceBlobStorageInfoProto& a, NamespaceBlobStorageInfoProto& b) {
1209     a.Swap(&b);
1210   }
Swap(NamespaceBlobStorageInfoProto * other)1211   inline void Swap(NamespaceBlobStorageInfoProto* other) {
1212     if (other == this) return;
1213   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1214     if (GetOwningArena() != nullptr &&
1215         GetOwningArena() == other->GetOwningArena()) {
1216    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
1217     if (GetOwningArena() == other->GetOwningArena()) {
1218   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
1219       InternalSwap(other);
1220     } else {
1221       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1222     }
1223   }
1224   void UnsafeArenaSwap(NamespaceBlobStorageInfoProto* other) {
1225     if (other == this) return;
1226     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1227     InternalSwap(other);
1228   }
1229 
1230   // implements Message ----------------------------------------------
1231 
1232   NamespaceBlobStorageInfoProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1233     return CreateMaybeMessage<NamespaceBlobStorageInfoProto>(arena);
1234   }
1235   NamespaceBlobStorageInfoProto* New() const {
1236     return New(nullptr);
1237   }
1238   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
1239   void CopyFrom(const NamespaceBlobStorageInfoProto& from);
1240   void MergeFrom(const NamespaceBlobStorageInfoProto& from);
1241   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1242   bool IsInitialized() const final;
1243 
1244   size_t ByteSizeLong() const final;
1245   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1246   ::uint8_t* _InternalSerialize(
1247       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1248   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1249 
1250   private:
1251   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1252   void SharedDtor();
1253   void SetCachedSize(int size) const;
1254   void InternalSwap(NamespaceBlobStorageInfoProto* other);
1255 
1256   private:
1257   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1258   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1259     return "icing.lib.NamespaceBlobStorageInfoProto";
1260   }
1261   protected:
1262   explicit NamespaceBlobStorageInfoProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1263                        bool is_message_owned = false);
1264   public:
1265 
1266   std::string GetTypeName() const final;
1267 
1268   // nested types ----------------------------------------------------
1269 
1270   // accessors -------------------------------------------------------
1271 
1272   enum : int {
1273     kNamespaceFieldNumber = 1,
1274     kBlobSizeFieldNumber = 2,
1275     kNumBlobsFieldNumber = 3,
1276   };
1277   // optional string namespace = 1;
1278   bool has_namespace_() const;
1279   private:
1280   bool _internal_has_namespace_() const;
1281   public:
1282   void clear_namespace_();
1283   const std::string& namespace_() const;
1284   template <typename ArgT0 = const std::string&, typename... ArgT>
1285   void set_namespace_(ArgT0&& arg0, ArgT... args);
1286   std::string* mutable_namespace_();
1287   PROTOBUF_NODISCARD std::string* release_namespace_();
1288   void set_allocated_namespace_(std::string* namespace_);
1289   private:
1290   const std::string& _internal_namespace_() const;
1291   inline PROTOBUF_ALWAYS_INLINE void _internal_set_namespace_(const std::string& value);
1292   std::string* _internal_mutable_namespace_();
1293   public:
1294 
1295   // optional int64 blob_size = 2;
1296   bool has_blob_size() const;
1297   private:
1298   bool _internal_has_blob_size() const;
1299   public:
1300   void clear_blob_size();
1301   ::int64_t blob_size() const;
1302   void set_blob_size(::int64_t value);
1303   private:
1304   ::int64_t _internal_blob_size() const;
1305   void _internal_set_blob_size(::int64_t value);
1306   public:
1307 
1308   // optional int32 num_blobs = 3;
1309   bool has_num_blobs() const;
1310   private:
1311   bool _internal_has_num_blobs() const;
1312   public:
1313   void clear_num_blobs();
1314   ::int32_t num_blobs() const;
1315   void set_num_blobs(::int32_t value);
1316   private:
1317   ::int32_t _internal_num_blobs() const;
1318   void _internal_set_num_blobs(::int32_t value);
1319   public:
1320 
1321   // @@protoc_insertion_point(class_scope:icing.lib.NamespaceBlobStorageInfoProto)
1322  private:
1323   class _Internal;
1324 
1325   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1326   typedef void InternalArenaConstructable_;
1327   typedef void DestructorSkippable_;
1328   struct Impl_ {
1329     ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
1330     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1331     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr namespace__;
1332     ::int64_t blob_size_;
1333     ::int32_t num_blobs_;
1334   };
1335   union { Impl_ _impl_; };
1336   friend struct ::TableStruct_icing_2fproto_2fstorage_2eproto;
1337 };
1338 // -------------------------------------------------------------------
1339 
1340 class StorageInfoProto final :
1341     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:icing.lib.StorageInfoProto) */ {
1342  public:
StorageInfoProto()1343   inline StorageInfoProto() : StorageInfoProto(nullptr) {}
1344   ~StorageInfoProto() override;
1345   explicit PROTOBUF_CONSTEXPR StorageInfoProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1346 
1347   StorageInfoProto(const StorageInfoProto& from);
StorageInfoProto(StorageInfoProto && from)1348   StorageInfoProto(StorageInfoProto&& from) noexcept
1349     : StorageInfoProto() {
1350     *this = ::std::move(from);
1351   }
1352 
1353   inline StorageInfoProto& operator=(const StorageInfoProto& from) {
1354     if (this == &from) return *this;
1355     CopyFrom(from);
1356     return *this;
1357   }
1358   inline StorageInfoProto& operator=(StorageInfoProto&& from) noexcept {
1359     if (this == &from) return *this;
1360     if (GetOwningArena() == from.GetOwningArena()
1361   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1362         && GetOwningArena() != nullptr
1363   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
1364     ) {
1365       InternalSwap(&from);
1366     } else {
1367       CopyFrom(from);
1368     }
1369     return *this;
1370   }
1371 
unknown_fields()1372   inline const std::string& unknown_fields() const {
1373     return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
1374   }
mutable_unknown_fields()1375   inline std::string* mutable_unknown_fields() {
1376     return _internal_metadata_.mutable_unknown_fields<std::string>();
1377   }
1378 
default_instance()1379   static const StorageInfoProto& default_instance() {
1380     return *internal_default_instance();
1381   }
internal_default_instance()1382   static inline const StorageInfoProto* internal_default_instance() {
1383     return reinterpret_cast<const StorageInfoProto*>(
1384                &_StorageInfoProto_default_instance_);
1385   }
1386   static constexpr int kIndexInFileMessages =
1387     5;
1388 
swap(StorageInfoProto & a,StorageInfoProto & b)1389   friend void swap(StorageInfoProto& a, StorageInfoProto& b) {
1390     a.Swap(&b);
1391   }
Swap(StorageInfoProto * other)1392   inline void Swap(StorageInfoProto* other) {
1393     if (other == this) return;
1394   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1395     if (GetOwningArena() != nullptr &&
1396         GetOwningArena() == other->GetOwningArena()) {
1397    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
1398     if (GetOwningArena() == other->GetOwningArena()) {
1399   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
1400       InternalSwap(other);
1401     } else {
1402       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1403     }
1404   }
1405   void UnsafeArenaSwap(StorageInfoProto* other) {
1406     if (other == this) return;
1407     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1408     InternalSwap(other);
1409   }
1410 
1411   // implements Message ----------------------------------------------
1412 
1413   StorageInfoProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1414     return CreateMaybeMessage<StorageInfoProto>(arena);
1415   }
1416   StorageInfoProto* New() const {
1417     return New(nullptr);
1418   }
1419   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
1420   void CopyFrom(const StorageInfoProto& from);
1421   void MergeFrom(const StorageInfoProto& from);
1422   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1423   bool IsInitialized() const final;
1424 
1425   size_t ByteSizeLong() const final;
1426   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1427   ::uint8_t* _InternalSerialize(
1428       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1429   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1430 
1431   private:
1432   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1433   void SharedDtor();
1434   void SetCachedSize(int size) const;
1435   void InternalSwap(StorageInfoProto* other);
1436 
1437   private:
1438   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1439   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1440     return "icing.lib.StorageInfoProto";
1441   }
1442   protected:
1443   explicit StorageInfoProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1444                        bool is_message_owned = false);
1445   public:
1446 
1447   std::string GetTypeName() const final;
1448 
1449   // nested types ----------------------------------------------------
1450 
1451   // accessors -------------------------------------------------------
1452 
1453   enum : int {
1454     kNamespaceBlobStorageInfoFieldNumber = 5,
1455     kDocumentStorageInfoFieldNumber = 2,
1456     kSchemaStoreStorageInfoFieldNumber = 3,
1457     kIndexStorageInfoFieldNumber = 4,
1458     kTotalStorageSizeFieldNumber = 1,
1459   };
1460   // repeated .icing.lib.NamespaceBlobStorageInfoProto namespace_blob_storage_info = 5;
1461   int namespace_blob_storage_info_size() const;
1462   private:
1463   int _internal_namespace_blob_storage_info_size() const;
1464   public:
1465   void clear_namespace_blob_storage_info();
1466   ::icing::lib::NamespaceBlobStorageInfoProto* mutable_namespace_blob_storage_info(int index);
1467   ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::NamespaceBlobStorageInfoProto >*
1468       mutable_namespace_blob_storage_info();
1469   private:
1470   const ::icing::lib::NamespaceBlobStorageInfoProto& _internal_namespace_blob_storage_info(int index) const;
1471   ::icing::lib::NamespaceBlobStorageInfoProto* _internal_add_namespace_blob_storage_info();
1472   public:
1473   const ::icing::lib::NamespaceBlobStorageInfoProto& namespace_blob_storage_info(int index) const;
1474   ::icing::lib::NamespaceBlobStorageInfoProto* add_namespace_blob_storage_info();
1475   const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::NamespaceBlobStorageInfoProto >&
1476       namespace_blob_storage_info() const;
1477 
1478   // optional .icing.lib.DocumentStorageInfoProto document_storage_info = 2;
1479   bool has_document_storage_info() const;
1480   private:
1481   bool _internal_has_document_storage_info() const;
1482   public:
1483   void clear_document_storage_info();
1484   const ::icing::lib::DocumentStorageInfoProto& document_storage_info() const;
1485   PROTOBUF_NODISCARD ::icing::lib::DocumentStorageInfoProto* release_document_storage_info();
1486   ::icing::lib::DocumentStorageInfoProto* mutable_document_storage_info();
1487   void set_allocated_document_storage_info(::icing::lib::DocumentStorageInfoProto* document_storage_info);
1488   private:
1489   const ::icing::lib::DocumentStorageInfoProto& _internal_document_storage_info() const;
1490   ::icing::lib::DocumentStorageInfoProto* _internal_mutable_document_storage_info();
1491   public:
1492   void unsafe_arena_set_allocated_document_storage_info(
1493       ::icing::lib::DocumentStorageInfoProto* document_storage_info);
1494   ::icing::lib::DocumentStorageInfoProto* unsafe_arena_release_document_storage_info();
1495 
1496   // optional .icing.lib.SchemaStoreStorageInfoProto schema_store_storage_info = 3;
1497   bool has_schema_store_storage_info() const;
1498   private:
1499   bool _internal_has_schema_store_storage_info() const;
1500   public:
1501   void clear_schema_store_storage_info();
1502   const ::icing::lib::SchemaStoreStorageInfoProto& schema_store_storage_info() const;
1503   PROTOBUF_NODISCARD ::icing::lib::SchemaStoreStorageInfoProto* release_schema_store_storage_info();
1504   ::icing::lib::SchemaStoreStorageInfoProto* mutable_schema_store_storage_info();
1505   void set_allocated_schema_store_storage_info(::icing::lib::SchemaStoreStorageInfoProto* schema_store_storage_info);
1506   private:
1507   const ::icing::lib::SchemaStoreStorageInfoProto& _internal_schema_store_storage_info() const;
1508   ::icing::lib::SchemaStoreStorageInfoProto* _internal_mutable_schema_store_storage_info();
1509   public:
1510   void unsafe_arena_set_allocated_schema_store_storage_info(
1511       ::icing::lib::SchemaStoreStorageInfoProto* schema_store_storage_info);
1512   ::icing::lib::SchemaStoreStorageInfoProto* unsafe_arena_release_schema_store_storage_info();
1513 
1514   // optional .icing.lib.IndexStorageInfoProto index_storage_info = 4;
1515   bool has_index_storage_info() const;
1516   private:
1517   bool _internal_has_index_storage_info() const;
1518   public:
1519   void clear_index_storage_info();
1520   const ::icing::lib::IndexStorageInfoProto& index_storage_info() const;
1521   PROTOBUF_NODISCARD ::icing::lib::IndexStorageInfoProto* release_index_storage_info();
1522   ::icing::lib::IndexStorageInfoProto* mutable_index_storage_info();
1523   void set_allocated_index_storage_info(::icing::lib::IndexStorageInfoProto* index_storage_info);
1524   private:
1525   const ::icing::lib::IndexStorageInfoProto& _internal_index_storage_info() const;
1526   ::icing::lib::IndexStorageInfoProto* _internal_mutable_index_storage_info();
1527   public:
1528   void unsafe_arena_set_allocated_index_storage_info(
1529       ::icing::lib::IndexStorageInfoProto* index_storage_info);
1530   ::icing::lib::IndexStorageInfoProto* unsafe_arena_release_index_storage_info();
1531 
1532   // optional int64 total_storage_size = 1;
1533   bool has_total_storage_size() const;
1534   private:
1535   bool _internal_has_total_storage_size() const;
1536   public:
1537   void clear_total_storage_size();
1538   ::int64_t total_storage_size() const;
1539   void set_total_storage_size(::int64_t value);
1540   private:
1541   ::int64_t _internal_total_storage_size() const;
1542   void _internal_set_total_storage_size(::int64_t value);
1543   public:
1544 
1545   // @@protoc_insertion_point(class_scope:icing.lib.StorageInfoProto)
1546  private:
1547   class _Internal;
1548 
1549   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1550   typedef void InternalArenaConstructable_;
1551   typedef void DestructorSkippable_;
1552   struct Impl_ {
1553     ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
1554     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1555     ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::NamespaceBlobStorageInfoProto > namespace_blob_storage_info_;
1556     ::icing::lib::DocumentStorageInfoProto* document_storage_info_;
1557     ::icing::lib::SchemaStoreStorageInfoProto* schema_store_storage_info_;
1558     ::icing::lib::IndexStorageInfoProto* index_storage_info_;
1559     ::int64_t total_storage_size_;
1560   };
1561   union { Impl_ _impl_; };
1562   friend struct ::TableStruct_icing_2fproto_2fstorage_2eproto;
1563 };
1564 // -------------------------------------------------------------------
1565 
1566 class StorageInfoResultProto final :
1567     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:icing.lib.StorageInfoResultProto) */ {
1568  public:
StorageInfoResultProto()1569   inline StorageInfoResultProto() : StorageInfoResultProto(nullptr) {}
1570   ~StorageInfoResultProto() override;
1571   explicit PROTOBUF_CONSTEXPR StorageInfoResultProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1572 
1573   StorageInfoResultProto(const StorageInfoResultProto& from);
StorageInfoResultProto(StorageInfoResultProto && from)1574   StorageInfoResultProto(StorageInfoResultProto&& from) noexcept
1575     : StorageInfoResultProto() {
1576     *this = ::std::move(from);
1577   }
1578 
1579   inline StorageInfoResultProto& operator=(const StorageInfoResultProto& from) {
1580     if (this == &from) return *this;
1581     CopyFrom(from);
1582     return *this;
1583   }
1584   inline StorageInfoResultProto& operator=(StorageInfoResultProto&& from) noexcept {
1585     if (this == &from) return *this;
1586     if (GetOwningArena() == from.GetOwningArena()
1587   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1588         && GetOwningArena() != nullptr
1589   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
1590     ) {
1591       InternalSwap(&from);
1592     } else {
1593       CopyFrom(from);
1594     }
1595     return *this;
1596   }
1597 
unknown_fields()1598   inline const std::string& unknown_fields() const {
1599     return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
1600   }
mutable_unknown_fields()1601   inline std::string* mutable_unknown_fields() {
1602     return _internal_metadata_.mutable_unknown_fields<std::string>();
1603   }
1604 
default_instance()1605   static const StorageInfoResultProto& default_instance() {
1606     return *internal_default_instance();
1607   }
internal_default_instance()1608   static inline const StorageInfoResultProto* internal_default_instance() {
1609     return reinterpret_cast<const StorageInfoResultProto*>(
1610                &_StorageInfoResultProto_default_instance_);
1611   }
1612   static constexpr int kIndexInFileMessages =
1613     6;
1614 
swap(StorageInfoResultProto & a,StorageInfoResultProto & b)1615   friend void swap(StorageInfoResultProto& a, StorageInfoResultProto& b) {
1616     a.Swap(&b);
1617   }
Swap(StorageInfoResultProto * other)1618   inline void Swap(StorageInfoResultProto* other) {
1619     if (other == this) return;
1620   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1621     if (GetOwningArena() != nullptr &&
1622         GetOwningArena() == other->GetOwningArena()) {
1623    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
1624     if (GetOwningArena() == other->GetOwningArena()) {
1625   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
1626       InternalSwap(other);
1627     } else {
1628       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1629     }
1630   }
1631   void UnsafeArenaSwap(StorageInfoResultProto* other) {
1632     if (other == this) return;
1633     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1634     InternalSwap(other);
1635   }
1636 
1637   // implements Message ----------------------------------------------
1638 
1639   StorageInfoResultProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1640     return CreateMaybeMessage<StorageInfoResultProto>(arena);
1641   }
1642   StorageInfoResultProto* New() const {
1643     return New(nullptr);
1644   }
1645   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
1646   void CopyFrom(const StorageInfoResultProto& from);
1647   void MergeFrom(const StorageInfoResultProto& from);
1648   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1649   bool IsInitialized() const final;
1650 
1651   size_t ByteSizeLong() const final;
1652   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1653   ::uint8_t* _InternalSerialize(
1654       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1655   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1656 
1657   private:
1658   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1659   void SharedDtor();
1660   void SetCachedSize(int size) const;
1661   void InternalSwap(StorageInfoResultProto* other);
1662 
1663   private:
1664   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1665   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1666     return "icing.lib.StorageInfoResultProto";
1667   }
1668   protected:
1669   explicit StorageInfoResultProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1670                        bool is_message_owned = false);
1671   public:
1672 
1673   std::string GetTypeName() const final;
1674 
1675   // nested types ----------------------------------------------------
1676 
1677   // accessors -------------------------------------------------------
1678 
1679   enum : int {
1680     kStatusFieldNumber = 1,
1681     kStorageInfoFieldNumber = 2,
1682   };
1683   // optional .icing.lib.StatusProto status = 1;
1684   bool has_status() const;
1685   private:
1686   bool _internal_has_status() const;
1687   public:
1688   void clear_status();
1689   const ::icing::lib::StatusProto& status() const;
1690   PROTOBUF_NODISCARD ::icing::lib::StatusProto* release_status();
1691   ::icing::lib::StatusProto* mutable_status();
1692   void set_allocated_status(::icing::lib::StatusProto* status);
1693   private:
1694   const ::icing::lib::StatusProto& _internal_status() const;
1695   ::icing::lib::StatusProto* _internal_mutable_status();
1696   public:
1697   void unsafe_arena_set_allocated_status(
1698       ::icing::lib::StatusProto* status);
1699   ::icing::lib::StatusProto* unsafe_arena_release_status();
1700 
1701   // optional .icing.lib.StorageInfoProto storage_info = 2;
1702   bool has_storage_info() const;
1703   private:
1704   bool _internal_has_storage_info() const;
1705   public:
1706   void clear_storage_info();
1707   const ::icing::lib::StorageInfoProto& storage_info() const;
1708   PROTOBUF_NODISCARD ::icing::lib::StorageInfoProto* release_storage_info();
1709   ::icing::lib::StorageInfoProto* mutable_storage_info();
1710   void set_allocated_storage_info(::icing::lib::StorageInfoProto* storage_info);
1711   private:
1712   const ::icing::lib::StorageInfoProto& _internal_storage_info() const;
1713   ::icing::lib::StorageInfoProto* _internal_mutable_storage_info();
1714   public:
1715   void unsafe_arena_set_allocated_storage_info(
1716       ::icing::lib::StorageInfoProto* storage_info);
1717   ::icing::lib::StorageInfoProto* unsafe_arena_release_storage_info();
1718 
1719   // @@protoc_insertion_point(class_scope:icing.lib.StorageInfoResultProto)
1720  private:
1721   class _Internal;
1722 
1723   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1724   typedef void InternalArenaConstructable_;
1725   typedef void DestructorSkippable_;
1726   struct Impl_ {
1727     ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
1728     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1729     ::icing::lib::StatusProto* status_;
1730     ::icing::lib::StorageInfoProto* storage_info_;
1731   };
1732   union { Impl_ _impl_; };
1733   friend struct ::TableStruct_icing_2fproto_2fstorage_2eproto;
1734 };
1735 // ===================================================================
1736 
1737 
1738 // ===================================================================
1739 
1740 #ifdef __GNUC__
1741   #pragma GCC diagnostic push
1742   #pragma GCC diagnostic ignored "-Wstrict-aliasing"
1743 #endif  // __GNUC__
1744 // NamespaceStorageInfoProto
1745 
1746 // optional string namespace = 1;
_internal_has_namespace_()1747 inline bool NamespaceStorageInfoProto::_internal_has_namespace_() const {
1748   bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
1749   return value;
1750 }
has_namespace_()1751 inline bool NamespaceStorageInfoProto::has_namespace_() const {
1752   return _internal_has_namespace_();
1753 }
clear_namespace_()1754 inline void NamespaceStorageInfoProto::clear_namespace_() {
1755   _impl_.namespace__.ClearToEmpty();
1756   _impl_._has_bits_[0] &= ~0x00000001u;
1757 }
namespace_()1758 inline const std::string& NamespaceStorageInfoProto::namespace_() const {
1759   // @@protoc_insertion_point(field_get:icing.lib.NamespaceStorageInfoProto.namespace)
1760   return _internal_namespace_();
1761 }
1762 template <typename ArgT0, typename... ArgT>
1763 inline PROTOBUF_ALWAYS_INLINE
set_namespace_(ArgT0 && arg0,ArgT...args)1764 void NamespaceStorageInfoProto::set_namespace_(ArgT0&& arg0, ArgT... args) {
1765  _impl_._has_bits_[0] |= 0x00000001u;
1766  _impl_.namespace__.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
1767   // @@protoc_insertion_point(field_set:icing.lib.NamespaceStorageInfoProto.namespace)
1768 }
mutable_namespace_()1769 inline std::string* NamespaceStorageInfoProto::mutable_namespace_() {
1770   std::string* _s = _internal_mutable_namespace_();
1771   // @@protoc_insertion_point(field_mutable:icing.lib.NamespaceStorageInfoProto.namespace)
1772   return _s;
1773 }
_internal_namespace_()1774 inline const std::string& NamespaceStorageInfoProto::_internal_namespace_() const {
1775   return _impl_.namespace__.Get();
1776 }
_internal_set_namespace_(const std::string & value)1777 inline void NamespaceStorageInfoProto::_internal_set_namespace_(const std::string& value) {
1778   _impl_._has_bits_[0] |= 0x00000001u;
1779   _impl_.namespace__.Set(value, GetArenaForAllocation());
1780 }
_internal_mutable_namespace_()1781 inline std::string* NamespaceStorageInfoProto::_internal_mutable_namespace_() {
1782   _impl_._has_bits_[0] |= 0x00000001u;
1783   return _impl_.namespace__.Mutable(GetArenaForAllocation());
1784 }
release_namespace_()1785 inline std::string* NamespaceStorageInfoProto::release_namespace_() {
1786   // @@protoc_insertion_point(field_release:icing.lib.NamespaceStorageInfoProto.namespace)
1787   if (!_internal_has_namespace_()) {
1788     return nullptr;
1789   }
1790   _impl_._has_bits_[0] &= ~0x00000001u;
1791   auto* p = _impl_.namespace__.Release();
1792 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1793   if (_impl_.namespace__.IsDefault()) {
1794     _impl_.namespace__.Set("", GetArenaForAllocation());
1795   }
1796 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1797   return p;
1798 }
set_allocated_namespace_(std::string * namespace_)1799 inline void NamespaceStorageInfoProto::set_allocated_namespace_(std::string* namespace_) {
1800   if (namespace_ != nullptr) {
1801     _impl_._has_bits_[0] |= 0x00000001u;
1802   } else {
1803     _impl_._has_bits_[0] &= ~0x00000001u;
1804   }
1805   _impl_.namespace__.SetAllocated(namespace_, GetArenaForAllocation());
1806 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1807   if (_impl_.namespace__.IsDefault()) {
1808     _impl_.namespace__.Set("", GetArenaForAllocation());
1809   }
1810 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1811   // @@protoc_insertion_point(field_set_allocated:icing.lib.NamespaceStorageInfoProto.namespace)
1812 }
1813 
1814 // optional int32 num_alive_documents = 2;
_internal_has_num_alive_documents()1815 inline bool NamespaceStorageInfoProto::_internal_has_num_alive_documents() const {
1816   bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
1817   return value;
1818 }
has_num_alive_documents()1819 inline bool NamespaceStorageInfoProto::has_num_alive_documents() const {
1820   return _internal_has_num_alive_documents();
1821 }
clear_num_alive_documents()1822 inline void NamespaceStorageInfoProto::clear_num_alive_documents() {
1823   _impl_.num_alive_documents_ = 0;
1824   _impl_._has_bits_[0] &= ~0x00000002u;
1825 }
_internal_num_alive_documents()1826 inline ::int32_t NamespaceStorageInfoProto::_internal_num_alive_documents() const {
1827   return _impl_.num_alive_documents_;
1828 }
num_alive_documents()1829 inline ::int32_t NamespaceStorageInfoProto::num_alive_documents() const {
1830   // @@protoc_insertion_point(field_get:icing.lib.NamespaceStorageInfoProto.num_alive_documents)
1831   return _internal_num_alive_documents();
1832 }
_internal_set_num_alive_documents(::int32_t value)1833 inline void NamespaceStorageInfoProto::_internal_set_num_alive_documents(::int32_t value) {
1834   _impl_._has_bits_[0] |= 0x00000002u;
1835   _impl_.num_alive_documents_ = value;
1836 }
set_num_alive_documents(::int32_t value)1837 inline void NamespaceStorageInfoProto::set_num_alive_documents(::int32_t value) {
1838   _internal_set_num_alive_documents(value);
1839   // @@protoc_insertion_point(field_set:icing.lib.NamespaceStorageInfoProto.num_alive_documents)
1840 }
1841 
1842 // optional int32 num_expired_documents = 3;
_internal_has_num_expired_documents()1843 inline bool NamespaceStorageInfoProto::_internal_has_num_expired_documents() const {
1844   bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
1845   return value;
1846 }
has_num_expired_documents()1847 inline bool NamespaceStorageInfoProto::has_num_expired_documents() const {
1848   return _internal_has_num_expired_documents();
1849 }
clear_num_expired_documents()1850 inline void NamespaceStorageInfoProto::clear_num_expired_documents() {
1851   _impl_.num_expired_documents_ = 0;
1852   _impl_._has_bits_[0] &= ~0x00000004u;
1853 }
_internal_num_expired_documents()1854 inline ::int32_t NamespaceStorageInfoProto::_internal_num_expired_documents() const {
1855   return _impl_.num_expired_documents_;
1856 }
num_expired_documents()1857 inline ::int32_t NamespaceStorageInfoProto::num_expired_documents() const {
1858   // @@protoc_insertion_point(field_get:icing.lib.NamespaceStorageInfoProto.num_expired_documents)
1859   return _internal_num_expired_documents();
1860 }
_internal_set_num_expired_documents(::int32_t value)1861 inline void NamespaceStorageInfoProto::_internal_set_num_expired_documents(::int32_t value) {
1862   _impl_._has_bits_[0] |= 0x00000004u;
1863   _impl_.num_expired_documents_ = value;
1864 }
set_num_expired_documents(::int32_t value)1865 inline void NamespaceStorageInfoProto::set_num_expired_documents(::int32_t value) {
1866   _internal_set_num_expired_documents(value);
1867   // @@protoc_insertion_point(field_set:icing.lib.NamespaceStorageInfoProto.num_expired_documents)
1868 }
1869 
1870 // optional int32 num_alive_documents_usage_type1 = 4;
_internal_has_num_alive_documents_usage_type1()1871 inline bool NamespaceStorageInfoProto::_internal_has_num_alive_documents_usage_type1() const {
1872   bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
1873   return value;
1874 }
has_num_alive_documents_usage_type1()1875 inline bool NamespaceStorageInfoProto::has_num_alive_documents_usage_type1() const {
1876   return _internal_has_num_alive_documents_usage_type1();
1877 }
clear_num_alive_documents_usage_type1()1878 inline void NamespaceStorageInfoProto::clear_num_alive_documents_usage_type1() {
1879   _impl_.num_alive_documents_usage_type1_ = 0;
1880   _impl_._has_bits_[0] &= ~0x00000008u;
1881 }
_internal_num_alive_documents_usage_type1()1882 inline ::int32_t NamespaceStorageInfoProto::_internal_num_alive_documents_usage_type1() const {
1883   return _impl_.num_alive_documents_usage_type1_;
1884 }
num_alive_documents_usage_type1()1885 inline ::int32_t NamespaceStorageInfoProto::num_alive_documents_usage_type1() const {
1886   // @@protoc_insertion_point(field_get:icing.lib.NamespaceStorageInfoProto.num_alive_documents_usage_type1)
1887   return _internal_num_alive_documents_usage_type1();
1888 }
_internal_set_num_alive_documents_usage_type1(::int32_t value)1889 inline void NamespaceStorageInfoProto::_internal_set_num_alive_documents_usage_type1(::int32_t value) {
1890   _impl_._has_bits_[0] |= 0x00000008u;
1891   _impl_.num_alive_documents_usage_type1_ = value;
1892 }
set_num_alive_documents_usage_type1(::int32_t value)1893 inline void NamespaceStorageInfoProto::set_num_alive_documents_usage_type1(::int32_t value) {
1894   _internal_set_num_alive_documents_usage_type1(value);
1895   // @@protoc_insertion_point(field_set:icing.lib.NamespaceStorageInfoProto.num_alive_documents_usage_type1)
1896 }
1897 
1898 // optional int32 num_alive_documents_usage_type2 = 5;
_internal_has_num_alive_documents_usage_type2()1899 inline bool NamespaceStorageInfoProto::_internal_has_num_alive_documents_usage_type2() const {
1900   bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
1901   return value;
1902 }
has_num_alive_documents_usage_type2()1903 inline bool NamespaceStorageInfoProto::has_num_alive_documents_usage_type2() const {
1904   return _internal_has_num_alive_documents_usage_type2();
1905 }
clear_num_alive_documents_usage_type2()1906 inline void NamespaceStorageInfoProto::clear_num_alive_documents_usage_type2() {
1907   _impl_.num_alive_documents_usage_type2_ = 0;
1908   _impl_._has_bits_[0] &= ~0x00000010u;
1909 }
_internal_num_alive_documents_usage_type2()1910 inline ::int32_t NamespaceStorageInfoProto::_internal_num_alive_documents_usage_type2() const {
1911   return _impl_.num_alive_documents_usage_type2_;
1912 }
num_alive_documents_usage_type2()1913 inline ::int32_t NamespaceStorageInfoProto::num_alive_documents_usage_type2() const {
1914   // @@protoc_insertion_point(field_get:icing.lib.NamespaceStorageInfoProto.num_alive_documents_usage_type2)
1915   return _internal_num_alive_documents_usage_type2();
1916 }
_internal_set_num_alive_documents_usage_type2(::int32_t value)1917 inline void NamespaceStorageInfoProto::_internal_set_num_alive_documents_usage_type2(::int32_t value) {
1918   _impl_._has_bits_[0] |= 0x00000010u;
1919   _impl_.num_alive_documents_usage_type2_ = value;
1920 }
set_num_alive_documents_usage_type2(::int32_t value)1921 inline void NamespaceStorageInfoProto::set_num_alive_documents_usage_type2(::int32_t value) {
1922   _internal_set_num_alive_documents_usage_type2(value);
1923   // @@protoc_insertion_point(field_set:icing.lib.NamespaceStorageInfoProto.num_alive_documents_usage_type2)
1924 }
1925 
1926 // optional int32 num_alive_documents_usage_type3 = 6;
_internal_has_num_alive_documents_usage_type3()1927 inline bool NamespaceStorageInfoProto::_internal_has_num_alive_documents_usage_type3() const {
1928   bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
1929   return value;
1930 }
has_num_alive_documents_usage_type3()1931 inline bool NamespaceStorageInfoProto::has_num_alive_documents_usage_type3() const {
1932   return _internal_has_num_alive_documents_usage_type3();
1933 }
clear_num_alive_documents_usage_type3()1934 inline void NamespaceStorageInfoProto::clear_num_alive_documents_usage_type3() {
1935   _impl_.num_alive_documents_usage_type3_ = 0;
1936   _impl_._has_bits_[0] &= ~0x00000020u;
1937 }
_internal_num_alive_documents_usage_type3()1938 inline ::int32_t NamespaceStorageInfoProto::_internal_num_alive_documents_usage_type3() const {
1939   return _impl_.num_alive_documents_usage_type3_;
1940 }
num_alive_documents_usage_type3()1941 inline ::int32_t NamespaceStorageInfoProto::num_alive_documents_usage_type3() const {
1942   // @@protoc_insertion_point(field_get:icing.lib.NamespaceStorageInfoProto.num_alive_documents_usage_type3)
1943   return _internal_num_alive_documents_usage_type3();
1944 }
_internal_set_num_alive_documents_usage_type3(::int32_t value)1945 inline void NamespaceStorageInfoProto::_internal_set_num_alive_documents_usage_type3(::int32_t value) {
1946   _impl_._has_bits_[0] |= 0x00000020u;
1947   _impl_.num_alive_documents_usage_type3_ = value;
1948 }
set_num_alive_documents_usage_type3(::int32_t value)1949 inline void NamespaceStorageInfoProto::set_num_alive_documents_usage_type3(::int32_t value) {
1950   _internal_set_num_alive_documents_usage_type3(value);
1951   // @@protoc_insertion_point(field_set:icing.lib.NamespaceStorageInfoProto.num_alive_documents_usage_type3)
1952 }
1953 
1954 // optional int32 num_expired_documents_usage_type1 = 7;
_internal_has_num_expired_documents_usage_type1()1955 inline bool NamespaceStorageInfoProto::_internal_has_num_expired_documents_usage_type1() const {
1956   bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
1957   return value;
1958 }
has_num_expired_documents_usage_type1()1959 inline bool NamespaceStorageInfoProto::has_num_expired_documents_usage_type1() const {
1960   return _internal_has_num_expired_documents_usage_type1();
1961 }
clear_num_expired_documents_usage_type1()1962 inline void NamespaceStorageInfoProto::clear_num_expired_documents_usage_type1() {
1963   _impl_.num_expired_documents_usage_type1_ = 0;
1964   _impl_._has_bits_[0] &= ~0x00000040u;
1965 }
_internal_num_expired_documents_usage_type1()1966 inline ::int32_t NamespaceStorageInfoProto::_internal_num_expired_documents_usage_type1() const {
1967   return _impl_.num_expired_documents_usage_type1_;
1968 }
num_expired_documents_usage_type1()1969 inline ::int32_t NamespaceStorageInfoProto::num_expired_documents_usage_type1() const {
1970   // @@protoc_insertion_point(field_get:icing.lib.NamespaceStorageInfoProto.num_expired_documents_usage_type1)
1971   return _internal_num_expired_documents_usage_type1();
1972 }
_internal_set_num_expired_documents_usage_type1(::int32_t value)1973 inline void NamespaceStorageInfoProto::_internal_set_num_expired_documents_usage_type1(::int32_t value) {
1974   _impl_._has_bits_[0] |= 0x00000040u;
1975   _impl_.num_expired_documents_usage_type1_ = value;
1976 }
set_num_expired_documents_usage_type1(::int32_t value)1977 inline void NamespaceStorageInfoProto::set_num_expired_documents_usage_type1(::int32_t value) {
1978   _internal_set_num_expired_documents_usage_type1(value);
1979   // @@protoc_insertion_point(field_set:icing.lib.NamespaceStorageInfoProto.num_expired_documents_usage_type1)
1980 }
1981 
1982 // optional int32 num_expired_documents_usage_type2 = 8;
_internal_has_num_expired_documents_usage_type2()1983 inline bool NamespaceStorageInfoProto::_internal_has_num_expired_documents_usage_type2() const {
1984   bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
1985   return value;
1986 }
has_num_expired_documents_usage_type2()1987 inline bool NamespaceStorageInfoProto::has_num_expired_documents_usage_type2() const {
1988   return _internal_has_num_expired_documents_usage_type2();
1989 }
clear_num_expired_documents_usage_type2()1990 inline void NamespaceStorageInfoProto::clear_num_expired_documents_usage_type2() {
1991   _impl_.num_expired_documents_usage_type2_ = 0;
1992   _impl_._has_bits_[0] &= ~0x00000080u;
1993 }
_internal_num_expired_documents_usage_type2()1994 inline ::int32_t NamespaceStorageInfoProto::_internal_num_expired_documents_usage_type2() const {
1995   return _impl_.num_expired_documents_usage_type2_;
1996 }
num_expired_documents_usage_type2()1997 inline ::int32_t NamespaceStorageInfoProto::num_expired_documents_usage_type2() const {
1998   // @@protoc_insertion_point(field_get:icing.lib.NamespaceStorageInfoProto.num_expired_documents_usage_type2)
1999   return _internal_num_expired_documents_usage_type2();
2000 }
_internal_set_num_expired_documents_usage_type2(::int32_t value)2001 inline void NamespaceStorageInfoProto::_internal_set_num_expired_documents_usage_type2(::int32_t value) {
2002   _impl_._has_bits_[0] |= 0x00000080u;
2003   _impl_.num_expired_documents_usage_type2_ = value;
2004 }
set_num_expired_documents_usage_type2(::int32_t value)2005 inline void NamespaceStorageInfoProto::set_num_expired_documents_usage_type2(::int32_t value) {
2006   _internal_set_num_expired_documents_usage_type2(value);
2007   // @@protoc_insertion_point(field_set:icing.lib.NamespaceStorageInfoProto.num_expired_documents_usage_type2)
2008 }
2009 
2010 // optional int32 num_expired_documents_usage_type3 = 9;
_internal_has_num_expired_documents_usage_type3()2011 inline bool NamespaceStorageInfoProto::_internal_has_num_expired_documents_usage_type3() const {
2012   bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
2013   return value;
2014 }
has_num_expired_documents_usage_type3()2015 inline bool NamespaceStorageInfoProto::has_num_expired_documents_usage_type3() const {
2016   return _internal_has_num_expired_documents_usage_type3();
2017 }
clear_num_expired_documents_usage_type3()2018 inline void NamespaceStorageInfoProto::clear_num_expired_documents_usage_type3() {
2019   _impl_.num_expired_documents_usage_type3_ = 0;
2020   _impl_._has_bits_[0] &= ~0x00000100u;
2021 }
_internal_num_expired_documents_usage_type3()2022 inline ::int32_t NamespaceStorageInfoProto::_internal_num_expired_documents_usage_type3() const {
2023   return _impl_.num_expired_documents_usage_type3_;
2024 }
num_expired_documents_usage_type3()2025 inline ::int32_t NamespaceStorageInfoProto::num_expired_documents_usage_type3() const {
2026   // @@protoc_insertion_point(field_get:icing.lib.NamespaceStorageInfoProto.num_expired_documents_usage_type3)
2027   return _internal_num_expired_documents_usage_type3();
2028 }
_internal_set_num_expired_documents_usage_type3(::int32_t value)2029 inline void NamespaceStorageInfoProto::_internal_set_num_expired_documents_usage_type3(::int32_t value) {
2030   _impl_._has_bits_[0] |= 0x00000100u;
2031   _impl_.num_expired_documents_usage_type3_ = value;
2032 }
set_num_expired_documents_usage_type3(::int32_t value)2033 inline void NamespaceStorageInfoProto::set_num_expired_documents_usage_type3(::int32_t value) {
2034   _internal_set_num_expired_documents_usage_type3(value);
2035   // @@protoc_insertion_point(field_set:icing.lib.NamespaceStorageInfoProto.num_expired_documents_usage_type3)
2036 }
2037 
2038 // -------------------------------------------------------------------
2039 
2040 // DocumentStorageInfoProto
2041 
2042 // optional int32 num_alive_documents = 1;
_internal_has_num_alive_documents()2043 inline bool DocumentStorageInfoProto::_internal_has_num_alive_documents() const {
2044   bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
2045   return value;
2046 }
has_num_alive_documents()2047 inline bool DocumentStorageInfoProto::has_num_alive_documents() const {
2048   return _internal_has_num_alive_documents();
2049 }
clear_num_alive_documents()2050 inline void DocumentStorageInfoProto::clear_num_alive_documents() {
2051   _impl_.num_alive_documents_ = 0;
2052   _impl_._has_bits_[0] &= ~0x00000001u;
2053 }
_internal_num_alive_documents()2054 inline ::int32_t DocumentStorageInfoProto::_internal_num_alive_documents() const {
2055   return _impl_.num_alive_documents_;
2056 }
num_alive_documents()2057 inline ::int32_t DocumentStorageInfoProto::num_alive_documents() const {
2058   // @@protoc_insertion_point(field_get:icing.lib.DocumentStorageInfoProto.num_alive_documents)
2059   return _internal_num_alive_documents();
2060 }
_internal_set_num_alive_documents(::int32_t value)2061 inline void DocumentStorageInfoProto::_internal_set_num_alive_documents(::int32_t value) {
2062   _impl_._has_bits_[0] |= 0x00000001u;
2063   _impl_.num_alive_documents_ = value;
2064 }
set_num_alive_documents(::int32_t value)2065 inline void DocumentStorageInfoProto::set_num_alive_documents(::int32_t value) {
2066   _internal_set_num_alive_documents(value);
2067   // @@protoc_insertion_point(field_set:icing.lib.DocumentStorageInfoProto.num_alive_documents)
2068 }
2069 
2070 // optional int32 num_deleted_documents = 2;
_internal_has_num_deleted_documents()2071 inline bool DocumentStorageInfoProto::_internal_has_num_deleted_documents() const {
2072   bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
2073   return value;
2074 }
has_num_deleted_documents()2075 inline bool DocumentStorageInfoProto::has_num_deleted_documents() const {
2076   return _internal_has_num_deleted_documents();
2077 }
clear_num_deleted_documents()2078 inline void DocumentStorageInfoProto::clear_num_deleted_documents() {
2079   _impl_.num_deleted_documents_ = 0;
2080   _impl_._has_bits_[0] &= ~0x00000002u;
2081 }
_internal_num_deleted_documents()2082 inline ::int32_t DocumentStorageInfoProto::_internal_num_deleted_documents() const {
2083   return _impl_.num_deleted_documents_;
2084 }
num_deleted_documents()2085 inline ::int32_t DocumentStorageInfoProto::num_deleted_documents() const {
2086   // @@protoc_insertion_point(field_get:icing.lib.DocumentStorageInfoProto.num_deleted_documents)
2087   return _internal_num_deleted_documents();
2088 }
_internal_set_num_deleted_documents(::int32_t value)2089 inline void DocumentStorageInfoProto::_internal_set_num_deleted_documents(::int32_t value) {
2090   _impl_._has_bits_[0] |= 0x00000002u;
2091   _impl_.num_deleted_documents_ = value;
2092 }
set_num_deleted_documents(::int32_t value)2093 inline void DocumentStorageInfoProto::set_num_deleted_documents(::int32_t value) {
2094   _internal_set_num_deleted_documents(value);
2095   // @@protoc_insertion_point(field_set:icing.lib.DocumentStorageInfoProto.num_deleted_documents)
2096 }
2097 
2098 // optional int32 num_expired_documents = 3;
_internal_has_num_expired_documents()2099 inline bool DocumentStorageInfoProto::_internal_has_num_expired_documents() const {
2100   bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
2101   return value;
2102 }
has_num_expired_documents()2103 inline bool DocumentStorageInfoProto::has_num_expired_documents() const {
2104   return _internal_has_num_expired_documents();
2105 }
clear_num_expired_documents()2106 inline void DocumentStorageInfoProto::clear_num_expired_documents() {
2107   _impl_.num_expired_documents_ = 0;
2108   _impl_._has_bits_[0] &= ~0x00000080u;
2109 }
_internal_num_expired_documents()2110 inline ::int32_t DocumentStorageInfoProto::_internal_num_expired_documents() const {
2111   return _impl_.num_expired_documents_;
2112 }
num_expired_documents()2113 inline ::int32_t DocumentStorageInfoProto::num_expired_documents() const {
2114   // @@protoc_insertion_point(field_get:icing.lib.DocumentStorageInfoProto.num_expired_documents)
2115   return _internal_num_expired_documents();
2116 }
_internal_set_num_expired_documents(::int32_t value)2117 inline void DocumentStorageInfoProto::_internal_set_num_expired_documents(::int32_t value) {
2118   _impl_._has_bits_[0] |= 0x00000080u;
2119   _impl_.num_expired_documents_ = value;
2120 }
set_num_expired_documents(::int32_t value)2121 inline void DocumentStorageInfoProto::set_num_expired_documents(::int32_t value) {
2122   _internal_set_num_expired_documents(value);
2123   // @@protoc_insertion_point(field_set:icing.lib.DocumentStorageInfoProto.num_expired_documents)
2124 }
2125 
2126 // optional int64 document_store_size = 4;
_internal_has_document_store_size()2127 inline bool DocumentStorageInfoProto::_internal_has_document_store_size() const {
2128   bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
2129   return value;
2130 }
has_document_store_size()2131 inline bool DocumentStorageInfoProto::has_document_store_size() const {
2132   return _internal_has_document_store_size();
2133 }
clear_document_store_size()2134 inline void DocumentStorageInfoProto::clear_document_store_size() {
2135   _impl_.document_store_size_ = ::int64_t{0};
2136   _impl_._has_bits_[0] &= ~0x00000004u;
2137 }
_internal_document_store_size()2138 inline ::int64_t DocumentStorageInfoProto::_internal_document_store_size() const {
2139   return _impl_.document_store_size_;
2140 }
document_store_size()2141 inline ::int64_t DocumentStorageInfoProto::document_store_size() const {
2142   // @@protoc_insertion_point(field_get:icing.lib.DocumentStorageInfoProto.document_store_size)
2143   return _internal_document_store_size();
2144 }
_internal_set_document_store_size(::int64_t value)2145 inline void DocumentStorageInfoProto::_internal_set_document_store_size(::int64_t value) {
2146   _impl_._has_bits_[0] |= 0x00000004u;
2147   _impl_.document_store_size_ = value;
2148 }
set_document_store_size(::int64_t value)2149 inline void DocumentStorageInfoProto::set_document_store_size(::int64_t value) {
2150   _internal_set_document_store_size(value);
2151   // @@protoc_insertion_point(field_set:icing.lib.DocumentStorageInfoProto.document_store_size)
2152 }
2153 
2154 // optional int64 document_log_size = 5;
_internal_has_document_log_size()2155 inline bool DocumentStorageInfoProto::_internal_has_document_log_size() const {
2156   bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
2157   return value;
2158 }
has_document_log_size()2159 inline bool DocumentStorageInfoProto::has_document_log_size() const {
2160   return _internal_has_document_log_size();
2161 }
clear_document_log_size()2162 inline void DocumentStorageInfoProto::clear_document_log_size() {
2163   _impl_.document_log_size_ = ::int64_t{0};
2164   _impl_._has_bits_[0] &= ~0x00000008u;
2165 }
_internal_document_log_size()2166 inline ::int64_t DocumentStorageInfoProto::_internal_document_log_size() const {
2167   return _impl_.document_log_size_;
2168 }
document_log_size()2169 inline ::int64_t DocumentStorageInfoProto::document_log_size() const {
2170   // @@protoc_insertion_point(field_get:icing.lib.DocumentStorageInfoProto.document_log_size)
2171   return _internal_document_log_size();
2172 }
_internal_set_document_log_size(::int64_t value)2173 inline void DocumentStorageInfoProto::_internal_set_document_log_size(::int64_t value) {
2174   _impl_._has_bits_[0] |= 0x00000008u;
2175   _impl_.document_log_size_ = value;
2176 }
set_document_log_size(::int64_t value)2177 inline void DocumentStorageInfoProto::set_document_log_size(::int64_t value) {
2178   _internal_set_document_log_size(value);
2179   // @@protoc_insertion_point(field_set:icing.lib.DocumentStorageInfoProto.document_log_size)
2180 }
2181 
2182 // optional int64 key_mapper_size = 6;
_internal_has_key_mapper_size()2183 inline bool DocumentStorageInfoProto::_internal_has_key_mapper_size() const {
2184   bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
2185   return value;
2186 }
has_key_mapper_size()2187 inline bool DocumentStorageInfoProto::has_key_mapper_size() const {
2188   return _internal_has_key_mapper_size();
2189 }
clear_key_mapper_size()2190 inline void DocumentStorageInfoProto::clear_key_mapper_size() {
2191   _impl_.key_mapper_size_ = ::int64_t{0};
2192   _impl_._has_bits_[0] &= ~0x00000010u;
2193 }
_internal_key_mapper_size()2194 inline ::int64_t DocumentStorageInfoProto::_internal_key_mapper_size() const {
2195   return _impl_.key_mapper_size_;
2196 }
key_mapper_size()2197 inline ::int64_t DocumentStorageInfoProto::key_mapper_size() const {
2198   // @@protoc_insertion_point(field_get:icing.lib.DocumentStorageInfoProto.key_mapper_size)
2199   return _internal_key_mapper_size();
2200 }
_internal_set_key_mapper_size(::int64_t value)2201 inline void DocumentStorageInfoProto::_internal_set_key_mapper_size(::int64_t value) {
2202   _impl_._has_bits_[0] |= 0x00000010u;
2203   _impl_.key_mapper_size_ = value;
2204 }
set_key_mapper_size(::int64_t value)2205 inline void DocumentStorageInfoProto::set_key_mapper_size(::int64_t value) {
2206   _internal_set_key_mapper_size(value);
2207   // @@protoc_insertion_point(field_set:icing.lib.DocumentStorageInfoProto.key_mapper_size)
2208 }
2209 
2210 // optional int64 document_id_mapper_size = 7;
_internal_has_document_id_mapper_size()2211 inline bool DocumentStorageInfoProto::_internal_has_document_id_mapper_size() const {
2212   bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
2213   return value;
2214 }
has_document_id_mapper_size()2215 inline bool DocumentStorageInfoProto::has_document_id_mapper_size() const {
2216   return _internal_has_document_id_mapper_size();
2217 }
clear_document_id_mapper_size()2218 inline void DocumentStorageInfoProto::clear_document_id_mapper_size() {
2219   _impl_.document_id_mapper_size_ = ::int64_t{0};
2220   _impl_._has_bits_[0] &= ~0x00000020u;
2221 }
_internal_document_id_mapper_size()2222 inline ::int64_t DocumentStorageInfoProto::_internal_document_id_mapper_size() const {
2223   return _impl_.document_id_mapper_size_;
2224 }
document_id_mapper_size()2225 inline ::int64_t DocumentStorageInfoProto::document_id_mapper_size() const {
2226   // @@protoc_insertion_point(field_get:icing.lib.DocumentStorageInfoProto.document_id_mapper_size)
2227   return _internal_document_id_mapper_size();
2228 }
_internal_set_document_id_mapper_size(::int64_t value)2229 inline void DocumentStorageInfoProto::_internal_set_document_id_mapper_size(::int64_t value) {
2230   _impl_._has_bits_[0] |= 0x00000020u;
2231   _impl_.document_id_mapper_size_ = value;
2232 }
set_document_id_mapper_size(::int64_t value)2233 inline void DocumentStorageInfoProto::set_document_id_mapper_size(::int64_t value) {
2234   _internal_set_document_id_mapper_size(value);
2235   // @@protoc_insertion_point(field_set:icing.lib.DocumentStorageInfoProto.document_id_mapper_size)
2236 }
2237 
2238 // optional int64 score_cache_size = 8;
_internal_has_score_cache_size()2239 inline bool DocumentStorageInfoProto::_internal_has_score_cache_size() const {
2240   bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
2241   return value;
2242 }
has_score_cache_size()2243 inline bool DocumentStorageInfoProto::has_score_cache_size() const {
2244   return _internal_has_score_cache_size();
2245 }
clear_score_cache_size()2246 inline void DocumentStorageInfoProto::clear_score_cache_size() {
2247   _impl_.score_cache_size_ = ::int64_t{0};
2248   _impl_._has_bits_[0] &= ~0x00000040u;
2249 }
_internal_score_cache_size()2250 inline ::int64_t DocumentStorageInfoProto::_internal_score_cache_size() const {
2251   return _impl_.score_cache_size_;
2252 }
score_cache_size()2253 inline ::int64_t DocumentStorageInfoProto::score_cache_size() const {
2254   // @@protoc_insertion_point(field_get:icing.lib.DocumentStorageInfoProto.score_cache_size)
2255   return _internal_score_cache_size();
2256 }
_internal_set_score_cache_size(::int64_t value)2257 inline void DocumentStorageInfoProto::_internal_set_score_cache_size(::int64_t value) {
2258   _impl_._has_bits_[0] |= 0x00000040u;
2259   _impl_.score_cache_size_ = value;
2260 }
set_score_cache_size(::int64_t value)2261 inline void DocumentStorageInfoProto::set_score_cache_size(::int64_t value) {
2262   _internal_set_score_cache_size(value);
2263   // @@protoc_insertion_point(field_set:icing.lib.DocumentStorageInfoProto.score_cache_size)
2264 }
2265 
2266 // optional int64 filter_cache_size = 9;
_internal_has_filter_cache_size()2267 inline bool DocumentStorageInfoProto::_internal_has_filter_cache_size() const {
2268   bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
2269   return value;
2270 }
has_filter_cache_size()2271 inline bool DocumentStorageInfoProto::has_filter_cache_size() const {
2272   return _internal_has_filter_cache_size();
2273 }
clear_filter_cache_size()2274 inline void DocumentStorageInfoProto::clear_filter_cache_size() {
2275   _impl_.filter_cache_size_ = ::int64_t{0};
2276   _impl_._has_bits_[0] &= ~0x00000200u;
2277 }
_internal_filter_cache_size()2278 inline ::int64_t DocumentStorageInfoProto::_internal_filter_cache_size() const {
2279   return _impl_.filter_cache_size_;
2280 }
filter_cache_size()2281 inline ::int64_t DocumentStorageInfoProto::filter_cache_size() const {
2282   // @@protoc_insertion_point(field_get:icing.lib.DocumentStorageInfoProto.filter_cache_size)
2283   return _internal_filter_cache_size();
2284 }
_internal_set_filter_cache_size(::int64_t value)2285 inline void DocumentStorageInfoProto::_internal_set_filter_cache_size(::int64_t value) {
2286   _impl_._has_bits_[0] |= 0x00000200u;
2287   _impl_.filter_cache_size_ = value;
2288 }
set_filter_cache_size(::int64_t value)2289 inline void DocumentStorageInfoProto::set_filter_cache_size(::int64_t value) {
2290   _internal_set_filter_cache_size(value);
2291   // @@protoc_insertion_point(field_set:icing.lib.DocumentStorageInfoProto.filter_cache_size)
2292 }
2293 
2294 // optional int64 corpus_mapper_size = 10;
_internal_has_corpus_mapper_size()2295 inline bool DocumentStorageInfoProto::_internal_has_corpus_mapper_size() const {
2296   bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
2297   return value;
2298 }
has_corpus_mapper_size()2299 inline bool DocumentStorageInfoProto::has_corpus_mapper_size() const {
2300   return _internal_has_corpus_mapper_size();
2301 }
clear_corpus_mapper_size()2302 inline void DocumentStorageInfoProto::clear_corpus_mapper_size() {
2303   _impl_.corpus_mapper_size_ = ::int64_t{0};
2304   _impl_._has_bits_[0] &= ~0x00000400u;
2305 }
_internal_corpus_mapper_size()2306 inline ::int64_t DocumentStorageInfoProto::_internal_corpus_mapper_size() const {
2307   return _impl_.corpus_mapper_size_;
2308 }
corpus_mapper_size()2309 inline ::int64_t DocumentStorageInfoProto::corpus_mapper_size() const {
2310   // @@protoc_insertion_point(field_get:icing.lib.DocumentStorageInfoProto.corpus_mapper_size)
2311   return _internal_corpus_mapper_size();
2312 }
_internal_set_corpus_mapper_size(::int64_t value)2313 inline void DocumentStorageInfoProto::_internal_set_corpus_mapper_size(::int64_t value) {
2314   _impl_._has_bits_[0] |= 0x00000400u;
2315   _impl_.corpus_mapper_size_ = value;
2316 }
set_corpus_mapper_size(::int64_t value)2317 inline void DocumentStorageInfoProto::set_corpus_mapper_size(::int64_t value) {
2318   _internal_set_corpus_mapper_size(value);
2319   // @@protoc_insertion_point(field_set:icing.lib.DocumentStorageInfoProto.corpus_mapper_size)
2320 }
2321 
2322 // optional int64 corpus_score_cache_size = 11;
_internal_has_corpus_score_cache_size()2323 inline bool DocumentStorageInfoProto::_internal_has_corpus_score_cache_size() const {
2324   bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
2325   return value;
2326 }
has_corpus_score_cache_size()2327 inline bool DocumentStorageInfoProto::has_corpus_score_cache_size() const {
2328   return _internal_has_corpus_score_cache_size();
2329 }
clear_corpus_score_cache_size()2330 inline void DocumentStorageInfoProto::clear_corpus_score_cache_size() {
2331   _impl_.corpus_score_cache_size_ = ::int64_t{0};
2332   _impl_._has_bits_[0] &= ~0x00000800u;
2333 }
_internal_corpus_score_cache_size()2334 inline ::int64_t DocumentStorageInfoProto::_internal_corpus_score_cache_size() const {
2335   return _impl_.corpus_score_cache_size_;
2336 }
corpus_score_cache_size()2337 inline ::int64_t DocumentStorageInfoProto::corpus_score_cache_size() const {
2338   // @@protoc_insertion_point(field_get:icing.lib.DocumentStorageInfoProto.corpus_score_cache_size)
2339   return _internal_corpus_score_cache_size();
2340 }
_internal_set_corpus_score_cache_size(::int64_t value)2341 inline void DocumentStorageInfoProto::_internal_set_corpus_score_cache_size(::int64_t value) {
2342   _impl_._has_bits_[0] |= 0x00000800u;
2343   _impl_.corpus_score_cache_size_ = value;
2344 }
set_corpus_score_cache_size(::int64_t value)2345 inline void DocumentStorageInfoProto::set_corpus_score_cache_size(::int64_t value) {
2346   _internal_set_corpus_score_cache_size(value);
2347   // @@protoc_insertion_point(field_set:icing.lib.DocumentStorageInfoProto.corpus_score_cache_size)
2348 }
2349 
2350 // optional int64 namespace_id_mapper_size = 12;
_internal_has_namespace_id_mapper_size()2351 inline bool DocumentStorageInfoProto::_internal_has_namespace_id_mapper_size() const {
2352   bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
2353   return value;
2354 }
has_namespace_id_mapper_size()2355 inline bool DocumentStorageInfoProto::has_namespace_id_mapper_size() const {
2356   return _internal_has_namespace_id_mapper_size();
2357 }
clear_namespace_id_mapper_size()2358 inline void DocumentStorageInfoProto::clear_namespace_id_mapper_size() {
2359   _impl_.namespace_id_mapper_size_ = ::int64_t{0};
2360   _impl_._has_bits_[0] &= ~0x00001000u;
2361 }
_internal_namespace_id_mapper_size()2362 inline ::int64_t DocumentStorageInfoProto::_internal_namespace_id_mapper_size() const {
2363   return _impl_.namespace_id_mapper_size_;
2364 }
namespace_id_mapper_size()2365 inline ::int64_t DocumentStorageInfoProto::namespace_id_mapper_size() const {
2366   // @@protoc_insertion_point(field_get:icing.lib.DocumentStorageInfoProto.namespace_id_mapper_size)
2367   return _internal_namespace_id_mapper_size();
2368 }
_internal_set_namespace_id_mapper_size(::int64_t value)2369 inline void DocumentStorageInfoProto::_internal_set_namespace_id_mapper_size(::int64_t value) {
2370   _impl_._has_bits_[0] |= 0x00001000u;
2371   _impl_.namespace_id_mapper_size_ = value;
2372 }
set_namespace_id_mapper_size(::int64_t value)2373 inline void DocumentStorageInfoProto::set_namespace_id_mapper_size(::int64_t value) {
2374   _internal_set_namespace_id_mapper_size(value);
2375   // @@protoc_insertion_point(field_set:icing.lib.DocumentStorageInfoProto.namespace_id_mapper_size)
2376 }
2377 
2378 // optional int64 scorable_property_cache_size = 15;
_internal_has_scorable_property_cache_size()2379 inline bool DocumentStorageInfoProto::_internal_has_scorable_property_cache_size() const {
2380   bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0;
2381   return value;
2382 }
has_scorable_property_cache_size()2383 inline bool DocumentStorageInfoProto::has_scorable_property_cache_size() const {
2384   return _internal_has_scorable_property_cache_size();
2385 }
clear_scorable_property_cache_size()2386 inline void DocumentStorageInfoProto::clear_scorable_property_cache_size() {
2387   _impl_.scorable_property_cache_size_ = ::int64_t{0};
2388   _impl_._has_bits_[0] &= ~0x00002000u;
2389 }
_internal_scorable_property_cache_size()2390 inline ::int64_t DocumentStorageInfoProto::_internal_scorable_property_cache_size() const {
2391   return _impl_.scorable_property_cache_size_;
2392 }
scorable_property_cache_size()2393 inline ::int64_t DocumentStorageInfoProto::scorable_property_cache_size() const {
2394   // @@protoc_insertion_point(field_get:icing.lib.DocumentStorageInfoProto.scorable_property_cache_size)
2395   return _internal_scorable_property_cache_size();
2396 }
_internal_set_scorable_property_cache_size(::int64_t value)2397 inline void DocumentStorageInfoProto::_internal_set_scorable_property_cache_size(::int64_t value) {
2398   _impl_._has_bits_[0] |= 0x00002000u;
2399   _impl_.scorable_property_cache_size_ = value;
2400 }
set_scorable_property_cache_size(::int64_t value)2401 inline void DocumentStorageInfoProto::set_scorable_property_cache_size(::int64_t value) {
2402   _internal_set_scorable_property_cache_size(value);
2403   // @@protoc_insertion_point(field_set:icing.lib.DocumentStorageInfoProto.scorable_property_cache_size)
2404 }
2405 
2406 // optional int32 num_namespaces = 13;
_internal_has_num_namespaces()2407 inline bool DocumentStorageInfoProto::_internal_has_num_namespaces() const {
2408   bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
2409   return value;
2410 }
has_num_namespaces()2411 inline bool DocumentStorageInfoProto::has_num_namespaces() const {
2412   return _internal_has_num_namespaces();
2413 }
clear_num_namespaces()2414 inline void DocumentStorageInfoProto::clear_num_namespaces() {
2415   _impl_.num_namespaces_ = 0;
2416   _impl_._has_bits_[0] &= ~0x00000100u;
2417 }
_internal_num_namespaces()2418 inline ::int32_t DocumentStorageInfoProto::_internal_num_namespaces() const {
2419   return _impl_.num_namespaces_;
2420 }
num_namespaces()2421 inline ::int32_t DocumentStorageInfoProto::num_namespaces() const {
2422   // @@protoc_insertion_point(field_get:icing.lib.DocumentStorageInfoProto.num_namespaces)
2423   return _internal_num_namespaces();
2424 }
_internal_set_num_namespaces(::int32_t value)2425 inline void DocumentStorageInfoProto::_internal_set_num_namespaces(::int32_t value) {
2426   _impl_._has_bits_[0] |= 0x00000100u;
2427   _impl_.num_namespaces_ = value;
2428 }
set_num_namespaces(::int32_t value)2429 inline void DocumentStorageInfoProto::set_num_namespaces(::int32_t value) {
2430   _internal_set_num_namespaces(value);
2431   // @@protoc_insertion_point(field_set:icing.lib.DocumentStorageInfoProto.num_namespaces)
2432 }
2433 
2434 // repeated .icing.lib.NamespaceStorageInfoProto namespace_storage_info = 14;
_internal_namespace_storage_info_size()2435 inline int DocumentStorageInfoProto::_internal_namespace_storage_info_size() const {
2436   return _impl_.namespace_storage_info_.size();
2437 }
namespace_storage_info_size()2438 inline int DocumentStorageInfoProto::namespace_storage_info_size() const {
2439   return _internal_namespace_storage_info_size();
2440 }
clear_namespace_storage_info()2441 inline void DocumentStorageInfoProto::clear_namespace_storage_info() {
2442   _impl_.namespace_storage_info_.Clear();
2443 }
mutable_namespace_storage_info(int index)2444 inline ::icing::lib::NamespaceStorageInfoProto* DocumentStorageInfoProto::mutable_namespace_storage_info(int index) {
2445   // @@protoc_insertion_point(field_mutable:icing.lib.DocumentStorageInfoProto.namespace_storage_info)
2446   return _impl_.namespace_storage_info_.Mutable(index);
2447 }
2448 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::NamespaceStorageInfoProto >*
mutable_namespace_storage_info()2449 DocumentStorageInfoProto::mutable_namespace_storage_info() {
2450   // @@protoc_insertion_point(field_mutable_list:icing.lib.DocumentStorageInfoProto.namespace_storage_info)
2451   return &_impl_.namespace_storage_info_;
2452 }
_internal_namespace_storage_info(int index)2453 inline const ::icing::lib::NamespaceStorageInfoProto& DocumentStorageInfoProto::_internal_namespace_storage_info(int index) const {
2454   return _impl_.namespace_storage_info_.Get(index);
2455 }
namespace_storage_info(int index)2456 inline const ::icing::lib::NamespaceStorageInfoProto& DocumentStorageInfoProto::namespace_storage_info(int index) const {
2457   // @@protoc_insertion_point(field_get:icing.lib.DocumentStorageInfoProto.namespace_storage_info)
2458   return _internal_namespace_storage_info(index);
2459 }
_internal_add_namespace_storage_info()2460 inline ::icing::lib::NamespaceStorageInfoProto* DocumentStorageInfoProto::_internal_add_namespace_storage_info() {
2461   return _impl_.namespace_storage_info_.Add();
2462 }
add_namespace_storage_info()2463 inline ::icing::lib::NamespaceStorageInfoProto* DocumentStorageInfoProto::add_namespace_storage_info() {
2464   ::icing::lib::NamespaceStorageInfoProto* _add = _internal_add_namespace_storage_info();
2465   // @@protoc_insertion_point(field_add:icing.lib.DocumentStorageInfoProto.namespace_storage_info)
2466   return _add;
2467 }
2468 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::NamespaceStorageInfoProto >&
namespace_storage_info()2469 DocumentStorageInfoProto::namespace_storage_info() const {
2470   // @@protoc_insertion_point(field_list:icing.lib.DocumentStorageInfoProto.namespace_storage_info)
2471   return _impl_.namespace_storage_info_;
2472 }
2473 
2474 // -------------------------------------------------------------------
2475 
2476 // SchemaStoreStorageInfoProto
2477 
2478 // optional int64 schema_store_size = 1;
_internal_has_schema_store_size()2479 inline bool SchemaStoreStorageInfoProto::_internal_has_schema_store_size() const {
2480   bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
2481   return value;
2482 }
has_schema_store_size()2483 inline bool SchemaStoreStorageInfoProto::has_schema_store_size() const {
2484   return _internal_has_schema_store_size();
2485 }
clear_schema_store_size()2486 inline void SchemaStoreStorageInfoProto::clear_schema_store_size() {
2487   _impl_.schema_store_size_ = ::int64_t{0};
2488   _impl_._has_bits_[0] &= ~0x00000001u;
2489 }
_internal_schema_store_size()2490 inline ::int64_t SchemaStoreStorageInfoProto::_internal_schema_store_size() const {
2491   return _impl_.schema_store_size_;
2492 }
schema_store_size()2493 inline ::int64_t SchemaStoreStorageInfoProto::schema_store_size() const {
2494   // @@protoc_insertion_point(field_get:icing.lib.SchemaStoreStorageInfoProto.schema_store_size)
2495   return _internal_schema_store_size();
2496 }
_internal_set_schema_store_size(::int64_t value)2497 inline void SchemaStoreStorageInfoProto::_internal_set_schema_store_size(::int64_t value) {
2498   _impl_._has_bits_[0] |= 0x00000001u;
2499   _impl_.schema_store_size_ = value;
2500 }
set_schema_store_size(::int64_t value)2501 inline void SchemaStoreStorageInfoProto::set_schema_store_size(::int64_t value) {
2502   _internal_set_schema_store_size(value);
2503   // @@protoc_insertion_point(field_set:icing.lib.SchemaStoreStorageInfoProto.schema_store_size)
2504 }
2505 
2506 // optional int32 num_schema_types = 2;
_internal_has_num_schema_types()2507 inline bool SchemaStoreStorageInfoProto::_internal_has_num_schema_types() const {
2508   bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
2509   return value;
2510 }
has_num_schema_types()2511 inline bool SchemaStoreStorageInfoProto::has_num_schema_types() const {
2512   return _internal_has_num_schema_types();
2513 }
clear_num_schema_types()2514 inline void SchemaStoreStorageInfoProto::clear_num_schema_types() {
2515   _impl_.num_schema_types_ = 0;
2516   _impl_._has_bits_[0] &= ~0x00000002u;
2517 }
_internal_num_schema_types()2518 inline ::int32_t SchemaStoreStorageInfoProto::_internal_num_schema_types() const {
2519   return _impl_.num_schema_types_;
2520 }
num_schema_types()2521 inline ::int32_t SchemaStoreStorageInfoProto::num_schema_types() const {
2522   // @@protoc_insertion_point(field_get:icing.lib.SchemaStoreStorageInfoProto.num_schema_types)
2523   return _internal_num_schema_types();
2524 }
_internal_set_num_schema_types(::int32_t value)2525 inline void SchemaStoreStorageInfoProto::_internal_set_num_schema_types(::int32_t value) {
2526   _impl_._has_bits_[0] |= 0x00000002u;
2527   _impl_.num_schema_types_ = value;
2528 }
set_num_schema_types(::int32_t value)2529 inline void SchemaStoreStorageInfoProto::set_num_schema_types(::int32_t value) {
2530   _internal_set_num_schema_types(value);
2531   // @@protoc_insertion_point(field_set:icing.lib.SchemaStoreStorageInfoProto.num_schema_types)
2532 }
2533 
2534 // optional int32 num_total_sections = 3;
_internal_has_num_total_sections()2535 inline bool SchemaStoreStorageInfoProto::_internal_has_num_total_sections() const {
2536   bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
2537   return value;
2538 }
has_num_total_sections()2539 inline bool SchemaStoreStorageInfoProto::has_num_total_sections() const {
2540   return _internal_has_num_total_sections();
2541 }
clear_num_total_sections()2542 inline void SchemaStoreStorageInfoProto::clear_num_total_sections() {
2543   _impl_.num_total_sections_ = 0;
2544   _impl_._has_bits_[0] &= ~0x00000004u;
2545 }
_internal_num_total_sections()2546 inline ::int32_t SchemaStoreStorageInfoProto::_internal_num_total_sections() const {
2547   return _impl_.num_total_sections_;
2548 }
num_total_sections()2549 inline ::int32_t SchemaStoreStorageInfoProto::num_total_sections() const {
2550   // @@protoc_insertion_point(field_get:icing.lib.SchemaStoreStorageInfoProto.num_total_sections)
2551   return _internal_num_total_sections();
2552 }
_internal_set_num_total_sections(::int32_t value)2553 inline void SchemaStoreStorageInfoProto::_internal_set_num_total_sections(::int32_t value) {
2554   _impl_._has_bits_[0] |= 0x00000004u;
2555   _impl_.num_total_sections_ = value;
2556 }
set_num_total_sections(::int32_t value)2557 inline void SchemaStoreStorageInfoProto::set_num_total_sections(::int32_t value) {
2558   _internal_set_num_total_sections(value);
2559   // @@protoc_insertion_point(field_set:icing.lib.SchemaStoreStorageInfoProto.num_total_sections)
2560 }
2561 
2562 // optional int32 num_schema_types_sections_exhausted = 4;
_internal_has_num_schema_types_sections_exhausted()2563 inline bool SchemaStoreStorageInfoProto::_internal_has_num_schema_types_sections_exhausted() const {
2564   bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
2565   return value;
2566 }
has_num_schema_types_sections_exhausted()2567 inline bool SchemaStoreStorageInfoProto::has_num_schema_types_sections_exhausted() const {
2568   return _internal_has_num_schema_types_sections_exhausted();
2569 }
clear_num_schema_types_sections_exhausted()2570 inline void SchemaStoreStorageInfoProto::clear_num_schema_types_sections_exhausted() {
2571   _impl_.num_schema_types_sections_exhausted_ = 0;
2572   _impl_._has_bits_[0] &= ~0x00000008u;
2573 }
_internal_num_schema_types_sections_exhausted()2574 inline ::int32_t SchemaStoreStorageInfoProto::_internal_num_schema_types_sections_exhausted() const {
2575   return _impl_.num_schema_types_sections_exhausted_;
2576 }
num_schema_types_sections_exhausted()2577 inline ::int32_t SchemaStoreStorageInfoProto::num_schema_types_sections_exhausted() const {
2578   // @@protoc_insertion_point(field_get:icing.lib.SchemaStoreStorageInfoProto.num_schema_types_sections_exhausted)
2579   return _internal_num_schema_types_sections_exhausted();
2580 }
_internal_set_num_schema_types_sections_exhausted(::int32_t value)2581 inline void SchemaStoreStorageInfoProto::_internal_set_num_schema_types_sections_exhausted(::int32_t value) {
2582   _impl_._has_bits_[0] |= 0x00000008u;
2583   _impl_.num_schema_types_sections_exhausted_ = value;
2584 }
set_num_schema_types_sections_exhausted(::int32_t value)2585 inline void SchemaStoreStorageInfoProto::set_num_schema_types_sections_exhausted(::int32_t value) {
2586   _internal_set_num_schema_types_sections_exhausted(value);
2587   // @@protoc_insertion_point(field_set:icing.lib.SchemaStoreStorageInfoProto.num_schema_types_sections_exhausted)
2588 }
2589 
2590 // -------------------------------------------------------------------
2591 
2592 // IndexStorageInfoProto
2593 
2594 // optional int64 index_size = 1;
_internal_has_index_size()2595 inline bool IndexStorageInfoProto::_internal_has_index_size() const {
2596   bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
2597   return value;
2598 }
has_index_size()2599 inline bool IndexStorageInfoProto::has_index_size() const {
2600   return _internal_has_index_size();
2601 }
clear_index_size()2602 inline void IndexStorageInfoProto::clear_index_size() {
2603   _impl_.index_size_ = ::int64_t{0};
2604   _impl_._has_bits_[0] &= ~0x00000001u;
2605 }
_internal_index_size()2606 inline ::int64_t IndexStorageInfoProto::_internal_index_size() const {
2607   return _impl_.index_size_;
2608 }
index_size()2609 inline ::int64_t IndexStorageInfoProto::index_size() const {
2610   // @@protoc_insertion_point(field_get:icing.lib.IndexStorageInfoProto.index_size)
2611   return _internal_index_size();
2612 }
_internal_set_index_size(::int64_t value)2613 inline void IndexStorageInfoProto::_internal_set_index_size(::int64_t value) {
2614   _impl_._has_bits_[0] |= 0x00000001u;
2615   _impl_.index_size_ = value;
2616 }
set_index_size(::int64_t value)2617 inline void IndexStorageInfoProto::set_index_size(::int64_t value) {
2618   _internal_set_index_size(value);
2619   // @@protoc_insertion_point(field_set:icing.lib.IndexStorageInfoProto.index_size)
2620 }
2621 
2622 // optional int64 lite_index_lexicon_size = 2;
_internal_has_lite_index_lexicon_size()2623 inline bool IndexStorageInfoProto::_internal_has_lite_index_lexicon_size() const {
2624   bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
2625   return value;
2626 }
has_lite_index_lexicon_size()2627 inline bool IndexStorageInfoProto::has_lite_index_lexicon_size() const {
2628   return _internal_has_lite_index_lexicon_size();
2629 }
clear_lite_index_lexicon_size()2630 inline void IndexStorageInfoProto::clear_lite_index_lexicon_size() {
2631   _impl_.lite_index_lexicon_size_ = ::int64_t{0};
2632   _impl_._has_bits_[0] &= ~0x00000002u;
2633 }
_internal_lite_index_lexicon_size()2634 inline ::int64_t IndexStorageInfoProto::_internal_lite_index_lexicon_size() const {
2635   return _impl_.lite_index_lexicon_size_;
2636 }
lite_index_lexicon_size()2637 inline ::int64_t IndexStorageInfoProto::lite_index_lexicon_size() const {
2638   // @@protoc_insertion_point(field_get:icing.lib.IndexStorageInfoProto.lite_index_lexicon_size)
2639   return _internal_lite_index_lexicon_size();
2640 }
_internal_set_lite_index_lexicon_size(::int64_t value)2641 inline void IndexStorageInfoProto::_internal_set_lite_index_lexicon_size(::int64_t value) {
2642   _impl_._has_bits_[0] |= 0x00000002u;
2643   _impl_.lite_index_lexicon_size_ = value;
2644 }
set_lite_index_lexicon_size(::int64_t value)2645 inline void IndexStorageInfoProto::set_lite_index_lexicon_size(::int64_t value) {
2646   _internal_set_lite_index_lexicon_size(value);
2647   // @@protoc_insertion_point(field_set:icing.lib.IndexStorageInfoProto.lite_index_lexicon_size)
2648 }
2649 
2650 // optional int64 lite_index_hit_buffer_size = 3;
_internal_has_lite_index_hit_buffer_size()2651 inline bool IndexStorageInfoProto::_internal_has_lite_index_hit_buffer_size() const {
2652   bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
2653   return value;
2654 }
has_lite_index_hit_buffer_size()2655 inline bool IndexStorageInfoProto::has_lite_index_hit_buffer_size() const {
2656   return _internal_has_lite_index_hit_buffer_size();
2657 }
clear_lite_index_hit_buffer_size()2658 inline void IndexStorageInfoProto::clear_lite_index_hit_buffer_size() {
2659   _impl_.lite_index_hit_buffer_size_ = ::int64_t{0};
2660   _impl_._has_bits_[0] &= ~0x00000004u;
2661 }
_internal_lite_index_hit_buffer_size()2662 inline ::int64_t IndexStorageInfoProto::_internal_lite_index_hit_buffer_size() const {
2663   return _impl_.lite_index_hit_buffer_size_;
2664 }
lite_index_hit_buffer_size()2665 inline ::int64_t IndexStorageInfoProto::lite_index_hit_buffer_size() const {
2666   // @@protoc_insertion_point(field_get:icing.lib.IndexStorageInfoProto.lite_index_hit_buffer_size)
2667   return _internal_lite_index_hit_buffer_size();
2668 }
_internal_set_lite_index_hit_buffer_size(::int64_t value)2669 inline void IndexStorageInfoProto::_internal_set_lite_index_hit_buffer_size(::int64_t value) {
2670   _impl_._has_bits_[0] |= 0x00000004u;
2671   _impl_.lite_index_hit_buffer_size_ = value;
2672 }
set_lite_index_hit_buffer_size(::int64_t value)2673 inline void IndexStorageInfoProto::set_lite_index_hit_buffer_size(::int64_t value) {
2674   _internal_set_lite_index_hit_buffer_size(value);
2675   // @@protoc_insertion_point(field_set:icing.lib.IndexStorageInfoProto.lite_index_hit_buffer_size)
2676 }
2677 
2678 // optional int64 main_index_lexicon_size = 4;
_internal_has_main_index_lexicon_size()2679 inline bool IndexStorageInfoProto::_internal_has_main_index_lexicon_size() const {
2680   bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
2681   return value;
2682 }
has_main_index_lexicon_size()2683 inline bool IndexStorageInfoProto::has_main_index_lexicon_size() const {
2684   return _internal_has_main_index_lexicon_size();
2685 }
clear_main_index_lexicon_size()2686 inline void IndexStorageInfoProto::clear_main_index_lexicon_size() {
2687   _impl_.main_index_lexicon_size_ = ::int64_t{0};
2688   _impl_._has_bits_[0] &= ~0x00000008u;
2689 }
_internal_main_index_lexicon_size()2690 inline ::int64_t IndexStorageInfoProto::_internal_main_index_lexicon_size() const {
2691   return _impl_.main_index_lexicon_size_;
2692 }
main_index_lexicon_size()2693 inline ::int64_t IndexStorageInfoProto::main_index_lexicon_size() const {
2694   // @@protoc_insertion_point(field_get:icing.lib.IndexStorageInfoProto.main_index_lexicon_size)
2695   return _internal_main_index_lexicon_size();
2696 }
_internal_set_main_index_lexicon_size(::int64_t value)2697 inline void IndexStorageInfoProto::_internal_set_main_index_lexicon_size(::int64_t value) {
2698   _impl_._has_bits_[0] |= 0x00000008u;
2699   _impl_.main_index_lexicon_size_ = value;
2700 }
set_main_index_lexicon_size(::int64_t value)2701 inline void IndexStorageInfoProto::set_main_index_lexicon_size(::int64_t value) {
2702   _internal_set_main_index_lexicon_size(value);
2703   // @@protoc_insertion_point(field_set:icing.lib.IndexStorageInfoProto.main_index_lexicon_size)
2704 }
2705 
2706 // optional int64 main_index_storage_size = 5;
_internal_has_main_index_storage_size()2707 inline bool IndexStorageInfoProto::_internal_has_main_index_storage_size() const {
2708   bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
2709   return value;
2710 }
has_main_index_storage_size()2711 inline bool IndexStorageInfoProto::has_main_index_storage_size() const {
2712   return _internal_has_main_index_storage_size();
2713 }
clear_main_index_storage_size()2714 inline void IndexStorageInfoProto::clear_main_index_storage_size() {
2715   _impl_.main_index_storage_size_ = ::int64_t{0};
2716   _impl_._has_bits_[0] &= ~0x00000010u;
2717 }
_internal_main_index_storage_size()2718 inline ::int64_t IndexStorageInfoProto::_internal_main_index_storage_size() const {
2719   return _impl_.main_index_storage_size_;
2720 }
main_index_storage_size()2721 inline ::int64_t IndexStorageInfoProto::main_index_storage_size() const {
2722   // @@protoc_insertion_point(field_get:icing.lib.IndexStorageInfoProto.main_index_storage_size)
2723   return _internal_main_index_storage_size();
2724 }
_internal_set_main_index_storage_size(::int64_t value)2725 inline void IndexStorageInfoProto::_internal_set_main_index_storage_size(::int64_t value) {
2726   _impl_._has_bits_[0] |= 0x00000010u;
2727   _impl_.main_index_storage_size_ = value;
2728 }
set_main_index_storage_size(::int64_t value)2729 inline void IndexStorageInfoProto::set_main_index_storage_size(::int64_t value) {
2730   _internal_set_main_index_storage_size(value);
2731   // @@protoc_insertion_point(field_set:icing.lib.IndexStorageInfoProto.main_index_storage_size)
2732 }
2733 
2734 // optional int64 main_index_block_size = 6;
_internal_has_main_index_block_size()2735 inline bool IndexStorageInfoProto::_internal_has_main_index_block_size() const {
2736   bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
2737   return value;
2738 }
has_main_index_block_size()2739 inline bool IndexStorageInfoProto::has_main_index_block_size() const {
2740   return _internal_has_main_index_block_size();
2741 }
clear_main_index_block_size()2742 inline void IndexStorageInfoProto::clear_main_index_block_size() {
2743   _impl_.main_index_block_size_ = ::int64_t{0};
2744   _impl_._has_bits_[0] &= ~0x00000020u;
2745 }
_internal_main_index_block_size()2746 inline ::int64_t IndexStorageInfoProto::_internal_main_index_block_size() const {
2747   return _impl_.main_index_block_size_;
2748 }
main_index_block_size()2749 inline ::int64_t IndexStorageInfoProto::main_index_block_size() const {
2750   // @@protoc_insertion_point(field_get:icing.lib.IndexStorageInfoProto.main_index_block_size)
2751   return _internal_main_index_block_size();
2752 }
_internal_set_main_index_block_size(::int64_t value)2753 inline void IndexStorageInfoProto::_internal_set_main_index_block_size(::int64_t value) {
2754   _impl_._has_bits_[0] |= 0x00000020u;
2755   _impl_.main_index_block_size_ = value;
2756 }
set_main_index_block_size(::int64_t value)2757 inline void IndexStorageInfoProto::set_main_index_block_size(::int64_t value) {
2758   _internal_set_main_index_block_size(value);
2759   // @@protoc_insertion_point(field_set:icing.lib.IndexStorageInfoProto.main_index_block_size)
2760 }
2761 
2762 // optional int32 num_blocks = 7;
_internal_has_num_blocks()2763 inline bool IndexStorageInfoProto::_internal_has_num_blocks() const {
2764   bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
2765   return value;
2766 }
has_num_blocks()2767 inline bool IndexStorageInfoProto::has_num_blocks() const {
2768   return _internal_has_num_blocks();
2769 }
clear_num_blocks()2770 inline void IndexStorageInfoProto::clear_num_blocks() {
2771   _impl_.num_blocks_ = 0;
2772   _impl_._has_bits_[0] &= ~0x00000040u;
2773 }
_internal_num_blocks()2774 inline ::int32_t IndexStorageInfoProto::_internal_num_blocks() const {
2775   return _impl_.num_blocks_;
2776 }
num_blocks()2777 inline ::int32_t IndexStorageInfoProto::num_blocks() const {
2778   // @@protoc_insertion_point(field_get:icing.lib.IndexStorageInfoProto.num_blocks)
2779   return _internal_num_blocks();
2780 }
_internal_set_num_blocks(::int32_t value)2781 inline void IndexStorageInfoProto::_internal_set_num_blocks(::int32_t value) {
2782   _impl_._has_bits_[0] |= 0x00000040u;
2783   _impl_.num_blocks_ = value;
2784 }
set_num_blocks(::int32_t value)2785 inline void IndexStorageInfoProto::set_num_blocks(::int32_t value) {
2786   _internal_set_num_blocks(value);
2787   // @@protoc_insertion_point(field_set:icing.lib.IndexStorageInfoProto.num_blocks)
2788 }
2789 
2790 // optional float min_free_fraction = 8;
_internal_has_min_free_fraction()2791 inline bool IndexStorageInfoProto::_internal_has_min_free_fraction() const {
2792   bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
2793   return value;
2794 }
has_min_free_fraction()2795 inline bool IndexStorageInfoProto::has_min_free_fraction() const {
2796   return _internal_has_min_free_fraction();
2797 }
clear_min_free_fraction()2798 inline void IndexStorageInfoProto::clear_min_free_fraction() {
2799   _impl_.min_free_fraction_ = 0;
2800   _impl_._has_bits_[0] &= ~0x00000080u;
2801 }
_internal_min_free_fraction()2802 inline float IndexStorageInfoProto::_internal_min_free_fraction() const {
2803   return _impl_.min_free_fraction_;
2804 }
min_free_fraction()2805 inline float IndexStorageInfoProto::min_free_fraction() const {
2806   // @@protoc_insertion_point(field_get:icing.lib.IndexStorageInfoProto.min_free_fraction)
2807   return _internal_min_free_fraction();
2808 }
_internal_set_min_free_fraction(float value)2809 inline void IndexStorageInfoProto::_internal_set_min_free_fraction(float value) {
2810   _impl_._has_bits_[0] |= 0x00000080u;
2811   _impl_.min_free_fraction_ = value;
2812 }
set_min_free_fraction(float value)2813 inline void IndexStorageInfoProto::set_min_free_fraction(float value) {
2814   _internal_set_min_free_fraction(value);
2815   // @@protoc_insertion_point(field_set:icing.lib.IndexStorageInfoProto.min_free_fraction)
2816 }
2817 
2818 // -------------------------------------------------------------------
2819 
2820 // NamespaceBlobStorageInfoProto
2821 
2822 // optional string namespace = 1;
_internal_has_namespace_()2823 inline bool NamespaceBlobStorageInfoProto::_internal_has_namespace_() const {
2824   bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
2825   return value;
2826 }
has_namespace_()2827 inline bool NamespaceBlobStorageInfoProto::has_namespace_() const {
2828   return _internal_has_namespace_();
2829 }
clear_namespace_()2830 inline void NamespaceBlobStorageInfoProto::clear_namespace_() {
2831   _impl_.namespace__.ClearToEmpty();
2832   _impl_._has_bits_[0] &= ~0x00000001u;
2833 }
namespace_()2834 inline const std::string& NamespaceBlobStorageInfoProto::namespace_() const {
2835   // @@protoc_insertion_point(field_get:icing.lib.NamespaceBlobStorageInfoProto.namespace)
2836   return _internal_namespace_();
2837 }
2838 template <typename ArgT0, typename... ArgT>
2839 inline PROTOBUF_ALWAYS_INLINE
set_namespace_(ArgT0 && arg0,ArgT...args)2840 void NamespaceBlobStorageInfoProto::set_namespace_(ArgT0&& arg0, ArgT... args) {
2841  _impl_._has_bits_[0] |= 0x00000001u;
2842  _impl_.namespace__.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
2843   // @@protoc_insertion_point(field_set:icing.lib.NamespaceBlobStorageInfoProto.namespace)
2844 }
mutable_namespace_()2845 inline std::string* NamespaceBlobStorageInfoProto::mutable_namespace_() {
2846   std::string* _s = _internal_mutable_namespace_();
2847   // @@protoc_insertion_point(field_mutable:icing.lib.NamespaceBlobStorageInfoProto.namespace)
2848   return _s;
2849 }
_internal_namespace_()2850 inline const std::string& NamespaceBlobStorageInfoProto::_internal_namespace_() const {
2851   return _impl_.namespace__.Get();
2852 }
_internal_set_namespace_(const std::string & value)2853 inline void NamespaceBlobStorageInfoProto::_internal_set_namespace_(const std::string& value) {
2854   _impl_._has_bits_[0] |= 0x00000001u;
2855   _impl_.namespace__.Set(value, GetArenaForAllocation());
2856 }
_internal_mutable_namespace_()2857 inline std::string* NamespaceBlobStorageInfoProto::_internal_mutable_namespace_() {
2858   _impl_._has_bits_[0] |= 0x00000001u;
2859   return _impl_.namespace__.Mutable(GetArenaForAllocation());
2860 }
release_namespace_()2861 inline std::string* NamespaceBlobStorageInfoProto::release_namespace_() {
2862   // @@protoc_insertion_point(field_release:icing.lib.NamespaceBlobStorageInfoProto.namespace)
2863   if (!_internal_has_namespace_()) {
2864     return nullptr;
2865   }
2866   _impl_._has_bits_[0] &= ~0x00000001u;
2867   auto* p = _impl_.namespace__.Release();
2868 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2869   if (_impl_.namespace__.IsDefault()) {
2870     _impl_.namespace__.Set("", GetArenaForAllocation());
2871   }
2872 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2873   return p;
2874 }
set_allocated_namespace_(std::string * namespace_)2875 inline void NamespaceBlobStorageInfoProto::set_allocated_namespace_(std::string* namespace_) {
2876   if (namespace_ != nullptr) {
2877     _impl_._has_bits_[0] |= 0x00000001u;
2878   } else {
2879     _impl_._has_bits_[0] &= ~0x00000001u;
2880   }
2881   _impl_.namespace__.SetAllocated(namespace_, GetArenaForAllocation());
2882 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2883   if (_impl_.namespace__.IsDefault()) {
2884     _impl_.namespace__.Set("", GetArenaForAllocation());
2885   }
2886 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2887   // @@protoc_insertion_point(field_set_allocated:icing.lib.NamespaceBlobStorageInfoProto.namespace)
2888 }
2889 
2890 // optional int64 blob_size = 2;
_internal_has_blob_size()2891 inline bool NamespaceBlobStorageInfoProto::_internal_has_blob_size() const {
2892   bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
2893   return value;
2894 }
has_blob_size()2895 inline bool NamespaceBlobStorageInfoProto::has_blob_size() const {
2896   return _internal_has_blob_size();
2897 }
clear_blob_size()2898 inline void NamespaceBlobStorageInfoProto::clear_blob_size() {
2899   _impl_.blob_size_ = ::int64_t{0};
2900   _impl_._has_bits_[0] &= ~0x00000002u;
2901 }
_internal_blob_size()2902 inline ::int64_t NamespaceBlobStorageInfoProto::_internal_blob_size() const {
2903   return _impl_.blob_size_;
2904 }
blob_size()2905 inline ::int64_t NamespaceBlobStorageInfoProto::blob_size() const {
2906   // @@protoc_insertion_point(field_get:icing.lib.NamespaceBlobStorageInfoProto.blob_size)
2907   return _internal_blob_size();
2908 }
_internal_set_blob_size(::int64_t value)2909 inline void NamespaceBlobStorageInfoProto::_internal_set_blob_size(::int64_t value) {
2910   _impl_._has_bits_[0] |= 0x00000002u;
2911   _impl_.blob_size_ = value;
2912 }
set_blob_size(::int64_t value)2913 inline void NamespaceBlobStorageInfoProto::set_blob_size(::int64_t value) {
2914   _internal_set_blob_size(value);
2915   // @@protoc_insertion_point(field_set:icing.lib.NamespaceBlobStorageInfoProto.blob_size)
2916 }
2917 
2918 // optional int32 num_blobs = 3;
_internal_has_num_blobs()2919 inline bool NamespaceBlobStorageInfoProto::_internal_has_num_blobs() const {
2920   bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
2921   return value;
2922 }
has_num_blobs()2923 inline bool NamespaceBlobStorageInfoProto::has_num_blobs() const {
2924   return _internal_has_num_blobs();
2925 }
clear_num_blobs()2926 inline void NamespaceBlobStorageInfoProto::clear_num_blobs() {
2927   _impl_.num_blobs_ = 0;
2928   _impl_._has_bits_[0] &= ~0x00000004u;
2929 }
_internal_num_blobs()2930 inline ::int32_t NamespaceBlobStorageInfoProto::_internal_num_blobs() const {
2931   return _impl_.num_blobs_;
2932 }
num_blobs()2933 inline ::int32_t NamespaceBlobStorageInfoProto::num_blobs() const {
2934   // @@protoc_insertion_point(field_get:icing.lib.NamespaceBlobStorageInfoProto.num_blobs)
2935   return _internal_num_blobs();
2936 }
_internal_set_num_blobs(::int32_t value)2937 inline void NamespaceBlobStorageInfoProto::_internal_set_num_blobs(::int32_t value) {
2938   _impl_._has_bits_[0] |= 0x00000004u;
2939   _impl_.num_blobs_ = value;
2940 }
set_num_blobs(::int32_t value)2941 inline void NamespaceBlobStorageInfoProto::set_num_blobs(::int32_t value) {
2942   _internal_set_num_blobs(value);
2943   // @@protoc_insertion_point(field_set:icing.lib.NamespaceBlobStorageInfoProto.num_blobs)
2944 }
2945 
2946 // -------------------------------------------------------------------
2947 
2948 // StorageInfoProto
2949 
2950 // optional int64 total_storage_size = 1;
_internal_has_total_storage_size()2951 inline bool StorageInfoProto::_internal_has_total_storage_size() const {
2952   bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
2953   return value;
2954 }
has_total_storage_size()2955 inline bool StorageInfoProto::has_total_storage_size() const {
2956   return _internal_has_total_storage_size();
2957 }
clear_total_storage_size()2958 inline void StorageInfoProto::clear_total_storage_size() {
2959   _impl_.total_storage_size_ = ::int64_t{0};
2960   _impl_._has_bits_[0] &= ~0x00000008u;
2961 }
_internal_total_storage_size()2962 inline ::int64_t StorageInfoProto::_internal_total_storage_size() const {
2963   return _impl_.total_storage_size_;
2964 }
total_storage_size()2965 inline ::int64_t StorageInfoProto::total_storage_size() const {
2966   // @@protoc_insertion_point(field_get:icing.lib.StorageInfoProto.total_storage_size)
2967   return _internal_total_storage_size();
2968 }
_internal_set_total_storage_size(::int64_t value)2969 inline void StorageInfoProto::_internal_set_total_storage_size(::int64_t value) {
2970   _impl_._has_bits_[0] |= 0x00000008u;
2971   _impl_.total_storage_size_ = value;
2972 }
set_total_storage_size(::int64_t value)2973 inline void StorageInfoProto::set_total_storage_size(::int64_t value) {
2974   _internal_set_total_storage_size(value);
2975   // @@protoc_insertion_point(field_set:icing.lib.StorageInfoProto.total_storage_size)
2976 }
2977 
2978 // optional .icing.lib.DocumentStorageInfoProto document_storage_info = 2;
_internal_has_document_storage_info()2979 inline bool StorageInfoProto::_internal_has_document_storage_info() const {
2980   bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
2981   PROTOBUF_ASSUME(!value || _impl_.document_storage_info_ != nullptr);
2982   return value;
2983 }
has_document_storage_info()2984 inline bool StorageInfoProto::has_document_storage_info() const {
2985   return _internal_has_document_storage_info();
2986 }
clear_document_storage_info()2987 inline void StorageInfoProto::clear_document_storage_info() {
2988   if (_impl_.document_storage_info_ != nullptr) _impl_.document_storage_info_->Clear();
2989   _impl_._has_bits_[0] &= ~0x00000001u;
2990 }
_internal_document_storage_info()2991 inline const ::icing::lib::DocumentStorageInfoProto& StorageInfoProto::_internal_document_storage_info() const {
2992   const ::icing::lib::DocumentStorageInfoProto* p = _impl_.document_storage_info_;
2993   return p != nullptr ? *p : reinterpret_cast<const ::icing::lib::DocumentStorageInfoProto&>(
2994       ::icing::lib::_DocumentStorageInfoProto_default_instance_);
2995 }
document_storage_info()2996 inline const ::icing::lib::DocumentStorageInfoProto& StorageInfoProto::document_storage_info() const {
2997   // @@protoc_insertion_point(field_get:icing.lib.StorageInfoProto.document_storage_info)
2998   return _internal_document_storage_info();
2999 }
unsafe_arena_set_allocated_document_storage_info(::icing::lib::DocumentStorageInfoProto * document_storage_info)3000 inline void StorageInfoProto::unsafe_arena_set_allocated_document_storage_info(
3001     ::icing::lib::DocumentStorageInfoProto* document_storage_info) {
3002   if (GetArenaForAllocation() == nullptr) {
3003     delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.document_storage_info_);
3004   }
3005   _impl_.document_storage_info_ = document_storage_info;
3006   if (document_storage_info) {
3007     _impl_._has_bits_[0] |= 0x00000001u;
3008   } else {
3009     _impl_._has_bits_[0] &= ~0x00000001u;
3010   }
3011   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:icing.lib.StorageInfoProto.document_storage_info)
3012 }
release_document_storage_info()3013 inline ::icing::lib::DocumentStorageInfoProto* StorageInfoProto::release_document_storage_info() {
3014   _impl_._has_bits_[0] &= ~0x00000001u;
3015   ::icing::lib::DocumentStorageInfoProto* temp = _impl_.document_storage_info_;
3016   _impl_.document_storage_info_ = nullptr;
3017 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
3018   auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
3019   temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
3020   if (GetArenaForAllocation() == nullptr) { delete old; }
3021 #else  // PROTOBUF_FORCE_COPY_IN_RELEASE
3022   if (GetArenaForAllocation() != nullptr) {
3023     temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
3024   }
3025 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
3026   return temp;
3027 }
unsafe_arena_release_document_storage_info()3028 inline ::icing::lib::DocumentStorageInfoProto* StorageInfoProto::unsafe_arena_release_document_storage_info() {
3029   // @@protoc_insertion_point(field_release:icing.lib.StorageInfoProto.document_storage_info)
3030   _impl_._has_bits_[0] &= ~0x00000001u;
3031   ::icing::lib::DocumentStorageInfoProto* temp = _impl_.document_storage_info_;
3032   _impl_.document_storage_info_ = nullptr;
3033   return temp;
3034 }
_internal_mutable_document_storage_info()3035 inline ::icing::lib::DocumentStorageInfoProto* StorageInfoProto::_internal_mutable_document_storage_info() {
3036   _impl_._has_bits_[0] |= 0x00000001u;
3037   if (_impl_.document_storage_info_ == nullptr) {
3038     auto* p = CreateMaybeMessage<::icing::lib::DocumentStorageInfoProto>(GetArenaForAllocation());
3039     _impl_.document_storage_info_ = p;
3040   }
3041   return _impl_.document_storage_info_;
3042 }
mutable_document_storage_info()3043 inline ::icing::lib::DocumentStorageInfoProto* StorageInfoProto::mutable_document_storage_info() {
3044   ::icing::lib::DocumentStorageInfoProto* _msg = _internal_mutable_document_storage_info();
3045   // @@protoc_insertion_point(field_mutable:icing.lib.StorageInfoProto.document_storage_info)
3046   return _msg;
3047 }
set_allocated_document_storage_info(::icing::lib::DocumentStorageInfoProto * document_storage_info)3048 inline void StorageInfoProto::set_allocated_document_storage_info(::icing::lib::DocumentStorageInfoProto* document_storage_info) {
3049   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
3050   if (message_arena == nullptr) {
3051     delete _impl_.document_storage_info_;
3052   }
3053   if (document_storage_info) {
3054     ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
3055         ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(document_storage_info);
3056     if (message_arena != submessage_arena) {
3057       document_storage_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
3058           message_arena, document_storage_info, submessage_arena);
3059     }
3060     _impl_._has_bits_[0] |= 0x00000001u;
3061   } else {
3062     _impl_._has_bits_[0] &= ~0x00000001u;
3063   }
3064   _impl_.document_storage_info_ = document_storage_info;
3065   // @@protoc_insertion_point(field_set_allocated:icing.lib.StorageInfoProto.document_storage_info)
3066 }
3067 
3068 // optional .icing.lib.SchemaStoreStorageInfoProto schema_store_storage_info = 3;
_internal_has_schema_store_storage_info()3069 inline bool StorageInfoProto::_internal_has_schema_store_storage_info() const {
3070   bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
3071   PROTOBUF_ASSUME(!value || _impl_.schema_store_storage_info_ != nullptr);
3072   return value;
3073 }
has_schema_store_storage_info()3074 inline bool StorageInfoProto::has_schema_store_storage_info() const {
3075   return _internal_has_schema_store_storage_info();
3076 }
clear_schema_store_storage_info()3077 inline void StorageInfoProto::clear_schema_store_storage_info() {
3078   if (_impl_.schema_store_storage_info_ != nullptr) _impl_.schema_store_storage_info_->Clear();
3079   _impl_._has_bits_[0] &= ~0x00000002u;
3080 }
_internal_schema_store_storage_info()3081 inline const ::icing::lib::SchemaStoreStorageInfoProto& StorageInfoProto::_internal_schema_store_storage_info() const {
3082   const ::icing::lib::SchemaStoreStorageInfoProto* p = _impl_.schema_store_storage_info_;
3083   return p != nullptr ? *p : reinterpret_cast<const ::icing::lib::SchemaStoreStorageInfoProto&>(
3084       ::icing::lib::_SchemaStoreStorageInfoProto_default_instance_);
3085 }
schema_store_storage_info()3086 inline const ::icing::lib::SchemaStoreStorageInfoProto& StorageInfoProto::schema_store_storage_info() const {
3087   // @@protoc_insertion_point(field_get:icing.lib.StorageInfoProto.schema_store_storage_info)
3088   return _internal_schema_store_storage_info();
3089 }
unsafe_arena_set_allocated_schema_store_storage_info(::icing::lib::SchemaStoreStorageInfoProto * schema_store_storage_info)3090 inline void StorageInfoProto::unsafe_arena_set_allocated_schema_store_storage_info(
3091     ::icing::lib::SchemaStoreStorageInfoProto* schema_store_storage_info) {
3092   if (GetArenaForAllocation() == nullptr) {
3093     delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.schema_store_storage_info_);
3094   }
3095   _impl_.schema_store_storage_info_ = schema_store_storage_info;
3096   if (schema_store_storage_info) {
3097     _impl_._has_bits_[0] |= 0x00000002u;
3098   } else {
3099     _impl_._has_bits_[0] &= ~0x00000002u;
3100   }
3101   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:icing.lib.StorageInfoProto.schema_store_storage_info)
3102 }
release_schema_store_storage_info()3103 inline ::icing::lib::SchemaStoreStorageInfoProto* StorageInfoProto::release_schema_store_storage_info() {
3104   _impl_._has_bits_[0] &= ~0x00000002u;
3105   ::icing::lib::SchemaStoreStorageInfoProto* temp = _impl_.schema_store_storage_info_;
3106   _impl_.schema_store_storage_info_ = nullptr;
3107 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
3108   auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
3109   temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
3110   if (GetArenaForAllocation() == nullptr) { delete old; }
3111 #else  // PROTOBUF_FORCE_COPY_IN_RELEASE
3112   if (GetArenaForAllocation() != nullptr) {
3113     temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
3114   }
3115 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
3116   return temp;
3117 }
unsafe_arena_release_schema_store_storage_info()3118 inline ::icing::lib::SchemaStoreStorageInfoProto* StorageInfoProto::unsafe_arena_release_schema_store_storage_info() {
3119   // @@protoc_insertion_point(field_release:icing.lib.StorageInfoProto.schema_store_storage_info)
3120   _impl_._has_bits_[0] &= ~0x00000002u;
3121   ::icing::lib::SchemaStoreStorageInfoProto* temp = _impl_.schema_store_storage_info_;
3122   _impl_.schema_store_storage_info_ = nullptr;
3123   return temp;
3124 }
_internal_mutable_schema_store_storage_info()3125 inline ::icing::lib::SchemaStoreStorageInfoProto* StorageInfoProto::_internal_mutable_schema_store_storage_info() {
3126   _impl_._has_bits_[0] |= 0x00000002u;
3127   if (_impl_.schema_store_storage_info_ == nullptr) {
3128     auto* p = CreateMaybeMessage<::icing::lib::SchemaStoreStorageInfoProto>(GetArenaForAllocation());
3129     _impl_.schema_store_storage_info_ = p;
3130   }
3131   return _impl_.schema_store_storage_info_;
3132 }
mutable_schema_store_storage_info()3133 inline ::icing::lib::SchemaStoreStorageInfoProto* StorageInfoProto::mutable_schema_store_storage_info() {
3134   ::icing::lib::SchemaStoreStorageInfoProto* _msg = _internal_mutable_schema_store_storage_info();
3135   // @@protoc_insertion_point(field_mutable:icing.lib.StorageInfoProto.schema_store_storage_info)
3136   return _msg;
3137 }
set_allocated_schema_store_storage_info(::icing::lib::SchemaStoreStorageInfoProto * schema_store_storage_info)3138 inline void StorageInfoProto::set_allocated_schema_store_storage_info(::icing::lib::SchemaStoreStorageInfoProto* schema_store_storage_info) {
3139   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
3140   if (message_arena == nullptr) {
3141     delete _impl_.schema_store_storage_info_;
3142   }
3143   if (schema_store_storage_info) {
3144     ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
3145         ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(schema_store_storage_info);
3146     if (message_arena != submessage_arena) {
3147       schema_store_storage_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
3148           message_arena, schema_store_storage_info, submessage_arena);
3149     }
3150     _impl_._has_bits_[0] |= 0x00000002u;
3151   } else {
3152     _impl_._has_bits_[0] &= ~0x00000002u;
3153   }
3154   _impl_.schema_store_storage_info_ = schema_store_storage_info;
3155   // @@protoc_insertion_point(field_set_allocated:icing.lib.StorageInfoProto.schema_store_storage_info)
3156 }
3157 
3158 // optional .icing.lib.IndexStorageInfoProto index_storage_info = 4;
_internal_has_index_storage_info()3159 inline bool StorageInfoProto::_internal_has_index_storage_info() const {
3160   bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
3161   PROTOBUF_ASSUME(!value || _impl_.index_storage_info_ != nullptr);
3162   return value;
3163 }
has_index_storage_info()3164 inline bool StorageInfoProto::has_index_storage_info() const {
3165   return _internal_has_index_storage_info();
3166 }
clear_index_storage_info()3167 inline void StorageInfoProto::clear_index_storage_info() {
3168   if (_impl_.index_storage_info_ != nullptr) _impl_.index_storage_info_->Clear();
3169   _impl_._has_bits_[0] &= ~0x00000004u;
3170 }
_internal_index_storage_info()3171 inline const ::icing::lib::IndexStorageInfoProto& StorageInfoProto::_internal_index_storage_info() const {
3172   const ::icing::lib::IndexStorageInfoProto* p = _impl_.index_storage_info_;
3173   return p != nullptr ? *p : reinterpret_cast<const ::icing::lib::IndexStorageInfoProto&>(
3174       ::icing::lib::_IndexStorageInfoProto_default_instance_);
3175 }
index_storage_info()3176 inline const ::icing::lib::IndexStorageInfoProto& StorageInfoProto::index_storage_info() const {
3177   // @@protoc_insertion_point(field_get:icing.lib.StorageInfoProto.index_storage_info)
3178   return _internal_index_storage_info();
3179 }
unsafe_arena_set_allocated_index_storage_info(::icing::lib::IndexStorageInfoProto * index_storage_info)3180 inline void StorageInfoProto::unsafe_arena_set_allocated_index_storage_info(
3181     ::icing::lib::IndexStorageInfoProto* index_storage_info) {
3182   if (GetArenaForAllocation() == nullptr) {
3183     delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.index_storage_info_);
3184   }
3185   _impl_.index_storage_info_ = index_storage_info;
3186   if (index_storage_info) {
3187     _impl_._has_bits_[0] |= 0x00000004u;
3188   } else {
3189     _impl_._has_bits_[0] &= ~0x00000004u;
3190   }
3191   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:icing.lib.StorageInfoProto.index_storage_info)
3192 }
release_index_storage_info()3193 inline ::icing::lib::IndexStorageInfoProto* StorageInfoProto::release_index_storage_info() {
3194   _impl_._has_bits_[0] &= ~0x00000004u;
3195   ::icing::lib::IndexStorageInfoProto* temp = _impl_.index_storage_info_;
3196   _impl_.index_storage_info_ = nullptr;
3197 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
3198   auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
3199   temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
3200   if (GetArenaForAllocation() == nullptr) { delete old; }
3201 #else  // PROTOBUF_FORCE_COPY_IN_RELEASE
3202   if (GetArenaForAllocation() != nullptr) {
3203     temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
3204   }
3205 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
3206   return temp;
3207 }
unsafe_arena_release_index_storage_info()3208 inline ::icing::lib::IndexStorageInfoProto* StorageInfoProto::unsafe_arena_release_index_storage_info() {
3209   // @@protoc_insertion_point(field_release:icing.lib.StorageInfoProto.index_storage_info)
3210   _impl_._has_bits_[0] &= ~0x00000004u;
3211   ::icing::lib::IndexStorageInfoProto* temp = _impl_.index_storage_info_;
3212   _impl_.index_storage_info_ = nullptr;
3213   return temp;
3214 }
_internal_mutable_index_storage_info()3215 inline ::icing::lib::IndexStorageInfoProto* StorageInfoProto::_internal_mutable_index_storage_info() {
3216   _impl_._has_bits_[0] |= 0x00000004u;
3217   if (_impl_.index_storage_info_ == nullptr) {
3218     auto* p = CreateMaybeMessage<::icing::lib::IndexStorageInfoProto>(GetArenaForAllocation());
3219     _impl_.index_storage_info_ = p;
3220   }
3221   return _impl_.index_storage_info_;
3222 }
mutable_index_storage_info()3223 inline ::icing::lib::IndexStorageInfoProto* StorageInfoProto::mutable_index_storage_info() {
3224   ::icing::lib::IndexStorageInfoProto* _msg = _internal_mutable_index_storage_info();
3225   // @@protoc_insertion_point(field_mutable:icing.lib.StorageInfoProto.index_storage_info)
3226   return _msg;
3227 }
set_allocated_index_storage_info(::icing::lib::IndexStorageInfoProto * index_storage_info)3228 inline void StorageInfoProto::set_allocated_index_storage_info(::icing::lib::IndexStorageInfoProto* index_storage_info) {
3229   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
3230   if (message_arena == nullptr) {
3231     delete _impl_.index_storage_info_;
3232   }
3233   if (index_storage_info) {
3234     ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
3235         ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(index_storage_info);
3236     if (message_arena != submessage_arena) {
3237       index_storage_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
3238           message_arena, index_storage_info, submessage_arena);
3239     }
3240     _impl_._has_bits_[0] |= 0x00000004u;
3241   } else {
3242     _impl_._has_bits_[0] &= ~0x00000004u;
3243   }
3244   _impl_.index_storage_info_ = index_storage_info;
3245   // @@protoc_insertion_point(field_set_allocated:icing.lib.StorageInfoProto.index_storage_info)
3246 }
3247 
3248 // repeated .icing.lib.NamespaceBlobStorageInfoProto namespace_blob_storage_info = 5;
_internal_namespace_blob_storage_info_size()3249 inline int StorageInfoProto::_internal_namespace_blob_storage_info_size() const {
3250   return _impl_.namespace_blob_storage_info_.size();
3251 }
namespace_blob_storage_info_size()3252 inline int StorageInfoProto::namespace_blob_storage_info_size() const {
3253   return _internal_namespace_blob_storage_info_size();
3254 }
clear_namespace_blob_storage_info()3255 inline void StorageInfoProto::clear_namespace_blob_storage_info() {
3256   _impl_.namespace_blob_storage_info_.Clear();
3257 }
mutable_namespace_blob_storage_info(int index)3258 inline ::icing::lib::NamespaceBlobStorageInfoProto* StorageInfoProto::mutable_namespace_blob_storage_info(int index) {
3259   // @@protoc_insertion_point(field_mutable:icing.lib.StorageInfoProto.namespace_blob_storage_info)
3260   return _impl_.namespace_blob_storage_info_.Mutable(index);
3261 }
3262 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::NamespaceBlobStorageInfoProto >*
mutable_namespace_blob_storage_info()3263 StorageInfoProto::mutable_namespace_blob_storage_info() {
3264   // @@protoc_insertion_point(field_mutable_list:icing.lib.StorageInfoProto.namespace_blob_storage_info)
3265   return &_impl_.namespace_blob_storage_info_;
3266 }
_internal_namespace_blob_storage_info(int index)3267 inline const ::icing::lib::NamespaceBlobStorageInfoProto& StorageInfoProto::_internal_namespace_blob_storage_info(int index) const {
3268   return _impl_.namespace_blob_storage_info_.Get(index);
3269 }
namespace_blob_storage_info(int index)3270 inline const ::icing::lib::NamespaceBlobStorageInfoProto& StorageInfoProto::namespace_blob_storage_info(int index) const {
3271   // @@protoc_insertion_point(field_get:icing.lib.StorageInfoProto.namespace_blob_storage_info)
3272   return _internal_namespace_blob_storage_info(index);
3273 }
_internal_add_namespace_blob_storage_info()3274 inline ::icing::lib::NamespaceBlobStorageInfoProto* StorageInfoProto::_internal_add_namespace_blob_storage_info() {
3275   return _impl_.namespace_blob_storage_info_.Add();
3276 }
add_namespace_blob_storage_info()3277 inline ::icing::lib::NamespaceBlobStorageInfoProto* StorageInfoProto::add_namespace_blob_storage_info() {
3278   ::icing::lib::NamespaceBlobStorageInfoProto* _add = _internal_add_namespace_blob_storage_info();
3279   // @@protoc_insertion_point(field_add:icing.lib.StorageInfoProto.namespace_blob_storage_info)
3280   return _add;
3281 }
3282 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::icing::lib::NamespaceBlobStorageInfoProto >&
namespace_blob_storage_info()3283 StorageInfoProto::namespace_blob_storage_info() const {
3284   // @@protoc_insertion_point(field_list:icing.lib.StorageInfoProto.namespace_blob_storage_info)
3285   return _impl_.namespace_blob_storage_info_;
3286 }
3287 
3288 // -------------------------------------------------------------------
3289 
3290 // StorageInfoResultProto
3291 
3292 // optional .icing.lib.StatusProto status = 1;
_internal_has_status()3293 inline bool StorageInfoResultProto::_internal_has_status() const {
3294   bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
3295   PROTOBUF_ASSUME(!value || _impl_.status_ != nullptr);
3296   return value;
3297 }
has_status()3298 inline bool StorageInfoResultProto::has_status() const {
3299   return _internal_has_status();
3300 }
_internal_status()3301 inline const ::icing::lib::StatusProto& StorageInfoResultProto::_internal_status() const {
3302   const ::icing::lib::StatusProto* p = _impl_.status_;
3303   return p != nullptr ? *p : reinterpret_cast<const ::icing::lib::StatusProto&>(
3304       ::icing::lib::_StatusProto_default_instance_);
3305 }
status()3306 inline const ::icing::lib::StatusProto& StorageInfoResultProto::status() const {
3307   // @@protoc_insertion_point(field_get:icing.lib.StorageInfoResultProto.status)
3308   return _internal_status();
3309 }
unsafe_arena_set_allocated_status(::icing::lib::StatusProto * status)3310 inline void StorageInfoResultProto::unsafe_arena_set_allocated_status(
3311     ::icing::lib::StatusProto* status) {
3312   if (GetArenaForAllocation() == nullptr) {
3313     delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.status_);
3314   }
3315   _impl_.status_ = status;
3316   if (status) {
3317     _impl_._has_bits_[0] |= 0x00000001u;
3318   } else {
3319     _impl_._has_bits_[0] &= ~0x00000001u;
3320   }
3321   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:icing.lib.StorageInfoResultProto.status)
3322 }
release_status()3323 inline ::icing::lib::StatusProto* StorageInfoResultProto::release_status() {
3324   _impl_._has_bits_[0] &= ~0x00000001u;
3325   ::icing::lib::StatusProto* temp = _impl_.status_;
3326   _impl_.status_ = nullptr;
3327 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
3328   auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
3329   temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
3330   if (GetArenaForAllocation() == nullptr) { delete old; }
3331 #else  // PROTOBUF_FORCE_COPY_IN_RELEASE
3332   if (GetArenaForAllocation() != nullptr) {
3333     temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
3334   }
3335 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
3336   return temp;
3337 }
unsafe_arena_release_status()3338 inline ::icing::lib::StatusProto* StorageInfoResultProto::unsafe_arena_release_status() {
3339   // @@protoc_insertion_point(field_release:icing.lib.StorageInfoResultProto.status)
3340   _impl_._has_bits_[0] &= ~0x00000001u;
3341   ::icing::lib::StatusProto* temp = _impl_.status_;
3342   _impl_.status_ = nullptr;
3343   return temp;
3344 }
_internal_mutable_status()3345 inline ::icing::lib::StatusProto* StorageInfoResultProto::_internal_mutable_status() {
3346   _impl_._has_bits_[0] |= 0x00000001u;
3347   if (_impl_.status_ == nullptr) {
3348     auto* p = CreateMaybeMessage<::icing::lib::StatusProto>(GetArenaForAllocation());
3349     _impl_.status_ = p;
3350   }
3351   return _impl_.status_;
3352 }
mutable_status()3353 inline ::icing::lib::StatusProto* StorageInfoResultProto::mutable_status() {
3354   ::icing::lib::StatusProto* _msg = _internal_mutable_status();
3355   // @@protoc_insertion_point(field_mutable:icing.lib.StorageInfoResultProto.status)
3356   return _msg;
3357 }
set_allocated_status(::icing::lib::StatusProto * status)3358 inline void StorageInfoResultProto::set_allocated_status(::icing::lib::StatusProto* status) {
3359   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
3360   if (message_arena == nullptr) {
3361     delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.status_);
3362   }
3363   if (status) {
3364     ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
3365         ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
3366                 reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(status));
3367     if (message_arena != submessage_arena) {
3368       status = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
3369           message_arena, status, submessage_arena);
3370     }
3371     _impl_._has_bits_[0] |= 0x00000001u;
3372   } else {
3373     _impl_._has_bits_[0] &= ~0x00000001u;
3374   }
3375   _impl_.status_ = status;
3376   // @@protoc_insertion_point(field_set_allocated:icing.lib.StorageInfoResultProto.status)
3377 }
3378 
3379 // optional .icing.lib.StorageInfoProto storage_info = 2;
_internal_has_storage_info()3380 inline bool StorageInfoResultProto::_internal_has_storage_info() const {
3381   bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
3382   PROTOBUF_ASSUME(!value || _impl_.storage_info_ != nullptr);
3383   return value;
3384 }
has_storage_info()3385 inline bool StorageInfoResultProto::has_storage_info() const {
3386   return _internal_has_storage_info();
3387 }
clear_storage_info()3388 inline void StorageInfoResultProto::clear_storage_info() {
3389   if (_impl_.storage_info_ != nullptr) _impl_.storage_info_->Clear();
3390   _impl_._has_bits_[0] &= ~0x00000002u;
3391 }
_internal_storage_info()3392 inline const ::icing::lib::StorageInfoProto& StorageInfoResultProto::_internal_storage_info() const {
3393   const ::icing::lib::StorageInfoProto* p = _impl_.storage_info_;
3394   return p != nullptr ? *p : reinterpret_cast<const ::icing::lib::StorageInfoProto&>(
3395       ::icing::lib::_StorageInfoProto_default_instance_);
3396 }
storage_info()3397 inline const ::icing::lib::StorageInfoProto& StorageInfoResultProto::storage_info() const {
3398   // @@protoc_insertion_point(field_get:icing.lib.StorageInfoResultProto.storage_info)
3399   return _internal_storage_info();
3400 }
unsafe_arena_set_allocated_storage_info(::icing::lib::StorageInfoProto * storage_info)3401 inline void StorageInfoResultProto::unsafe_arena_set_allocated_storage_info(
3402     ::icing::lib::StorageInfoProto* storage_info) {
3403   if (GetArenaForAllocation() == nullptr) {
3404     delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.storage_info_);
3405   }
3406   _impl_.storage_info_ = storage_info;
3407   if (storage_info) {
3408     _impl_._has_bits_[0] |= 0x00000002u;
3409   } else {
3410     _impl_._has_bits_[0] &= ~0x00000002u;
3411   }
3412   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:icing.lib.StorageInfoResultProto.storage_info)
3413 }
release_storage_info()3414 inline ::icing::lib::StorageInfoProto* StorageInfoResultProto::release_storage_info() {
3415   _impl_._has_bits_[0] &= ~0x00000002u;
3416   ::icing::lib::StorageInfoProto* temp = _impl_.storage_info_;
3417   _impl_.storage_info_ = nullptr;
3418 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
3419   auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
3420   temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
3421   if (GetArenaForAllocation() == nullptr) { delete old; }
3422 #else  // PROTOBUF_FORCE_COPY_IN_RELEASE
3423   if (GetArenaForAllocation() != nullptr) {
3424     temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
3425   }
3426 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
3427   return temp;
3428 }
unsafe_arena_release_storage_info()3429 inline ::icing::lib::StorageInfoProto* StorageInfoResultProto::unsafe_arena_release_storage_info() {
3430   // @@protoc_insertion_point(field_release:icing.lib.StorageInfoResultProto.storage_info)
3431   _impl_._has_bits_[0] &= ~0x00000002u;
3432   ::icing::lib::StorageInfoProto* temp = _impl_.storage_info_;
3433   _impl_.storage_info_ = nullptr;
3434   return temp;
3435 }
_internal_mutable_storage_info()3436 inline ::icing::lib::StorageInfoProto* StorageInfoResultProto::_internal_mutable_storage_info() {
3437   _impl_._has_bits_[0] |= 0x00000002u;
3438   if (_impl_.storage_info_ == nullptr) {
3439     auto* p = CreateMaybeMessage<::icing::lib::StorageInfoProto>(GetArenaForAllocation());
3440     _impl_.storage_info_ = p;
3441   }
3442   return _impl_.storage_info_;
3443 }
mutable_storage_info()3444 inline ::icing::lib::StorageInfoProto* StorageInfoResultProto::mutable_storage_info() {
3445   ::icing::lib::StorageInfoProto* _msg = _internal_mutable_storage_info();
3446   // @@protoc_insertion_point(field_mutable:icing.lib.StorageInfoResultProto.storage_info)
3447   return _msg;
3448 }
set_allocated_storage_info(::icing::lib::StorageInfoProto * storage_info)3449 inline void StorageInfoResultProto::set_allocated_storage_info(::icing::lib::StorageInfoProto* storage_info) {
3450   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
3451   if (message_arena == nullptr) {
3452     delete _impl_.storage_info_;
3453   }
3454   if (storage_info) {
3455     ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
3456         ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(storage_info);
3457     if (message_arena != submessage_arena) {
3458       storage_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
3459           message_arena, storage_info, submessage_arena);
3460     }
3461     _impl_._has_bits_[0] |= 0x00000002u;
3462   } else {
3463     _impl_._has_bits_[0] &= ~0x00000002u;
3464   }
3465   _impl_.storage_info_ = storage_info;
3466   // @@protoc_insertion_point(field_set_allocated:icing.lib.StorageInfoResultProto.storage_info)
3467 }
3468 
3469 #ifdef __GNUC__
3470   #pragma GCC diagnostic pop
3471 #endif  // __GNUC__
3472 // -------------------------------------------------------------------
3473 
3474 // -------------------------------------------------------------------
3475 
3476 // -------------------------------------------------------------------
3477 
3478 // -------------------------------------------------------------------
3479 
3480 // -------------------------------------------------------------------
3481 
3482 // -------------------------------------------------------------------
3483 
3484 
3485 // @@protoc_insertion_point(namespace_scope)
3486 
3487 }  // namespace lib
3488 }  // namespace icing
3489 
3490 // @@protoc_insertion_point(global_scope)
3491 
3492 #include <google/protobuf/port_undef.inc>
3493 #endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_icing_2fproto_2fstorage_2eproto
3494