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