1 // Generated by the protocol buffer compiler. DO NOT EDIT!
2 // source: icing/proto/debug.proto
3
4 #include "icing/proto/debug.pb.h"
5
6 #include <algorithm>
7 #include <cstdint>
8
9 #include <google/protobuf/io/coded_stream.h>
10 #include <google/protobuf/extension_set.h>
11 #include <google/protobuf/wire_format_lite.h>
12 #include <google/protobuf/io/zero_copy_stream_impl_lite.h>
13 // @@protoc_insertion_point(includes)
14 #include <google/protobuf/port_def.inc>
15
16 PROTOBUF_PRAGMA_INIT_SEG
17
18 namespace _pb = ::PROTOBUF_NAMESPACE_ID;
19 namespace _pbi = _pb::internal;
20
21 namespace icing {
22 namespace lib {
LogSeverity(::_pbi::ConstantInitialized)23 PROTOBUF_CONSTEXPR LogSeverity::LogSeverity(
24 ::_pbi::ConstantInitialized): _impl_{
25 /*decltype(_impl_._cached_size_)*/{}} {}
26 struct LogSeverityDefaultTypeInternal {
LogSeverityDefaultTypeInternalicing::lib::LogSeverityDefaultTypeInternal27 PROTOBUF_CONSTEXPR LogSeverityDefaultTypeInternal()
28 : _instance(::_pbi::ConstantInitialized{}) {}
~LogSeverityDefaultTypeInternalicing::lib::LogSeverityDefaultTypeInternal29 ~LogSeverityDefaultTypeInternal() {}
30 union { // NOLINT(misc-non-private-member-variables-in-classes)
31 LogSeverity _instance;
32 };
33 };
34 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 LogSeverityDefaultTypeInternal _LogSeverity_default_instance_;
DebugInfoVerbosity(::_pbi::ConstantInitialized)35 PROTOBUF_CONSTEXPR DebugInfoVerbosity::DebugInfoVerbosity(
36 ::_pbi::ConstantInitialized): _impl_{
37 /*decltype(_impl_._cached_size_)*/{}} {}
38 struct DebugInfoVerbosityDefaultTypeInternal {
DebugInfoVerbosityDefaultTypeInternalicing::lib::DebugInfoVerbosityDefaultTypeInternal39 PROTOBUF_CONSTEXPR DebugInfoVerbosityDefaultTypeInternal()
40 : _instance(::_pbi::ConstantInitialized{}) {}
~DebugInfoVerbosityDefaultTypeInternalicing::lib::DebugInfoVerbosityDefaultTypeInternal41 ~DebugInfoVerbosityDefaultTypeInternal() {}
42 union { // NOLINT(misc-non-private-member-variables-in-classes)
43 DebugInfoVerbosity _instance;
44 };
45 };
46 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DebugInfoVerbosityDefaultTypeInternal _DebugInfoVerbosity_default_instance_;
IndexDebugInfoProto(::_pbi::ConstantInitialized)47 PROTOBUF_CONSTEXPR IndexDebugInfoProto::IndexDebugInfoProto(
48 ::_pbi::ConstantInitialized): _impl_{
49 /*decltype(_impl_._has_bits_)*/{}
50 , /*decltype(_impl_._cached_size_)*/{}
51 , /*decltype(_impl_.main_index_info_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
52 , /*decltype(_impl_.lite_index_info_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
53 , /*decltype(_impl_.index_storage_info_)*/nullptr} {}
54 struct IndexDebugInfoProtoDefaultTypeInternal {
IndexDebugInfoProtoDefaultTypeInternalicing::lib::IndexDebugInfoProtoDefaultTypeInternal55 PROTOBUF_CONSTEXPR IndexDebugInfoProtoDefaultTypeInternal()
56 : _instance(::_pbi::ConstantInitialized{}) {}
~IndexDebugInfoProtoDefaultTypeInternalicing::lib::IndexDebugInfoProtoDefaultTypeInternal57 ~IndexDebugInfoProtoDefaultTypeInternal() {}
58 union { // NOLINT(misc-non-private-member-variables-in-classes)
59 IndexDebugInfoProto _instance;
60 };
61 };
62 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 IndexDebugInfoProtoDefaultTypeInternal _IndexDebugInfoProto_default_instance_;
DocumentDebugInfoProto_CorpusInfo(::_pbi::ConstantInitialized)63 PROTOBUF_CONSTEXPR DocumentDebugInfoProto_CorpusInfo::DocumentDebugInfoProto_CorpusInfo(
64 ::_pbi::ConstantInitialized): _impl_{
65 /*decltype(_impl_._has_bits_)*/{}
66 , /*decltype(_impl_._cached_size_)*/{}
67 , /*decltype(_impl_.namespace__)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
68 , /*decltype(_impl_.schema_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
69 , /*decltype(_impl_.total_documents_)*/0u
70 , /*decltype(_impl_.total_token_)*/0u} {}
71 struct DocumentDebugInfoProto_CorpusInfoDefaultTypeInternal {
DocumentDebugInfoProto_CorpusInfoDefaultTypeInternalicing::lib::DocumentDebugInfoProto_CorpusInfoDefaultTypeInternal72 PROTOBUF_CONSTEXPR DocumentDebugInfoProto_CorpusInfoDefaultTypeInternal()
73 : _instance(::_pbi::ConstantInitialized{}) {}
~DocumentDebugInfoProto_CorpusInfoDefaultTypeInternalicing::lib::DocumentDebugInfoProto_CorpusInfoDefaultTypeInternal74 ~DocumentDebugInfoProto_CorpusInfoDefaultTypeInternal() {}
75 union { // NOLINT(misc-non-private-member-variables-in-classes)
76 DocumentDebugInfoProto_CorpusInfo _instance;
77 };
78 };
79 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DocumentDebugInfoProto_CorpusInfoDefaultTypeInternal _DocumentDebugInfoProto_CorpusInfo_default_instance_;
DocumentDebugInfoProto(::_pbi::ConstantInitialized)80 PROTOBUF_CONSTEXPR DocumentDebugInfoProto::DocumentDebugInfoProto(
81 ::_pbi::ConstantInitialized): _impl_{
82 /*decltype(_impl_._has_bits_)*/{}
83 , /*decltype(_impl_._cached_size_)*/{}
84 , /*decltype(_impl_.corpus_info_)*/{}
85 , /*decltype(_impl_.document_storage_info_)*/nullptr
86 , /*decltype(_impl_.crc_)*/0u} {}
87 struct DocumentDebugInfoProtoDefaultTypeInternal {
DocumentDebugInfoProtoDefaultTypeInternalicing::lib::DocumentDebugInfoProtoDefaultTypeInternal88 PROTOBUF_CONSTEXPR DocumentDebugInfoProtoDefaultTypeInternal()
89 : _instance(::_pbi::ConstantInitialized{}) {}
~DocumentDebugInfoProtoDefaultTypeInternalicing::lib::DocumentDebugInfoProtoDefaultTypeInternal90 ~DocumentDebugInfoProtoDefaultTypeInternal() {}
91 union { // NOLINT(misc-non-private-member-variables-in-classes)
92 DocumentDebugInfoProto _instance;
93 };
94 };
95 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DocumentDebugInfoProtoDefaultTypeInternal _DocumentDebugInfoProto_default_instance_;
SchemaDebugInfoProto(::_pbi::ConstantInitialized)96 PROTOBUF_CONSTEXPR SchemaDebugInfoProto::SchemaDebugInfoProto(
97 ::_pbi::ConstantInitialized): _impl_{
98 /*decltype(_impl_._has_bits_)*/{}
99 , /*decltype(_impl_._cached_size_)*/{}
100 , /*decltype(_impl_.schema_)*/nullptr
101 , /*decltype(_impl_.crc_)*/0u} {}
102 struct SchemaDebugInfoProtoDefaultTypeInternal {
SchemaDebugInfoProtoDefaultTypeInternalicing::lib::SchemaDebugInfoProtoDefaultTypeInternal103 PROTOBUF_CONSTEXPR SchemaDebugInfoProtoDefaultTypeInternal()
104 : _instance(::_pbi::ConstantInitialized{}) {}
~SchemaDebugInfoProtoDefaultTypeInternalicing::lib::SchemaDebugInfoProtoDefaultTypeInternal105 ~SchemaDebugInfoProtoDefaultTypeInternal() {}
106 union { // NOLINT(misc-non-private-member-variables-in-classes)
107 SchemaDebugInfoProto _instance;
108 };
109 };
110 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SchemaDebugInfoProtoDefaultTypeInternal _SchemaDebugInfoProto_default_instance_;
DebugInfoProto(::_pbi::ConstantInitialized)111 PROTOBUF_CONSTEXPR DebugInfoProto::DebugInfoProto(
112 ::_pbi::ConstantInitialized): _impl_{
113 /*decltype(_impl_._has_bits_)*/{}
114 , /*decltype(_impl_._cached_size_)*/{}
115 , /*decltype(_impl_.index_info_)*/nullptr
116 , /*decltype(_impl_.document_info_)*/nullptr
117 , /*decltype(_impl_.schema_info_)*/nullptr} {}
118 struct DebugInfoProtoDefaultTypeInternal {
DebugInfoProtoDefaultTypeInternalicing::lib::DebugInfoProtoDefaultTypeInternal119 PROTOBUF_CONSTEXPR DebugInfoProtoDefaultTypeInternal()
120 : _instance(::_pbi::ConstantInitialized{}) {}
~DebugInfoProtoDefaultTypeInternalicing::lib::DebugInfoProtoDefaultTypeInternal121 ~DebugInfoProtoDefaultTypeInternal() {}
122 union { // NOLINT(misc-non-private-member-variables-in-classes)
123 DebugInfoProto _instance;
124 };
125 };
126 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DebugInfoProtoDefaultTypeInternal _DebugInfoProto_default_instance_;
DebugInfoResultProto(::_pbi::ConstantInitialized)127 PROTOBUF_CONSTEXPR DebugInfoResultProto::DebugInfoResultProto(
128 ::_pbi::ConstantInitialized): _impl_{
129 /*decltype(_impl_._has_bits_)*/{}
130 , /*decltype(_impl_._cached_size_)*/{}
131 , /*decltype(_impl_.status_)*/nullptr
132 , /*decltype(_impl_.debug_info_)*/nullptr} {}
133 struct DebugInfoResultProtoDefaultTypeInternal {
DebugInfoResultProtoDefaultTypeInternalicing::lib::DebugInfoResultProtoDefaultTypeInternal134 PROTOBUF_CONSTEXPR DebugInfoResultProtoDefaultTypeInternal()
135 : _instance(::_pbi::ConstantInitialized{}) {}
~DebugInfoResultProtoDefaultTypeInternalicing::lib::DebugInfoResultProtoDefaultTypeInternal136 ~DebugInfoResultProtoDefaultTypeInternal() {}
137 union { // NOLINT(misc-non-private-member-variables-in-classes)
138 DebugInfoResultProto _instance;
139 };
140 };
141 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DebugInfoResultProtoDefaultTypeInternal _DebugInfoResultProto_default_instance_;
142 } // namespace lib
143 } // namespace icing
144 namespace icing {
145 namespace lib {
LogSeverity_Code_IsValid(int value)146 bool LogSeverity_Code_IsValid(int value) {
147 switch (value) {
148 case 0:
149 case 1:
150 case 2:
151 case 3:
152 case 4:
153 case 5:
154 return true;
155 default:
156 return false;
157 }
158 }
159
160 static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> LogSeverity_Code_strings[6] = {};
161
162 static const char LogSeverity_Code_names[] =
163 "DBG"
164 "ERROR"
165 "FATAL"
166 "INFO"
167 "VERBOSE"
168 "WARNING";
169
170 static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry LogSeverity_Code_entries[] = {
171 { {LogSeverity_Code_names + 0, 3}, 1 },
172 { {LogSeverity_Code_names + 3, 5}, 4 },
173 { {LogSeverity_Code_names + 8, 5}, 5 },
174 { {LogSeverity_Code_names + 13, 4}, 2 },
175 { {LogSeverity_Code_names + 17, 7}, 0 },
176 { {LogSeverity_Code_names + 24, 7}, 3 },
177 };
178
179 static const int LogSeverity_Code_entries_by_number[] = {
180 4, // 0 -> VERBOSE
181 0, // 1 -> DBG
182 3, // 2 -> INFO
183 5, // 3 -> WARNING
184 1, // 4 -> ERROR
185 2, // 5 -> FATAL
186 };
187
LogSeverity_Code_Name(LogSeverity_Code value)188 const std::string& LogSeverity_Code_Name(
189 LogSeverity_Code value) {
190 static const bool dummy =
191 ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
192 LogSeverity_Code_entries,
193 LogSeverity_Code_entries_by_number,
194 6, LogSeverity_Code_strings);
195 (void) dummy;
196 int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
197 LogSeverity_Code_entries,
198 LogSeverity_Code_entries_by_number,
199 6, value);
200 return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
201 LogSeverity_Code_strings[idx].get();
202 }
LogSeverity_Code_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,LogSeverity_Code * value)203 bool LogSeverity_Code_Parse(
204 ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, LogSeverity_Code* value) {
205 int int_value;
206 bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
207 LogSeverity_Code_entries, 6, name, &int_value);
208 if (success) {
209 *value = static_cast<LogSeverity_Code>(int_value);
210 }
211 return success;
212 }
213 #if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
214 constexpr LogSeverity_Code LogSeverity::VERBOSE;
215 constexpr LogSeverity_Code LogSeverity::DBG;
216 constexpr LogSeverity_Code LogSeverity::INFO;
217 constexpr LogSeverity_Code LogSeverity::WARNING;
218 constexpr LogSeverity_Code LogSeverity::ERROR;
219 constexpr LogSeverity_Code LogSeverity::FATAL;
220 constexpr LogSeverity_Code LogSeverity::Code_MIN;
221 constexpr LogSeverity_Code LogSeverity::Code_MAX;
222 constexpr int LogSeverity::Code_ARRAYSIZE;
223 #endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
DebugInfoVerbosity_Code_IsValid(int value)224 bool DebugInfoVerbosity_Code_IsValid(int value) {
225 switch (value) {
226 case 0:
227 case 1:
228 return true;
229 default:
230 return false;
231 }
232 }
233
234 static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> DebugInfoVerbosity_Code_strings[2] = {};
235
236 static const char DebugInfoVerbosity_Code_names[] =
237 "BASIC"
238 "DETAILED";
239
240 static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry DebugInfoVerbosity_Code_entries[] = {
241 { {DebugInfoVerbosity_Code_names + 0, 5}, 0 },
242 { {DebugInfoVerbosity_Code_names + 5, 8}, 1 },
243 };
244
245 static const int DebugInfoVerbosity_Code_entries_by_number[] = {
246 0, // 0 -> BASIC
247 1, // 1 -> DETAILED
248 };
249
DebugInfoVerbosity_Code_Name(DebugInfoVerbosity_Code value)250 const std::string& DebugInfoVerbosity_Code_Name(
251 DebugInfoVerbosity_Code value) {
252 static const bool dummy =
253 ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
254 DebugInfoVerbosity_Code_entries,
255 DebugInfoVerbosity_Code_entries_by_number,
256 2, DebugInfoVerbosity_Code_strings);
257 (void) dummy;
258 int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
259 DebugInfoVerbosity_Code_entries,
260 DebugInfoVerbosity_Code_entries_by_number,
261 2, value);
262 return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
263 DebugInfoVerbosity_Code_strings[idx].get();
264 }
DebugInfoVerbosity_Code_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,DebugInfoVerbosity_Code * value)265 bool DebugInfoVerbosity_Code_Parse(
266 ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DebugInfoVerbosity_Code* value) {
267 int int_value;
268 bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
269 DebugInfoVerbosity_Code_entries, 2, name, &int_value);
270 if (success) {
271 *value = static_cast<DebugInfoVerbosity_Code>(int_value);
272 }
273 return success;
274 }
275 #if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
276 constexpr DebugInfoVerbosity_Code DebugInfoVerbosity::BASIC;
277 constexpr DebugInfoVerbosity_Code DebugInfoVerbosity::DETAILED;
278 constexpr DebugInfoVerbosity_Code DebugInfoVerbosity::Code_MIN;
279 constexpr DebugInfoVerbosity_Code DebugInfoVerbosity::Code_MAX;
280 constexpr int DebugInfoVerbosity::Code_ARRAYSIZE;
281 #endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
282
283 // ===================================================================
284
285 class LogSeverity::_Internal {
286 public:
287 };
288
LogSeverity(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)289 LogSeverity::LogSeverity(::PROTOBUF_NAMESPACE_ID::Arena* arena,
290 bool is_message_owned)
291 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
292 SharedCtor(arena, is_message_owned);
293 // @@protoc_insertion_point(arena_constructor:icing.lib.LogSeverity)
294 }
LogSeverity(const LogSeverity & from)295 LogSeverity::LogSeverity(const LogSeverity& from)
296 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
297 LogSeverity* const _this = this; (void)_this;
298 new (&_impl_) Impl_{
299 /*decltype(_impl_._cached_size_)*/{}};
300
301 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
302 // @@protoc_insertion_point(copy_constructor:icing.lib.LogSeverity)
303 }
304
SharedCtor(::_pb::Arena * arena,bool is_message_owned)305 inline void LogSeverity::SharedCtor(
306 ::_pb::Arena* arena, bool is_message_owned) {
307 (void)arena;
308 (void)is_message_owned;
309 new (&_impl_) Impl_{
310 /*decltype(_impl_._cached_size_)*/{}
311 };
312 }
313
~LogSeverity()314 LogSeverity::~LogSeverity() {
315 // @@protoc_insertion_point(destructor:icing.lib.LogSeverity)
316 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
317 (void)arena;
318 return;
319 }
320 SharedDtor();
321 }
322
SharedDtor()323 inline void LogSeverity::SharedDtor() {
324 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
325 }
326
SetCachedSize(int size) const327 void LogSeverity::SetCachedSize(int size) const {
328 _impl_._cached_size_.Set(size);
329 }
330
Clear()331 void LogSeverity::Clear() {
332 // @@protoc_insertion_point(message_clear_start:icing.lib.LogSeverity)
333 ::uint32_t cached_has_bits = 0;
334 // Prevent compiler warnings about cached_has_bits being unused
335 (void) cached_has_bits;
336
337 _internal_metadata_.Clear<std::string>();
338 }
339
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)340 const char* LogSeverity::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
341 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
342 while (!ctx->Done(&ptr)) {
343 ::uint32_t tag;
344 ptr = ::_pbi::ReadTag(ptr, &tag);
345 if ((tag == 0) || ((tag & 7) == 4)) {
346 CHK_(ptr);
347 ctx->SetLastTag(tag);
348 goto message_done;
349 }
350 ptr = UnknownFieldParse(
351 tag,
352 _internal_metadata_.mutable_unknown_fields<std::string>(),
353 ptr, ctx);
354 CHK_(ptr != nullptr);
355 } // while
356 message_done:
357 return ptr;
358 failure:
359 ptr = nullptr;
360 goto message_done;
361 #undef CHK_
362 }
363
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const364 ::uint8_t* LogSeverity::_InternalSerialize(
365 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
366 // @@protoc_insertion_point(serialize_to_array_start:icing.lib.LogSeverity)
367 ::uint32_t cached_has_bits = 0;
368 (void) cached_has_bits;
369
370 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
371 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
372 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
373 }
374 // @@protoc_insertion_point(serialize_to_array_end:icing.lib.LogSeverity)
375 return target;
376 }
377
ByteSizeLong() const378 size_t LogSeverity::ByteSizeLong() const {
379 // @@protoc_insertion_point(message_byte_size_start:icing.lib.LogSeverity)
380 size_t total_size = 0;
381
382 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
383 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
384 }
385 int cached_size = ::_pbi::ToCachedSize(total_size);
386 SetCachedSize(cached_size);
387 return total_size;
388 }
389
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)390 void LogSeverity::CheckTypeAndMergeFrom(
391 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
392 MergeFrom(*::_pbi::DownCast<const LogSeverity*>(
393 &from));
394 }
395
MergeFrom(const LogSeverity & from)396 void LogSeverity::MergeFrom(const LogSeverity& from) {
397 LogSeverity* const _this = this;
398 // @@protoc_insertion_point(class_specific_merge_from_start:icing.lib.LogSeverity)
399 GOOGLE_DCHECK_NE(&from, _this);
400 ::uint32_t cached_has_bits = 0;
401 (void) cached_has_bits;
402
403 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
404 }
405
CopyFrom(const LogSeverity & from)406 void LogSeverity::CopyFrom(const LogSeverity& from) {
407 // @@protoc_insertion_point(class_specific_copy_from_start:icing.lib.LogSeverity)
408 if (&from == this) return;
409 Clear();
410 MergeFrom(from);
411 }
412
IsInitialized() const413 bool LogSeverity::IsInitialized() const {
414 return true;
415 }
416
InternalSwap(LogSeverity * other)417 void LogSeverity::InternalSwap(LogSeverity* other) {
418 using std::swap;
419 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
420 }
421
GetTypeName() const422 std::string LogSeverity::GetTypeName() const {
423 return "icing.lib.LogSeverity";
424 }
425
426
427 // ===================================================================
428
429 class DebugInfoVerbosity::_Internal {
430 public:
431 };
432
DebugInfoVerbosity(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)433 DebugInfoVerbosity::DebugInfoVerbosity(::PROTOBUF_NAMESPACE_ID::Arena* arena,
434 bool is_message_owned)
435 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
436 SharedCtor(arena, is_message_owned);
437 // @@protoc_insertion_point(arena_constructor:icing.lib.DebugInfoVerbosity)
438 }
DebugInfoVerbosity(const DebugInfoVerbosity & from)439 DebugInfoVerbosity::DebugInfoVerbosity(const DebugInfoVerbosity& from)
440 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
441 DebugInfoVerbosity* const _this = this; (void)_this;
442 new (&_impl_) Impl_{
443 /*decltype(_impl_._cached_size_)*/{}};
444
445 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
446 // @@protoc_insertion_point(copy_constructor:icing.lib.DebugInfoVerbosity)
447 }
448
SharedCtor(::_pb::Arena * arena,bool is_message_owned)449 inline void DebugInfoVerbosity::SharedCtor(
450 ::_pb::Arena* arena, bool is_message_owned) {
451 (void)arena;
452 (void)is_message_owned;
453 new (&_impl_) Impl_{
454 /*decltype(_impl_._cached_size_)*/{}
455 };
456 }
457
~DebugInfoVerbosity()458 DebugInfoVerbosity::~DebugInfoVerbosity() {
459 // @@protoc_insertion_point(destructor:icing.lib.DebugInfoVerbosity)
460 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
461 (void)arena;
462 return;
463 }
464 SharedDtor();
465 }
466
SharedDtor()467 inline void DebugInfoVerbosity::SharedDtor() {
468 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
469 }
470
SetCachedSize(int size) const471 void DebugInfoVerbosity::SetCachedSize(int size) const {
472 _impl_._cached_size_.Set(size);
473 }
474
Clear()475 void DebugInfoVerbosity::Clear() {
476 // @@protoc_insertion_point(message_clear_start:icing.lib.DebugInfoVerbosity)
477 ::uint32_t cached_has_bits = 0;
478 // Prevent compiler warnings about cached_has_bits being unused
479 (void) cached_has_bits;
480
481 _internal_metadata_.Clear<std::string>();
482 }
483
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)484 const char* DebugInfoVerbosity::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
485 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
486 while (!ctx->Done(&ptr)) {
487 ::uint32_t tag;
488 ptr = ::_pbi::ReadTag(ptr, &tag);
489 if ((tag == 0) || ((tag & 7) == 4)) {
490 CHK_(ptr);
491 ctx->SetLastTag(tag);
492 goto message_done;
493 }
494 ptr = UnknownFieldParse(
495 tag,
496 _internal_metadata_.mutable_unknown_fields<std::string>(),
497 ptr, ctx);
498 CHK_(ptr != nullptr);
499 } // while
500 message_done:
501 return ptr;
502 failure:
503 ptr = nullptr;
504 goto message_done;
505 #undef CHK_
506 }
507
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const508 ::uint8_t* DebugInfoVerbosity::_InternalSerialize(
509 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
510 // @@protoc_insertion_point(serialize_to_array_start:icing.lib.DebugInfoVerbosity)
511 ::uint32_t cached_has_bits = 0;
512 (void) cached_has_bits;
513
514 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
515 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
516 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
517 }
518 // @@protoc_insertion_point(serialize_to_array_end:icing.lib.DebugInfoVerbosity)
519 return target;
520 }
521
ByteSizeLong() const522 size_t DebugInfoVerbosity::ByteSizeLong() const {
523 // @@protoc_insertion_point(message_byte_size_start:icing.lib.DebugInfoVerbosity)
524 size_t total_size = 0;
525
526 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
527 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
528 }
529 int cached_size = ::_pbi::ToCachedSize(total_size);
530 SetCachedSize(cached_size);
531 return total_size;
532 }
533
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)534 void DebugInfoVerbosity::CheckTypeAndMergeFrom(
535 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
536 MergeFrom(*::_pbi::DownCast<const DebugInfoVerbosity*>(
537 &from));
538 }
539
MergeFrom(const DebugInfoVerbosity & from)540 void DebugInfoVerbosity::MergeFrom(const DebugInfoVerbosity& from) {
541 DebugInfoVerbosity* const _this = this;
542 // @@protoc_insertion_point(class_specific_merge_from_start:icing.lib.DebugInfoVerbosity)
543 GOOGLE_DCHECK_NE(&from, _this);
544 ::uint32_t cached_has_bits = 0;
545 (void) cached_has_bits;
546
547 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
548 }
549
CopyFrom(const DebugInfoVerbosity & from)550 void DebugInfoVerbosity::CopyFrom(const DebugInfoVerbosity& from) {
551 // @@protoc_insertion_point(class_specific_copy_from_start:icing.lib.DebugInfoVerbosity)
552 if (&from == this) return;
553 Clear();
554 MergeFrom(from);
555 }
556
IsInitialized() const557 bool DebugInfoVerbosity::IsInitialized() const {
558 return true;
559 }
560
InternalSwap(DebugInfoVerbosity * other)561 void DebugInfoVerbosity::InternalSwap(DebugInfoVerbosity* other) {
562 using std::swap;
563 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
564 }
565
GetTypeName() const566 std::string DebugInfoVerbosity::GetTypeName() const {
567 return "icing.lib.DebugInfoVerbosity";
568 }
569
570
571 // ===================================================================
572
573 class IndexDebugInfoProto::_Internal {
574 public:
575 using HasBits = decltype(std::declval<IndexDebugInfoProto>()._impl_._has_bits_);
576 static const ::icing::lib::IndexStorageInfoProto& index_storage_info(const IndexDebugInfoProto* msg);
set_has_index_storage_info(HasBits * has_bits)577 static void set_has_index_storage_info(HasBits* has_bits) {
578 (*has_bits)[0] |= 4u;
579 }
set_has_main_index_info(HasBits * has_bits)580 static void set_has_main_index_info(HasBits* has_bits) {
581 (*has_bits)[0] |= 1u;
582 }
set_has_lite_index_info(HasBits * has_bits)583 static void set_has_lite_index_info(HasBits* has_bits) {
584 (*has_bits)[0] |= 2u;
585 }
586 };
587
588 const ::icing::lib::IndexStorageInfoProto&
index_storage_info(const IndexDebugInfoProto * msg)589 IndexDebugInfoProto::_Internal::index_storage_info(const IndexDebugInfoProto* msg) {
590 return *msg->_impl_.index_storage_info_;
591 }
clear_index_storage_info()592 void IndexDebugInfoProto::clear_index_storage_info() {
593 if (_impl_.index_storage_info_ != nullptr) _impl_.index_storage_info_->Clear();
594 _impl_._has_bits_[0] &= ~0x00000004u;
595 }
IndexDebugInfoProto(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)596 IndexDebugInfoProto::IndexDebugInfoProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
597 bool is_message_owned)
598 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
599 SharedCtor(arena, is_message_owned);
600 // @@protoc_insertion_point(arena_constructor:icing.lib.IndexDebugInfoProto)
601 }
IndexDebugInfoProto(const IndexDebugInfoProto & from)602 IndexDebugInfoProto::IndexDebugInfoProto(const IndexDebugInfoProto& from)
603 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
604 IndexDebugInfoProto* const _this = this; (void)_this;
605 new (&_impl_) Impl_{
606 decltype(_impl_._has_bits_){from._impl_._has_bits_}
607 , /*decltype(_impl_._cached_size_)*/{}
608 , decltype(_impl_.main_index_info_){}
609 , decltype(_impl_.lite_index_info_){}
610 , decltype(_impl_.index_storage_info_){nullptr}};
611
612 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
613 _impl_.main_index_info_.InitDefault();
614 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
615 _impl_.main_index_info_.Set("", GetArenaForAllocation());
616 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
617 if (from._internal_has_main_index_info()) {
618 _this->_impl_.main_index_info_.Set(from._internal_main_index_info(),
619 _this->GetArenaForAllocation());
620 }
621 _impl_.lite_index_info_.InitDefault();
622 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
623 _impl_.lite_index_info_.Set("", GetArenaForAllocation());
624 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
625 if (from._internal_has_lite_index_info()) {
626 _this->_impl_.lite_index_info_.Set(from._internal_lite_index_info(),
627 _this->GetArenaForAllocation());
628 }
629 if (from._internal_has_index_storage_info()) {
630 _this->_impl_.index_storage_info_ = new ::icing::lib::IndexStorageInfoProto(*from._impl_.index_storage_info_);
631 }
632 // @@protoc_insertion_point(copy_constructor:icing.lib.IndexDebugInfoProto)
633 }
634
SharedCtor(::_pb::Arena * arena,bool is_message_owned)635 inline void IndexDebugInfoProto::SharedCtor(
636 ::_pb::Arena* arena, bool is_message_owned) {
637 (void)arena;
638 (void)is_message_owned;
639 new (&_impl_) Impl_{
640 decltype(_impl_._has_bits_){}
641 , /*decltype(_impl_._cached_size_)*/{}
642 , decltype(_impl_.main_index_info_){}
643 , decltype(_impl_.lite_index_info_){}
644 , decltype(_impl_.index_storage_info_){nullptr}
645 };
646 _impl_.main_index_info_.InitDefault();
647 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
648 _impl_.main_index_info_.Set("", GetArenaForAllocation());
649 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
650 _impl_.lite_index_info_.InitDefault();
651 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
652 _impl_.lite_index_info_.Set("", GetArenaForAllocation());
653 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
654 }
655
~IndexDebugInfoProto()656 IndexDebugInfoProto::~IndexDebugInfoProto() {
657 // @@protoc_insertion_point(destructor:icing.lib.IndexDebugInfoProto)
658 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
659 (void)arena;
660 return;
661 }
662 SharedDtor();
663 }
664
SharedDtor()665 inline void IndexDebugInfoProto::SharedDtor() {
666 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
667 _impl_.main_index_info_.Destroy();
668 _impl_.lite_index_info_.Destroy();
669 if (this != internal_default_instance()) delete _impl_.index_storage_info_;
670 }
671
SetCachedSize(int size) const672 void IndexDebugInfoProto::SetCachedSize(int size) const {
673 _impl_._cached_size_.Set(size);
674 }
675
Clear()676 void IndexDebugInfoProto::Clear() {
677 // @@protoc_insertion_point(message_clear_start:icing.lib.IndexDebugInfoProto)
678 ::uint32_t cached_has_bits = 0;
679 // Prevent compiler warnings about cached_has_bits being unused
680 (void) cached_has_bits;
681
682 cached_has_bits = _impl_._has_bits_[0];
683 if (cached_has_bits & 0x00000007u) {
684 if (cached_has_bits & 0x00000001u) {
685 _impl_.main_index_info_.ClearNonDefaultToEmpty();
686 }
687 if (cached_has_bits & 0x00000002u) {
688 _impl_.lite_index_info_.ClearNonDefaultToEmpty();
689 }
690 if (cached_has_bits & 0x00000004u) {
691 GOOGLE_DCHECK(_impl_.index_storage_info_ != nullptr);
692 _impl_.index_storage_info_->Clear();
693 }
694 }
695 _impl_._has_bits_.Clear();
696 _internal_metadata_.Clear<std::string>();
697 }
698
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)699 const char* IndexDebugInfoProto::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
700 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
701 _Internal::HasBits has_bits{};
702 while (!ctx->Done(&ptr)) {
703 ::uint32_t tag;
704 ptr = ::_pbi::ReadTag(ptr, &tag);
705 switch (tag >> 3) {
706 // optional .icing.lib.IndexStorageInfoProto index_storage_info = 1;
707 case 1:
708 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
709 ptr = ctx->ParseMessage(_internal_mutable_index_storage_info(), ptr);
710 CHK_(ptr);
711 } else {
712 goto handle_unusual;
713 }
714 continue;
715 // optional string main_index_info = 2;
716 case 2:
717 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
718 auto str = _internal_mutable_main_index_info();
719 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
720 CHK_(ptr);
721 } else {
722 goto handle_unusual;
723 }
724 continue;
725 // optional string lite_index_info = 3;
726 case 3:
727 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
728 auto str = _internal_mutable_lite_index_info();
729 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
730 CHK_(ptr);
731 } else {
732 goto handle_unusual;
733 }
734 continue;
735 default:
736 goto handle_unusual;
737 } // switch
738 handle_unusual:
739 if ((tag == 0) || ((tag & 7) == 4)) {
740 CHK_(ptr);
741 ctx->SetLastTag(tag);
742 goto message_done;
743 }
744 ptr = UnknownFieldParse(
745 tag,
746 _internal_metadata_.mutable_unknown_fields<std::string>(),
747 ptr, ctx);
748 CHK_(ptr != nullptr);
749 } // while
750 message_done:
751 _impl_._has_bits_.Or(has_bits);
752 return ptr;
753 failure:
754 ptr = nullptr;
755 goto message_done;
756 #undef CHK_
757 }
758
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const759 ::uint8_t* IndexDebugInfoProto::_InternalSerialize(
760 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
761 // @@protoc_insertion_point(serialize_to_array_start:icing.lib.IndexDebugInfoProto)
762 ::uint32_t cached_has_bits = 0;
763 (void) cached_has_bits;
764
765 cached_has_bits = _impl_._has_bits_[0];
766 // optional .icing.lib.IndexStorageInfoProto index_storage_info = 1;
767 if (cached_has_bits & 0x00000004u) {
768 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
769 InternalWriteMessage(1, _Internal::index_storage_info(this),
770 _Internal::index_storage_info(this).GetCachedSize(), target, stream);
771 }
772
773 // optional string main_index_info = 2;
774 if (cached_has_bits & 0x00000001u) {
775 target = stream->WriteStringMaybeAliased(
776 2, this->_internal_main_index_info(), target);
777 }
778
779 // optional string lite_index_info = 3;
780 if (cached_has_bits & 0x00000002u) {
781 target = stream->WriteStringMaybeAliased(
782 3, this->_internal_lite_index_info(), target);
783 }
784
785 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
786 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
787 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
788 }
789 // @@protoc_insertion_point(serialize_to_array_end:icing.lib.IndexDebugInfoProto)
790 return target;
791 }
792
ByteSizeLong() const793 size_t IndexDebugInfoProto::ByteSizeLong() const {
794 // @@protoc_insertion_point(message_byte_size_start:icing.lib.IndexDebugInfoProto)
795 size_t total_size = 0;
796
797 ::uint32_t cached_has_bits = 0;
798 // Prevent compiler warnings about cached_has_bits being unused
799 (void) cached_has_bits;
800
801 cached_has_bits = _impl_._has_bits_[0];
802 if (cached_has_bits & 0x00000007u) {
803 // optional string main_index_info = 2;
804 if (cached_has_bits & 0x00000001u) {
805 total_size += 1 +
806 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
807 this->_internal_main_index_info());
808 }
809
810 // optional string lite_index_info = 3;
811 if (cached_has_bits & 0x00000002u) {
812 total_size += 1 +
813 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
814 this->_internal_lite_index_info());
815 }
816
817 // optional .icing.lib.IndexStorageInfoProto index_storage_info = 1;
818 if (cached_has_bits & 0x00000004u) {
819 total_size += 1 +
820 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
821 *_impl_.index_storage_info_);
822 }
823
824 }
825 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
826 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
827 }
828 int cached_size = ::_pbi::ToCachedSize(total_size);
829 SetCachedSize(cached_size);
830 return total_size;
831 }
832
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)833 void IndexDebugInfoProto::CheckTypeAndMergeFrom(
834 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
835 MergeFrom(*::_pbi::DownCast<const IndexDebugInfoProto*>(
836 &from));
837 }
838
MergeFrom(const IndexDebugInfoProto & from)839 void IndexDebugInfoProto::MergeFrom(const IndexDebugInfoProto& from) {
840 IndexDebugInfoProto* const _this = this;
841 // @@protoc_insertion_point(class_specific_merge_from_start:icing.lib.IndexDebugInfoProto)
842 GOOGLE_DCHECK_NE(&from, _this);
843 ::uint32_t cached_has_bits = 0;
844 (void) cached_has_bits;
845
846 cached_has_bits = from._impl_._has_bits_[0];
847 if (cached_has_bits & 0x00000007u) {
848 if (cached_has_bits & 0x00000001u) {
849 _this->_internal_set_main_index_info(from._internal_main_index_info());
850 }
851 if (cached_has_bits & 0x00000002u) {
852 _this->_internal_set_lite_index_info(from._internal_lite_index_info());
853 }
854 if (cached_has_bits & 0x00000004u) {
855 _this->_internal_mutable_index_storage_info()->::icing::lib::IndexStorageInfoProto::MergeFrom(
856 from._internal_index_storage_info());
857 }
858 }
859 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
860 }
861
CopyFrom(const IndexDebugInfoProto & from)862 void IndexDebugInfoProto::CopyFrom(const IndexDebugInfoProto& from) {
863 // @@protoc_insertion_point(class_specific_copy_from_start:icing.lib.IndexDebugInfoProto)
864 if (&from == this) return;
865 Clear();
866 MergeFrom(from);
867 }
868
IsInitialized() const869 bool IndexDebugInfoProto::IsInitialized() const {
870 return true;
871 }
872
InternalSwap(IndexDebugInfoProto * other)873 void IndexDebugInfoProto::InternalSwap(IndexDebugInfoProto* other) {
874 using std::swap;
875 auto* lhs_arena = GetArenaForAllocation();
876 auto* rhs_arena = other->GetArenaForAllocation();
877 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
878 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
879 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
880 &_impl_.main_index_info_, lhs_arena,
881 &other->_impl_.main_index_info_, rhs_arena
882 );
883 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
884 &_impl_.lite_index_info_, lhs_arena,
885 &other->_impl_.lite_index_info_, rhs_arena
886 );
887 swap(_impl_.index_storage_info_, other->_impl_.index_storage_info_);
888 }
889
GetTypeName() const890 std::string IndexDebugInfoProto::GetTypeName() const {
891 return "icing.lib.IndexDebugInfoProto";
892 }
893
894
895 // ===================================================================
896
897 class DocumentDebugInfoProto_CorpusInfo::_Internal {
898 public:
899 using HasBits = decltype(std::declval<DocumentDebugInfoProto_CorpusInfo>()._impl_._has_bits_);
set_has_namespace_(HasBits * has_bits)900 static void set_has_namespace_(HasBits* has_bits) {
901 (*has_bits)[0] |= 1u;
902 }
set_has_schema(HasBits * has_bits)903 static void set_has_schema(HasBits* has_bits) {
904 (*has_bits)[0] |= 2u;
905 }
set_has_total_documents(HasBits * has_bits)906 static void set_has_total_documents(HasBits* has_bits) {
907 (*has_bits)[0] |= 4u;
908 }
set_has_total_token(HasBits * has_bits)909 static void set_has_total_token(HasBits* has_bits) {
910 (*has_bits)[0] |= 8u;
911 }
912 };
913
DocumentDebugInfoProto_CorpusInfo(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)914 DocumentDebugInfoProto_CorpusInfo::DocumentDebugInfoProto_CorpusInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
915 bool is_message_owned)
916 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
917 SharedCtor(arena, is_message_owned);
918 // @@protoc_insertion_point(arena_constructor:icing.lib.DocumentDebugInfoProto.CorpusInfo)
919 }
DocumentDebugInfoProto_CorpusInfo(const DocumentDebugInfoProto_CorpusInfo & from)920 DocumentDebugInfoProto_CorpusInfo::DocumentDebugInfoProto_CorpusInfo(const DocumentDebugInfoProto_CorpusInfo& from)
921 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
922 DocumentDebugInfoProto_CorpusInfo* const _this = this; (void)_this;
923 new (&_impl_) Impl_{
924 decltype(_impl_._has_bits_){from._impl_._has_bits_}
925 , /*decltype(_impl_._cached_size_)*/{}
926 , decltype(_impl_.namespace__){}
927 , decltype(_impl_.schema_){}
928 , decltype(_impl_.total_documents_){}
929 , decltype(_impl_.total_token_){}};
930
931 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
932 _impl_.namespace__.InitDefault();
933 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
934 _impl_.namespace__.Set("", GetArenaForAllocation());
935 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
936 if (from._internal_has_namespace_()) {
937 _this->_impl_.namespace__.Set(from._internal_namespace_(),
938 _this->GetArenaForAllocation());
939 }
940 _impl_.schema_.InitDefault();
941 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
942 _impl_.schema_.Set("", GetArenaForAllocation());
943 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
944 if (from._internal_has_schema()) {
945 _this->_impl_.schema_.Set(from._internal_schema(),
946 _this->GetArenaForAllocation());
947 }
948 ::memcpy(&_impl_.total_documents_, &from._impl_.total_documents_,
949 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.total_token_) -
950 reinterpret_cast<char*>(&_impl_.total_documents_)) + sizeof(_impl_.total_token_));
951 // @@protoc_insertion_point(copy_constructor:icing.lib.DocumentDebugInfoProto.CorpusInfo)
952 }
953
SharedCtor(::_pb::Arena * arena,bool is_message_owned)954 inline void DocumentDebugInfoProto_CorpusInfo::SharedCtor(
955 ::_pb::Arena* arena, bool is_message_owned) {
956 (void)arena;
957 (void)is_message_owned;
958 new (&_impl_) Impl_{
959 decltype(_impl_._has_bits_){}
960 , /*decltype(_impl_._cached_size_)*/{}
961 , decltype(_impl_.namespace__){}
962 , decltype(_impl_.schema_){}
963 , decltype(_impl_.total_documents_){0u}
964 , decltype(_impl_.total_token_){0u}
965 };
966 _impl_.namespace__.InitDefault();
967 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
968 _impl_.namespace__.Set("", GetArenaForAllocation());
969 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
970 _impl_.schema_.InitDefault();
971 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
972 _impl_.schema_.Set("", GetArenaForAllocation());
973 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
974 }
975
~DocumentDebugInfoProto_CorpusInfo()976 DocumentDebugInfoProto_CorpusInfo::~DocumentDebugInfoProto_CorpusInfo() {
977 // @@protoc_insertion_point(destructor:icing.lib.DocumentDebugInfoProto.CorpusInfo)
978 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
979 (void)arena;
980 return;
981 }
982 SharedDtor();
983 }
984
SharedDtor()985 inline void DocumentDebugInfoProto_CorpusInfo::SharedDtor() {
986 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
987 _impl_.namespace__.Destroy();
988 _impl_.schema_.Destroy();
989 }
990
SetCachedSize(int size) const991 void DocumentDebugInfoProto_CorpusInfo::SetCachedSize(int size) const {
992 _impl_._cached_size_.Set(size);
993 }
994
Clear()995 void DocumentDebugInfoProto_CorpusInfo::Clear() {
996 // @@protoc_insertion_point(message_clear_start:icing.lib.DocumentDebugInfoProto.CorpusInfo)
997 ::uint32_t cached_has_bits = 0;
998 // Prevent compiler warnings about cached_has_bits being unused
999 (void) cached_has_bits;
1000
1001 cached_has_bits = _impl_._has_bits_[0];
1002 if (cached_has_bits & 0x00000003u) {
1003 if (cached_has_bits & 0x00000001u) {
1004 _impl_.namespace__.ClearNonDefaultToEmpty();
1005 }
1006 if (cached_has_bits & 0x00000002u) {
1007 _impl_.schema_.ClearNonDefaultToEmpty();
1008 }
1009 }
1010 if (cached_has_bits & 0x0000000cu) {
1011 ::memset(&_impl_.total_documents_, 0, static_cast<size_t>(
1012 reinterpret_cast<char*>(&_impl_.total_token_) -
1013 reinterpret_cast<char*>(&_impl_.total_documents_)) + sizeof(_impl_.total_token_));
1014 }
1015 _impl_._has_bits_.Clear();
1016 _internal_metadata_.Clear<std::string>();
1017 }
1018
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1019 const char* DocumentDebugInfoProto_CorpusInfo::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1020 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1021 _Internal::HasBits has_bits{};
1022 while (!ctx->Done(&ptr)) {
1023 ::uint32_t tag;
1024 ptr = ::_pbi::ReadTag(ptr, &tag);
1025 switch (tag >> 3) {
1026 // optional string namespace = 1;
1027 case 1:
1028 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
1029 auto str = _internal_mutable_namespace_();
1030 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1031 CHK_(ptr);
1032 } else {
1033 goto handle_unusual;
1034 }
1035 continue;
1036 // optional string schema = 2;
1037 case 2:
1038 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
1039 auto str = _internal_mutable_schema();
1040 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1041 CHK_(ptr);
1042 } else {
1043 goto handle_unusual;
1044 }
1045 continue;
1046 // optional uint32 total_documents = 3;
1047 case 3:
1048 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
1049 _Internal::set_has_total_documents(&has_bits);
1050 _impl_.total_documents_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1051 CHK_(ptr);
1052 } else {
1053 goto handle_unusual;
1054 }
1055 continue;
1056 // optional uint32 total_token = 4;
1057 case 4:
1058 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
1059 _Internal::set_has_total_token(&has_bits);
1060 _impl_.total_token_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1061 CHK_(ptr);
1062 } else {
1063 goto handle_unusual;
1064 }
1065 continue;
1066 default:
1067 goto handle_unusual;
1068 } // switch
1069 handle_unusual:
1070 if ((tag == 0) || ((tag & 7) == 4)) {
1071 CHK_(ptr);
1072 ctx->SetLastTag(tag);
1073 goto message_done;
1074 }
1075 ptr = UnknownFieldParse(
1076 tag,
1077 _internal_metadata_.mutable_unknown_fields<std::string>(),
1078 ptr, ctx);
1079 CHK_(ptr != nullptr);
1080 } // while
1081 message_done:
1082 _impl_._has_bits_.Or(has_bits);
1083 return ptr;
1084 failure:
1085 ptr = nullptr;
1086 goto message_done;
1087 #undef CHK_
1088 }
1089
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1090 ::uint8_t* DocumentDebugInfoProto_CorpusInfo::_InternalSerialize(
1091 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1092 // @@protoc_insertion_point(serialize_to_array_start:icing.lib.DocumentDebugInfoProto.CorpusInfo)
1093 ::uint32_t cached_has_bits = 0;
1094 (void) cached_has_bits;
1095
1096 cached_has_bits = _impl_._has_bits_[0];
1097 // optional string namespace = 1;
1098 if (cached_has_bits & 0x00000001u) {
1099 target = stream->WriteStringMaybeAliased(
1100 1, this->_internal_namespace_(), target);
1101 }
1102
1103 // optional string schema = 2;
1104 if (cached_has_bits & 0x00000002u) {
1105 target = stream->WriteStringMaybeAliased(
1106 2, this->_internal_schema(), target);
1107 }
1108
1109 // optional uint32 total_documents = 3;
1110 if (cached_has_bits & 0x00000004u) {
1111 target = stream->EnsureSpace(target);
1112 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_total_documents(), target);
1113 }
1114
1115 // optional uint32 total_token = 4;
1116 if (cached_has_bits & 0x00000008u) {
1117 target = stream->EnsureSpace(target);
1118 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(4, this->_internal_total_token(), target);
1119 }
1120
1121 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1122 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1123 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1124 }
1125 // @@protoc_insertion_point(serialize_to_array_end:icing.lib.DocumentDebugInfoProto.CorpusInfo)
1126 return target;
1127 }
1128
ByteSizeLong() const1129 size_t DocumentDebugInfoProto_CorpusInfo::ByteSizeLong() const {
1130 // @@protoc_insertion_point(message_byte_size_start:icing.lib.DocumentDebugInfoProto.CorpusInfo)
1131 size_t total_size = 0;
1132
1133 ::uint32_t cached_has_bits = 0;
1134 // Prevent compiler warnings about cached_has_bits being unused
1135 (void) cached_has_bits;
1136
1137 cached_has_bits = _impl_._has_bits_[0];
1138 if (cached_has_bits & 0x0000000fu) {
1139 // optional string namespace = 1;
1140 if (cached_has_bits & 0x00000001u) {
1141 total_size += 1 +
1142 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
1143 this->_internal_namespace_());
1144 }
1145
1146 // optional string schema = 2;
1147 if (cached_has_bits & 0x00000002u) {
1148 total_size += 1 +
1149 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
1150 this->_internal_schema());
1151 }
1152
1153 // optional uint32 total_documents = 3;
1154 if (cached_has_bits & 0x00000004u) {
1155 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_total_documents());
1156 }
1157
1158 // optional uint32 total_token = 4;
1159 if (cached_has_bits & 0x00000008u) {
1160 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_total_token());
1161 }
1162
1163 }
1164 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1165 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1166 }
1167 int cached_size = ::_pbi::ToCachedSize(total_size);
1168 SetCachedSize(cached_size);
1169 return total_size;
1170 }
1171
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1172 void DocumentDebugInfoProto_CorpusInfo::CheckTypeAndMergeFrom(
1173 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1174 MergeFrom(*::_pbi::DownCast<const DocumentDebugInfoProto_CorpusInfo*>(
1175 &from));
1176 }
1177
MergeFrom(const DocumentDebugInfoProto_CorpusInfo & from)1178 void DocumentDebugInfoProto_CorpusInfo::MergeFrom(const DocumentDebugInfoProto_CorpusInfo& from) {
1179 DocumentDebugInfoProto_CorpusInfo* const _this = this;
1180 // @@protoc_insertion_point(class_specific_merge_from_start:icing.lib.DocumentDebugInfoProto.CorpusInfo)
1181 GOOGLE_DCHECK_NE(&from, _this);
1182 ::uint32_t cached_has_bits = 0;
1183 (void) cached_has_bits;
1184
1185 cached_has_bits = from._impl_._has_bits_[0];
1186 if (cached_has_bits & 0x0000000fu) {
1187 if (cached_has_bits & 0x00000001u) {
1188 _this->_internal_set_namespace_(from._internal_namespace_());
1189 }
1190 if (cached_has_bits & 0x00000002u) {
1191 _this->_internal_set_schema(from._internal_schema());
1192 }
1193 if (cached_has_bits & 0x00000004u) {
1194 _this->_impl_.total_documents_ = from._impl_.total_documents_;
1195 }
1196 if (cached_has_bits & 0x00000008u) {
1197 _this->_impl_.total_token_ = from._impl_.total_token_;
1198 }
1199 _this->_impl_._has_bits_[0] |= cached_has_bits;
1200 }
1201 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1202 }
1203
CopyFrom(const DocumentDebugInfoProto_CorpusInfo & from)1204 void DocumentDebugInfoProto_CorpusInfo::CopyFrom(const DocumentDebugInfoProto_CorpusInfo& from) {
1205 // @@protoc_insertion_point(class_specific_copy_from_start:icing.lib.DocumentDebugInfoProto.CorpusInfo)
1206 if (&from == this) return;
1207 Clear();
1208 MergeFrom(from);
1209 }
1210
IsInitialized() const1211 bool DocumentDebugInfoProto_CorpusInfo::IsInitialized() const {
1212 return true;
1213 }
1214
InternalSwap(DocumentDebugInfoProto_CorpusInfo * other)1215 void DocumentDebugInfoProto_CorpusInfo::InternalSwap(DocumentDebugInfoProto_CorpusInfo* other) {
1216 using std::swap;
1217 auto* lhs_arena = GetArenaForAllocation();
1218 auto* rhs_arena = other->GetArenaForAllocation();
1219 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1220 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
1221 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1222 &_impl_.namespace__, lhs_arena,
1223 &other->_impl_.namespace__, rhs_arena
1224 );
1225 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1226 &_impl_.schema_, lhs_arena,
1227 &other->_impl_.schema_, rhs_arena
1228 );
1229 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
1230 PROTOBUF_FIELD_OFFSET(DocumentDebugInfoProto_CorpusInfo, _impl_.total_token_)
1231 + sizeof(DocumentDebugInfoProto_CorpusInfo::_impl_.total_token_) // NOLINT
1232 - PROTOBUF_FIELD_OFFSET(DocumentDebugInfoProto_CorpusInfo, _impl_.total_documents_)>(
1233 reinterpret_cast<char*>(&_impl_.total_documents_),
1234 reinterpret_cast<char*>(&other->_impl_.total_documents_));
1235 }
1236
GetTypeName() const1237 std::string DocumentDebugInfoProto_CorpusInfo::GetTypeName() const {
1238 return "icing.lib.DocumentDebugInfoProto.CorpusInfo";
1239 }
1240
1241
1242 // ===================================================================
1243
1244 class DocumentDebugInfoProto::_Internal {
1245 public:
1246 using HasBits = decltype(std::declval<DocumentDebugInfoProto>()._impl_._has_bits_);
1247 static const ::icing::lib::DocumentStorageInfoProto& document_storage_info(const DocumentDebugInfoProto* msg);
set_has_document_storage_info(HasBits * has_bits)1248 static void set_has_document_storage_info(HasBits* has_bits) {
1249 (*has_bits)[0] |= 1u;
1250 }
set_has_crc(HasBits * has_bits)1251 static void set_has_crc(HasBits* has_bits) {
1252 (*has_bits)[0] |= 2u;
1253 }
1254 };
1255
1256 const ::icing::lib::DocumentStorageInfoProto&
document_storage_info(const DocumentDebugInfoProto * msg)1257 DocumentDebugInfoProto::_Internal::document_storage_info(const DocumentDebugInfoProto* msg) {
1258 return *msg->_impl_.document_storage_info_;
1259 }
clear_document_storage_info()1260 void DocumentDebugInfoProto::clear_document_storage_info() {
1261 if (_impl_.document_storage_info_ != nullptr) _impl_.document_storage_info_->Clear();
1262 _impl_._has_bits_[0] &= ~0x00000001u;
1263 }
DocumentDebugInfoProto(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1264 DocumentDebugInfoProto::DocumentDebugInfoProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1265 bool is_message_owned)
1266 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1267 SharedCtor(arena, is_message_owned);
1268 // @@protoc_insertion_point(arena_constructor:icing.lib.DocumentDebugInfoProto)
1269 }
DocumentDebugInfoProto(const DocumentDebugInfoProto & from)1270 DocumentDebugInfoProto::DocumentDebugInfoProto(const DocumentDebugInfoProto& from)
1271 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1272 DocumentDebugInfoProto* const _this = this; (void)_this;
1273 new (&_impl_) Impl_{
1274 decltype(_impl_._has_bits_){from._impl_._has_bits_}
1275 , /*decltype(_impl_._cached_size_)*/{}
1276 , decltype(_impl_.corpus_info_){from._impl_.corpus_info_}
1277 , decltype(_impl_.document_storage_info_){nullptr}
1278 , decltype(_impl_.crc_){}};
1279
1280 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1281 if (from._internal_has_document_storage_info()) {
1282 _this->_impl_.document_storage_info_ = new ::icing::lib::DocumentStorageInfoProto(*from._impl_.document_storage_info_);
1283 }
1284 _this->_impl_.crc_ = from._impl_.crc_;
1285 // @@protoc_insertion_point(copy_constructor:icing.lib.DocumentDebugInfoProto)
1286 }
1287
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1288 inline void DocumentDebugInfoProto::SharedCtor(
1289 ::_pb::Arena* arena, bool is_message_owned) {
1290 (void)arena;
1291 (void)is_message_owned;
1292 new (&_impl_) Impl_{
1293 decltype(_impl_._has_bits_){}
1294 , /*decltype(_impl_._cached_size_)*/{}
1295 , decltype(_impl_.corpus_info_){arena}
1296 , decltype(_impl_.document_storage_info_){nullptr}
1297 , decltype(_impl_.crc_){0u}
1298 };
1299 }
1300
~DocumentDebugInfoProto()1301 DocumentDebugInfoProto::~DocumentDebugInfoProto() {
1302 // @@protoc_insertion_point(destructor:icing.lib.DocumentDebugInfoProto)
1303 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1304 (void)arena;
1305 return;
1306 }
1307 SharedDtor();
1308 }
1309
SharedDtor()1310 inline void DocumentDebugInfoProto::SharedDtor() {
1311 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1312 _impl_.corpus_info_.~RepeatedPtrField();
1313 if (this != internal_default_instance()) delete _impl_.document_storage_info_;
1314 }
1315
SetCachedSize(int size) const1316 void DocumentDebugInfoProto::SetCachedSize(int size) const {
1317 _impl_._cached_size_.Set(size);
1318 }
1319
Clear()1320 void DocumentDebugInfoProto::Clear() {
1321 // @@protoc_insertion_point(message_clear_start:icing.lib.DocumentDebugInfoProto)
1322 ::uint32_t cached_has_bits = 0;
1323 // Prevent compiler warnings about cached_has_bits being unused
1324 (void) cached_has_bits;
1325
1326 _impl_.corpus_info_.Clear();
1327 cached_has_bits = _impl_._has_bits_[0];
1328 if (cached_has_bits & 0x00000001u) {
1329 GOOGLE_DCHECK(_impl_.document_storage_info_ != nullptr);
1330 _impl_.document_storage_info_->Clear();
1331 }
1332 _impl_.crc_ = 0u;
1333 _impl_._has_bits_.Clear();
1334 _internal_metadata_.Clear<std::string>();
1335 }
1336
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1337 const char* DocumentDebugInfoProto::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1338 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1339 _Internal::HasBits has_bits{};
1340 while (!ctx->Done(&ptr)) {
1341 ::uint32_t tag;
1342 ptr = ::_pbi::ReadTag(ptr, &tag);
1343 switch (tag >> 3) {
1344 // optional .icing.lib.DocumentStorageInfoProto document_storage_info = 1;
1345 case 1:
1346 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
1347 ptr = ctx->ParseMessage(_internal_mutable_document_storage_info(), ptr);
1348 CHK_(ptr);
1349 } else {
1350 goto handle_unusual;
1351 }
1352 continue;
1353 // optional uint32 crc = 2;
1354 case 2:
1355 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
1356 _Internal::set_has_crc(&has_bits);
1357 _impl_.crc_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1358 CHK_(ptr);
1359 } else {
1360 goto handle_unusual;
1361 }
1362 continue;
1363 // repeated .icing.lib.DocumentDebugInfoProto.CorpusInfo corpus_info = 3;
1364 case 3:
1365 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
1366 ptr -= 1;
1367 do {
1368 ptr += 1;
1369 ptr = ctx->ParseMessage(_internal_add_corpus_info(), ptr);
1370 CHK_(ptr);
1371 if (!ctx->DataAvailable(ptr)) break;
1372 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
1373 } else {
1374 goto handle_unusual;
1375 }
1376 continue;
1377 default:
1378 goto handle_unusual;
1379 } // switch
1380 handle_unusual:
1381 if ((tag == 0) || ((tag & 7) == 4)) {
1382 CHK_(ptr);
1383 ctx->SetLastTag(tag);
1384 goto message_done;
1385 }
1386 ptr = UnknownFieldParse(
1387 tag,
1388 _internal_metadata_.mutable_unknown_fields<std::string>(),
1389 ptr, ctx);
1390 CHK_(ptr != nullptr);
1391 } // while
1392 message_done:
1393 _impl_._has_bits_.Or(has_bits);
1394 return ptr;
1395 failure:
1396 ptr = nullptr;
1397 goto message_done;
1398 #undef CHK_
1399 }
1400
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1401 ::uint8_t* DocumentDebugInfoProto::_InternalSerialize(
1402 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1403 // @@protoc_insertion_point(serialize_to_array_start:icing.lib.DocumentDebugInfoProto)
1404 ::uint32_t cached_has_bits = 0;
1405 (void) cached_has_bits;
1406
1407 cached_has_bits = _impl_._has_bits_[0];
1408 // optional .icing.lib.DocumentStorageInfoProto document_storage_info = 1;
1409 if (cached_has_bits & 0x00000001u) {
1410 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
1411 InternalWriteMessage(1, _Internal::document_storage_info(this),
1412 _Internal::document_storage_info(this).GetCachedSize(), target, stream);
1413 }
1414
1415 // optional uint32 crc = 2;
1416 if (cached_has_bits & 0x00000002u) {
1417 target = stream->EnsureSpace(target);
1418 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_crc(), target);
1419 }
1420
1421 // repeated .icing.lib.DocumentDebugInfoProto.CorpusInfo corpus_info = 3;
1422 for (unsigned i = 0,
1423 n = static_cast<unsigned>(this->_internal_corpus_info_size()); i < n; i++) {
1424 const auto& repfield = this->_internal_corpus_info(i);
1425 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
1426 InternalWriteMessage(3, repfield, repfield.GetCachedSize(), target, stream);
1427 }
1428
1429 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1430 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1431 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1432 }
1433 // @@protoc_insertion_point(serialize_to_array_end:icing.lib.DocumentDebugInfoProto)
1434 return target;
1435 }
1436
ByteSizeLong() const1437 size_t DocumentDebugInfoProto::ByteSizeLong() const {
1438 // @@protoc_insertion_point(message_byte_size_start:icing.lib.DocumentDebugInfoProto)
1439 size_t total_size = 0;
1440
1441 ::uint32_t cached_has_bits = 0;
1442 // Prevent compiler warnings about cached_has_bits being unused
1443 (void) cached_has_bits;
1444
1445 // repeated .icing.lib.DocumentDebugInfoProto.CorpusInfo corpus_info = 3;
1446 total_size += 1UL * this->_internal_corpus_info_size();
1447 for (const auto& msg : this->_impl_.corpus_info_) {
1448 total_size +=
1449 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
1450 }
1451
1452 cached_has_bits = _impl_._has_bits_[0];
1453 if (cached_has_bits & 0x00000003u) {
1454 // optional .icing.lib.DocumentStorageInfoProto document_storage_info = 1;
1455 if (cached_has_bits & 0x00000001u) {
1456 total_size += 1 +
1457 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
1458 *_impl_.document_storage_info_);
1459 }
1460
1461 // optional uint32 crc = 2;
1462 if (cached_has_bits & 0x00000002u) {
1463 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_crc());
1464 }
1465
1466 }
1467 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1468 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1469 }
1470 int cached_size = ::_pbi::ToCachedSize(total_size);
1471 SetCachedSize(cached_size);
1472 return total_size;
1473 }
1474
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1475 void DocumentDebugInfoProto::CheckTypeAndMergeFrom(
1476 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1477 MergeFrom(*::_pbi::DownCast<const DocumentDebugInfoProto*>(
1478 &from));
1479 }
1480
MergeFrom(const DocumentDebugInfoProto & from)1481 void DocumentDebugInfoProto::MergeFrom(const DocumentDebugInfoProto& from) {
1482 DocumentDebugInfoProto* const _this = this;
1483 // @@protoc_insertion_point(class_specific_merge_from_start:icing.lib.DocumentDebugInfoProto)
1484 GOOGLE_DCHECK_NE(&from, _this);
1485 ::uint32_t cached_has_bits = 0;
1486 (void) cached_has_bits;
1487
1488 _this->_impl_.corpus_info_.MergeFrom(from._impl_.corpus_info_);
1489 cached_has_bits = from._impl_._has_bits_[0];
1490 if (cached_has_bits & 0x00000003u) {
1491 if (cached_has_bits & 0x00000001u) {
1492 _this->_internal_mutable_document_storage_info()->::icing::lib::DocumentStorageInfoProto::MergeFrom(
1493 from._internal_document_storage_info());
1494 }
1495 if (cached_has_bits & 0x00000002u) {
1496 _this->_impl_.crc_ = from._impl_.crc_;
1497 }
1498 _this->_impl_._has_bits_[0] |= cached_has_bits;
1499 }
1500 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1501 }
1502
CopyFrom(const DocumentDebugInfoProto & from)1503 void DocumentDebugInfoProto::CopyFrom(const DocumentDebugInfoProto& from) {
1504 // @@protoc_insertion_point(class_specific_copy_from_start:icing.lib.DocumentDebugInfoProto)
1505 if (&from == this) return;
1506 Clear();
1507 MergeFrom(from);
1508 }
1509
IsInitialized() const1510 bool DocumentDebugInfoProto::IsInitialized() const {
1511 return true;
1512 }
1513
InternalSwap(DocumentDebugInfoProto * other)1514 void DocumentDebugInfoProto::InternalSwap(DocumentDebugInfoProto* other) {
1515 using std::swap;
1516 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1517 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
1518 _impl_.corpus_info_.InternalSwap(&other->_impl_.corpus_info_);
1519 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
1520 PROTOBUF_FIELD_OFFSET(DocumentDebugInfoProto, _impl_.crc_)
1521 + sizeof(DocumentDebugInfoProto::_impl_.crc_) // NOLINT
1522 - PROTOBUF_FIELD_OFFSET(DocumentDebugInfoProto, _impl_.document_storage_info_)>(
1523 reinterpret_cast<char*>(&_impl_.document_storage_info_),
1524 reinterpret_cast<char*>(&other->_impl_.document_storage_info_));
1525 }
1526
GetTypeName() const1527 std::string DocumentDebugInfoProto::GetTypeName() const {
1528 return "icing.lib.DocumentDebugInfoProto";
1529 }
1530
1531
1532 // ===================================================================
1533
1534 class SchemaDebugInfoProto::_Internal {
1535 public:
1536 using HasBits = decltype(std::declval<SchemaDebugInfoProto>()._impl_._has_bits_);
1537 static const ::icing::lib::SchemaProto& schema(const SchemaDebugInfoProto* msg);
set_has_schema(HasBits * has_bits)1538 static void set_has_schema(HasBits* has_bits) {
1539 (*has_bits)[0] |= 1u;
1540 }
set_has_crc(HasBits * has_bits)1541 static void set_has_crc(HasBits* has_bits) {
1542 (*has_bits)[0] |= 2u;
1543 }
1544 };
1545
1546 const ::icing::lib::SchemaProto&
schema(const SchemaDebugInfoProto * msg)1547 SchemaDebugInfoProto::_Internal::schema(const SchemaDebugInfoProto* msg) {
1548 return *msg->_impl_.schema_;
1549 }
clear_schema()1550 void SchemaDebugInfoProto::clear_schema() {
1551 if (_impl_.schema_ != nullptr) _impl_.schema_->Clear();
1552 _impl_._has_bits_[0] &= ~0x00000001u;
1553 }
SchemaDebugInfoProto(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1554 SchemaDebugInfoProto::SchemaDebugInfoProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1555 bool is_message_owned)
1556 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1557 SharedCtor(arena, is_message_owned);
1558 // @@protoc_insertion_point(arena_constructor:icing.lib.SchemaDebugInfoProto)
1559 }
SchemaDebugInfoProto(const SchemaDebugInfoProto & from)1560 SchemaDebugInfoProto::SchemaDebugInfoProto(const SchemaDebugInfoProto& from)
1561 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1562 SchemaDebugInfoProto* const _this = this; (void)_this;
1563 new (&_impl_) Impl_{
1564 decltype(_impl_._has_bits_){from._impl_._has_bits_}
1565 , /*decltype(_impl_._cached_size_)*/{}
1566 , decltype(_impl_.schema_){nullptr}
1567 , decltype(_impl_.crc_){}};
1568
1569 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1570 if (from._internal_has_schema()) {
1571 _this->_impl_.schema_ = new ::icing::lib::SchemaProto(*from._impl_.schema_);
1572 }
1573 _this->_impl_.crc_ = from._impl_.crc_;
1574 // @@protoc_insertion_point(copy_constructor:icing.lib.SchemaDebugInfoProto)
1575 }
1576
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1577 inline void SchemaDebugInfoProto::SharedCtor(
1578 ::_pb::Arena* arena, bool is_message_owned) {
1579 (void)arena;
1580 (void)is_message_owned;
1581 new (&_impl_) Impl_{
1582 decltype(_impl_._has_bits_){}
1583 , /*decltype(_impl_._cached_size_)*/{}
1584 , decltype(_impl_.schema_){nullptr}
1585 , decltype(_impl_.crc_){0u}
1586 };
1587 }
1588
~SchemaDebugInfoProto()1589 SchemaDebugInfoProto::~SchemaDebugInfoProto() {
1590 // @@protoc_insertion_point(destructor:icing.lib.SchemaDebugInfoProto)
1591 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1592 (void)arena;
1593 return;
1594 }
1595 SharedDtor();
1596 }
1597
SharedDtor()1598 inline void SchemaDebugInfoProto::SharedDtor() {
1599 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1600 if (this != internal_default_instance()) delete _impl_.schema_;
1601 }
1602
SetCachedSize(int size) const1603 void SchemaDebugInfoProto::SetCachedSize(int size) const {
1604 _impl_._cached_size_.Set(size);
1605 }
1606
Clear()1607 void SchemaDebugInfoProto::Clear() {
1608 // @@protoc_insertion_point(message_clear_start:icing.lib.SchemaDebugInfoProto)
1609 ::uint32_t cached_has_bits = 0;
1610 // Prevent compiler warnings about cached_has_bits being unused
1611 (void) cached_has_bits;
1612
1613 cached_has_bits = _impl_._has_bits_[0];
1614 if (cached_has_bits & 0x00000001u) {
1615 GOOGLE_DCHECK(_impl_.schema_ != nullptr);
1616 _impl_.schema_->Clear();
1617 }
1618 _impl_.crc_ = 0u;
1619 _impl_._has_bits_.Clear();
1620 _internal_metadata_.Clear<std::string>();
1621 }
1622
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1623 const char* SchemaDebugInfoProto::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1624 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1625 _Internal::HasBits has_bits{};
1626 while (!ctx->Done(&ptr)) {
1627 ::uint32_t tag;
1628 ptr = ::_pbi::ReadTag(ptr, &tag);
1629 switch (tag >> 3) {
1630 // optional .icing.lib.SchemaProto schema = 1;
1631 case 1:
1632 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
1633 ptr = ctx->ParseMessage(_internal_mutable_schema(), ptr);
1634 CHK_(ptr);
1635 } else {
1636 goto handle_unusual;
1637 }
1638 continue;
1639 // optional uint32 crc = 2;
1640 case 2:
1641 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
1642 _Internal::set_has_crc(&has_bits);
1643 _impl_.crc_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1644 CHK_(ptr);
1645 } else {
1646 goto handle_unusual;
1647 }
1648 continue;
1649 default:
1650 goto handle_unusual;
1651 } // switch
1652 handle_unusual:
1653 if ((tag == 0) || ((tag & 7) == 4)) {
1654 CHK_(ptr);
1655 ctx->SetLastTag(tag);
1656 goto message_done;
1657 }
1658 ptr = UnknownFieldParse(
1659 tag,
1660 _internal_metadata_.mutable_unknown_fields<std::string>(),
1661 ptr, ctx);
1662 CHK_(ptr != nullptr);
1663 } // while
1664 message_done:
1665 _impl_._has_bits_.Or(has_bits);
1666 return ptr;
1667 failure:
1668 ptr = nullptr;
1669 goto message_done;
1670 #undef CHK_
1671 }
1672
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1673 ::uint8_t* SchemaDebugInfoProto::_InternalSerialize(
1674 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1675 // @@protoc_insertion_point(serialize_to_array_start:icing.lib.SchemaDebugInfoProto)
1676 ::uint32_t cached_has_bits = 0;
1677 (void) cached_has_bits;
1678
1679 cached_has_bits = _impl_._has_bits_[0];
1680 // optional .icing.lib.SchemaProto schema = 1;
1681 if (cached_has_bits & 0x00000001u) {
1682 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
1683 InternalWriteMessage(1, _Internal::schema(this),
1684 _Internal::schema(this).GetCachedSize(), target, stream);
1685 }
1686
1687 // optional uint32 crc = 2;
1688 if (cached_has_bits & 0x00000002u) {
1689 target = stream->EnsureSpace(target);
1690 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_crc(), target);
1691 }
1692
1693 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1694 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1695 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1696 }
1697 // @@protoc_insertion_point(serialize_to_array_end:icing.lib.SchemaDebugInfoProto)
1698 return target;
1699 }
1700
ByteSizeLong() const1701 size_t SchemaDebugInfoProto::ByteSizeLong() const {
1702 // @@protoc_insertion_point(message_byte_size_start:icing.lib.SchemaDebugInfoProto)
1703 size_t total_size = 0;
1704
1705 ::uint32_t cached_has_bits = 0;
1706 // Prevent compiler warnings about cached_has_bits being unused
1707 (void) cached_has_bits;
1708
1709 cached_has_bits = _impl_._has_bits_[0];
1710 if (cached_has_bits & 0x00000003u) {
1711 // optional .icing.lib.SchemaProto schema = 1;
1712 if (cached_has_bits & 0x00000001u) {
1713 total_size += 1 +
1714 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
1715 *_impl_.schema_);
1716 }
1717
1718 // optional uint32 crc = 2;
1719 if (cached_has_bits & 0x00000002u) {
1720 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_crc());
1721 }
1722
1723 }
1724 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1725 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1726 }
1727 int cached_size = ::_pbi::ToCachedSize(total_size);
1728 SetCachedSize(cached_size);
1729 return total_size;
1730 }
1731
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1732 void SchemaDebugInfoProto::CheckTypeAndMergeFrom(
1733 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1734 MergeFrom(*::_pbi::DownCast<const SchemaDebugInfoProto*>(
1735 &from));
1736 }
1737
MergeFrom(const SchemaDebugInfoProto & from)1738 void SchemaDebugInfoProto::MergeFrom(const SchemaDebugInfoProto& from) {
1739 SchemaDebugInfoProto* const _this = this;
1740 // @@protoc_insertion_point(class_specific_merge_from_start:icing.lib.SchemaDebugInfoProto)
1741 GOOGLE_DCHECK_NE(&from, _this);
1742 ::uint32_t cached_has_bits = 0;
1743 (void) cached_has_bits;
1744
1745 cached_has_bits = from._impl_._has_bits_[0];
1746 if (cached_has_bits & 0x00000003u) {
1747 if (cached_has_bits & 0x00000001u) {
1748 _this->_internal_mutable_schema()->::icing::lib::SchemaProto::MergeFrom(
1749 from._internal_schema());
1750 }
1751 if (cached_has_bits & 0x00000002u) {
1752 _this->_impl_.crc_ = from._impl_.crc_;
1753 }
1754 _this->_impl_._has_bits_[0] |= cached_has_bits;
1755 }
1756 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1757 }
1758
CopyFrom(const SchemaDebugInfoProto & from)1759 void SchemaDebugInfoProto::CopyFrom(const SchemaDebugInfoProto& from) {
1760 // @@protoc_insertion_point(class_specific_copy_from_start:icing.lib.SchemaDebugInfoProto)
1761 if (&from == this) return;
1762 Clear();
1763 MergeFrom(from);
1764 }
1765
IsInitialized() const1766 bool SchemaDebugInfoProto::IsInitialized() const {
1767 return true;
1768 }
1769
InternalSwap(SchemaDebugInfoProto * other)1770 void SchemaDebugInfoProto::InternalSwap(SchemaDebugInfoProto* other) {
1771 using std::swap;
1772 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1773 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
1774 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
1775 PROTOBUF_FIELD_OFFSET(SchemaDebugInfoProto, _impl_.crc_)
1776 + sizeof(SchemaDebugInfoProto::_impl_.crc_) // NOLINT
1777 - PROTOBUF_FIELD_OFFSET(SchemaDebugInfoProto, _impl_.schema_)>(
1778 reinterpret_cast<char*>(&_impl_.schema_),
1779 reinterpret_cast<char*>(&other->_impl_.schema_));
1780 }
1781
GetTypeName() const1782 std::string SchemaDebugInfoProto::GetTypeName() const {
1783 return "icing.lib.SchemaDebugInfoProto";
1784 }
1785
1786
1787 // ===================================================================
1788
1789 class DebugInfoProto::_Internal {
1790 public:
1791 using HasBits = decltype(std::declval<DebugInfoProto>()._impl_._has_bits_);
1792 static const ::icing::lib::IndexDebugInfoProto& index_info(const DebugInfoProto* msg);
set_has_index_info(HasBits * has_bits)1793 static void set_has_index_info(HasBits* has_bits) {
1794 (*has_bits)[0] |= 1u;
1795 }
1796 static const ::icing::lib::DocumentDebugInfoProto& document_info(const DebugInfoProto* msg);
set_has_document_info(HasBits * has_bits)1797 static void set_has_document_info(HasBits* has_bits) {
1798 (*has_bits)[0] |= 2u;
1799 }
1800 static const ::icing::lib::SchemaDebugInfoProto& schema_info(const DebugInfoProto* msg);
set_has_schema_info(HasBits * has_bits)1801 static void set_has_schema_info(HasBits* has_bits) {
1802 (*has_bits)[0] |= 4u;
1803 }
1804 };
1805
1806 const ::icing::lib::IndexDebugInfoProto&
index_info(const DebugInfoProto * msg)1807 DebugInfoProto::_Internal::index_info(const DebugInfoProto* msg) {
1808 return *msg->_impl_.index_info_;
1809 }
1810 const ::icing::lib::DocumentDebugInfoProto&
document_info(const DebugInfoProto * msg)1811 DebugInfoProto::_Internal::document_info(const DebugInfoProto* msg) {
1812 return *msg->_impl_.document_info_;
1813 }
1814 const ::icing::lib::SchemaDebugInfoProto&
schema_info(const DebugInfoProto * msg)1815 DebugInfoProto::_Internal::schema_info(const DebugInfoProto* msg) {
1816 return *msg->_impl_.schema_info_;
1817 }
DebugInfoProto(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1818 DebugInfoProto::DebugInfoProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1819 bool is_message_owned)
1820 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1821 SharedCtor(arena, is_message_owned);
1822 // @@protoc_insertion_point(arena_constructor:icing.lib.DebugInfoProto)
1823 }
DebugInfoProto(const DebugInfoProto & from)1824 DebugInfoProto::DebugInfoProto(const DebugInfoProto& from)
1825 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1826 DebugInfoProto* const _this = this; (void)_this;
1827 new (&_impl_) Impl_{
1828 decltype(_impl_._has_bits_){from._impl_._has_bits_}
1829 , /*decltype(_impl_._cached_size_)*/{}
1830 , decltype(_impl_.index_info_){nullptr}
1831 , decltype(_impl_.document_info_){nullptr}
1832 , decltype(_impl_.schema_info_){nullptr}};
1833
1834 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1835 if (from._internal_has_index_info()) {
1836 _this->_impl_.index_info_ = new ::icing::lib::IndexDebugInfoProto(*from._impl_.index_info_);
1837 }
1838 if (from._internal_has_document_info()) {
1839 _this->_impl_.document_info_ = new ::icing::lib::DocumentDebugInfoProto(*from._impl_.document_info_);
1840 }
1841 if (from._internal_has_schema_info()) {
1842 _this->_impl_.schema_info_ = new ::icing::lib::SchemaDebugInfoProto(*from._impl_.schema_info_);
1843 }
1844 // @@protoc_insertion_point(copy_constructor:icing.lib.DebugInfoProto)
1845 }
1846
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1847 inline void DebugInfoProto::SharedCtor(
1848 ::_pb::Arena* arena, bool is_message_owned) {
1849 (void)arena;
1850 (void)is_message_owned;
1851 new (&_impl_) Impl_{
1852 decltype(_impl_._has_bits_){}
1853 , /*decltype(_impl_._cached_size_)*/{}
1854 , decltype(_impl_.index_info_){nullptr}
1855 , decltype(_impl_.document_info_){nullptr}
1856 , decltype(_impl_.schema_info_){nullptr}
1857 };
1858 }
1859
~DebugInfoProto()1860 DebugInfoProto::~DebugInfoProto() {
1861 // @@protoc_insertion_point(destructor:icing.lib.DebugInfoProto)
1862 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1863 (void)arena;
1864 return;
1865 }
1866 SharedDtor();
1867 }
1868
SharedDtor()1869 inline void DebugInfoProto::SharedDtor() {
1870 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1871 if (this != internal_default_instance()) delete _impl_.index_info_;
1872 if (this != internal_default_instance()) delete _impl_.document_info_;
1873 if (this != internal_default_instance()) delete _impl_.schema_info_;
1874 }
1875
SetCachedSize(int size) const1876 void DebugInfoProto::SetCachedSize(int size) const {
1877 _impl_._cached_size_.Set(size);
1878 }
1879
Clear()1880 void DebugInfoProto::Clear() {
1881 // @@protoc_insertion_point(message_clear_start:icing.lib.DebugInfoProto)
1882 ::uint32_t cached_has_bits = 0;
1883 // Prevent compiler warnings about cached_has_bits being unused
1884 (void) cached_has_bits;
1885
1886 cached_has_bits = _impl_._has_bits_[0];
1887 if (cached_has_bits & 0x00000007u) {
1888 if (cached_has_bits & 0x00000001u) {
1889 GOOGLE_DCHECK(_impl_.index_info_ != nullptr);
1890 _impl_.index_info_->Clear();
1891 }
1892 if (cached_has_bits & 0x00000002u) {
1893 GOOGLE_DCHECK(_impl_.document_info_ != nullptr);
1894 _impl_.document_info_->Clear();
1895 }
1896 if (cached_has_bits & 0x00000004u) {
1897 GOOGLE_DCHECK(_impl_.schema_info_ != nullptr);
1898 _impl_.schema_info_->Clear();
1899 }
1900 }
1901 _impl_._has_bits_.Clear();
1902 _internal_metadata_.Clear<std::string>();
1903 }
1904
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1905 const char* DebugInfoProto::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1906 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1907 _Internal::HasBits has_bits{};
1908 while (!ctx->Done(&ptr)) {
1909 ::uint32_t tag;
1910 ptr = ::_pbi::ReadTag(ptr, &tag);
1911 switch (tag >> 3) {
1912 // optional .icing.lib.IndexDebugInfoProto index_info = 1;
1913 case 1:
1914 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
1915 ptr = ctx->ParseMessage(_internal_mutable_index_info(), ptr);
1916 CHK_(ptr);
1917 } else {
1918 goto handle_unusual;
1919 }
1920 continue;
1921 // optional .icing.lib.DocumentDebugInfoProto document_info = 2;
1922 case 2:
1923 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
1924 ptr = ctx->ParseMessage(_internal_mutable_document_info(), ptr);
1925 CHK_(ptr);
1926 } else {
1927 goto handle_unusual;
1928 }
1929 continue;
1930 // optional .icing.lib.SchemaDebugInfoProto schema_info = 3;
1931 case 3:
1932 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
1933 ptr = ctx->ParseMessage(_internal_mutable_schema_info(), ptr);
1934 CHK_(ptr);
1935 } else {
1936 goto handle_unusual;
1937 }
1938 continue;
1939 default:
1940 goto handle_unusual;
1941 } // switch
1942 handle_unusual:
1943 if ((tag == 0) || ((tag & 7) == 4)) {
1944 CHK_(ptr);
1945 ctx->SetLastTag(tag);
1946 goto message_done;
1947 }
1948 ptr = UnknownFieldParse(
1949 tag,
1950 _internal_metadata_.mutable_unknown_fields<std::string>(),
1951 ptr, ctx);
1952 CHK_(ptr != nullptr);
1953 } // while
1954 message_done:
1955 _impl_._has_bits_.Or(has_bits);
1956 return ptr;
1957 failure:
1958 ptr = nullptr;
1959 goto message_done;
1960 #undef CHK_
1961 }
1962
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1963 ::uint8_t* DebugInfoProto::_InternalSerialize(
1964 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1965 // @@protoc_insertion_point(serialize_to_array_start:icing.lib.DebugInfoProto)
1966 ::uint32_t cached_has_bits = 0;
1967 (void) cached_has_bits;
1968
1969 cached_has_bits = _impl_._has_bits_[0];
1970 // optional .icing.lib.IndexDebugInfoProto index_info = 1;
1971 if (cached_has_bits & 0x00000001u) {
1972 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
1973 InternalWriteMessage(1, _Internal::index_info(this),
1974 _Internal::index_info(this).GetCachedSize(), target, stream);
1975 }
1976
1977 // optional .icing.lib.DocumentDebugInfoProto document_info = 2;
1978 if (cached_has_bits & 0x00000002u) {
1979 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
1980 InternalWriteMessage(2, _Internal::document_info(this),
1981 _Internal::document_info(this).GetCachedSize(), target, stream);
1982 }
1983
1984 // optional .icing.lib.SchemaDebugInfoProto schema_info = 3;
1985 if (cached_has_bits & 0x00000004u) {
1986 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
1987 InternalWriteMessage(3, _Internal::schema_info(this),
1988 _Internal::schema_info(this).GetCachedSize(), target, stream);
1989 }
1990
1991 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1992 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1993 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1994 }
1995 // @@protoc_insertion_point(serialize_to_array_end:icing.lib.DebugInfoProto)
1996 return target;
1997 }
1998
ByteSizeLong() const1999 size_t DebugInfoProto::ByteSizeLong() const {
2000 // @@protoc_insertion_point(message_byte_size_start:icing.lib.DebugInfoProto)
2001 size_t total_size = 0;
2002
2003 ::uint32_t cached_has_bits = 0;
2004 // Prevent compiler warnings about cached_has_bits being unused
2005 (void) cached_has_bits;
2006
2007 cached_has_bits = _impl_._has_bits_[0];
2008 if (cached_has_bits & 0x00000007u) {
2009 // optional .icing.lib.IndexDebugInfoProto index_info = 1;
2010 if (cached_has_bits & 0x00000001u) {
2011 total_size += 1 +
2012 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
2013 *_impl_.index_info_);
2014 }
2015
2016 // optional .icing.lib.DocumentDebugInfoProto document_info = 2;
2017 if (cached_has_bits & 0x00000002u) {
2018 total_size += 1 +
2019 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
2020 *_impl_.document_info_);
2021 }
2022
2023 // optional .icing.lib.SchemaDebugInfoProto schema_info = 3;
2024 if (cached_has_bits & 0x00000004u) {
2025 total_size += 1 +
2026 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
2027 *_impl_.schema_info_);
2028 }
2029
2030 }
2031 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2032 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
2033 }
2034 int cached_size = ::_pbi::ToCachedSize(total_size);
2035 SetCachedSize(cached_size);
2036 return total_size;
2037 }
2038
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)2039 void DebugInfoProto::CheckTypeAndMergeFrom(
2040 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
2041 MergeFrom(*::_pbi::DownCast<const DebugInfoProto*>(
2042 &from));
2043 }
2044
MergeFrom(const DebugInfoProto & from)2045 void DebugInfoProto::MergeFrom(const DebugInfoProto& from) {
2046 DebugInfoProto* const _this = this;
2047 // @@protoc_insertion_point(class_specific_merge_from_start:icing.lib.DebugInfoProto)
2048 GOOGLE_DCHECK_NE(&from, _this);
2049 ::uint32_t cached_has_bits = 0;
2050 (void) cached_has_bits;
2051
2052 cached_has_bits = from._impl_._has_bits_[0];
2053 if (cached_has_bits & 0x00000007u) {
2054 if (cached_has_bits & 0x00000001u) {
2055 _this->_internal_mutable_index_info()->::icing::lib::IndexDebugInfoProto::MergeFrom(
2056 from._internal_index_info());
2057 }
2058 if (cached_has_bits & 0x00000002u) {
2059 _this->_internal_mutable_document_info()->::icing::lib::DocumentDebugInfoProto::MergeFrom(
2060 from._internal_document_info());
2061 }
2062 if (cached_has_bits & 0x00000004u) {
2063 _this->_internal_mutable_schema_info()->::icing::lib::SchemaDebugInfoProto::MergeFrom(
2064 from._internal_schema_info());
2065 }
2066 }
2067 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2068 }
2069
CopyFrom(const DebugInfoProto & from)2070 void DebugInfoProto::CopyFrom(const DebugInfoProto& from) {
2071 // @@protoc_insertion_point(class_specific_copy_from_start:icing.lib.DebugInfoProto)
2072 if (&from == this) return;
2073 Clear();
2074 MergeFrom(from);
2075 }
2076
IsInitialized() const2077 bool DebugInfoProto::IsInitialized() const {
2078 return true;
2079 }
2080
InternalSwap(DebugInfoProto * other)2081 void DebugInfoProto::InternalSwap(DebugInfoProto* other) {
2082 using std::swap;
2083 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2084 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
2085 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
2086 PROTOBUF_FIELD_OFFSET(DebugInfoProto, _impl_.schema_info_)
2087 + sizeof(DebugInfoProto::_impl_.schema_info_) // NOLINT
2088 - PROTOBUF_FIELD_OFFSET(DebugInfoProto, _impl_.index_info_)>(
2089 reinterpret_cast<char*>(&_impl_.index_info_),
2090 reinterpret_cast<char*>(&other->_impl_.index_info_));
2091 }
2092
GetTypeName() const2093 std::string DebugInfoProto::GetTypeName() const {
2094 return "icing.lib.DebugInfoProto";
2095 }
2096
2097
2098 // ===================================================================
2099
2100 class DebugInfoResultProto::_Internal {
2101 public:
2102 using HasBits = decltype(std::declval<DebugInfoResultProto>()._impl_._has_bits_);
2103 static const ::icing::lib::StatusProto& status(const DebugInfoResultProto* msg);
set_has_status(HasBits * has_bits)2104 static void set_has_status(HasBits* has_bits) {
2105 (*has_bits)[0] |= 1u;
2106 }
2107 static const ::icing::lib::DebugInfoProto& debug_info(const DebugInfoResultProto* msg);
set_has_debug_info(HasBits * has_bits)2108 static void set_has_debug_info(HasBits* has_bits) {
2109 (*has_bits)[0] |= 2u;
2110 }
2111 };
2112
2113 const ::icing::lib::StatusProto&
status(const DebugInfoResultProto * msg)2114 DebugInfoResultProto::_Internal::status(const DebugInfoResultProto* msg) {
2115 return *msg->_impl_.status_;
2116 }
2117 const ::icing::lib::DebugInfoProto&
debug_info(const DebugInfoResultProto * msg)2118 DebugInfoResultProto::_Internal::debug_info(const DebugInfoResultProto* msg) {
2119 return *msg->_impl_.debug_info_;
2120 }
clear_status()2121 void DebugInfoResultProto::clear_status() {
2122 if (_impl_.status_ != nullptr) _impl_.status_->Clear();
2123 _impl_._has_bits_[0] &= ~0x00000001u;
2124 }
DebugInfoResultProto(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)2125 DebugInfoResultProto::DebugInfoResultProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2126 bool is_message_owned)
2127 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
2128 SharedCtor(arena, is_message_owned);
2129 // @@protoc_insertion_point(arena_constructor:icing.lib.DebugInfoResultProto)
2130 }
DebugInfoResultProto(const DebugInfoResultProto & from)2131 DebugInfoResultProto::DebugInfoResultProto(const DebugInfoResultProto& from)
2132 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
2133 DebugInfoResultProto* const _this = this; (void)_this;
2134 new (&_impl_) Impl_{
2135 decltype(_impl_._has_bits_){from._impl_._has_bits_}
2136 , /*decltype(_impl_._cached_size_)*/{}
2137 , decltype(_impl_.status_){nullptr}
2138 , decltype(_impl_.debug_info_){nullptr}};
2139
2140 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2141 if (from._internal_has_status()) {
2142 _this->_impl_.status_ = new ::icing::lib::StatusProto(*from._impl_.status_);
2143 }
2144 if (from._internal_has_debug_info()) {
2145 _this->_impl_.debug_info_ = new ::icing::lib::DebugInfoProto(*from._impl_.debug_info_);
2146 }
2147 // @@protoc_insertion_point(copy_constructor:icing.lib.DebugInfoResultProto)
2148 }
2149
SharedCtor(::_pb::Arena * arena,bool is_message_owned)2150 inline void DebugInfoResultProto::SharedCtor(
2151 ::_pb::Arena* arena, bool is_message_owned) {
2152 (void)arena;
2153 (void)is_message_owned;
2154 new (&_impl_) Impl_{
2155 decltype(_impl_._has_bits_){}
2156 , /*decltype(_impl_._cached_size_)*/{}
2157 , decltype(_impl_.status_){nullptr}
2158 , decltype(_impl_.debug_info_){nullptr}
2159 };
2160 }
2161
~DebugInfoResultProto()2162 DebugInfoResultProto::~DebugInfoResultProto() {
2163 // @@protoc_insertion_point(destructor:icing.lib.DebugInfoResultProto)
2164 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
2165 (void)arena;
2166 return;
2167 }
2168 SharedDtor();
2169 }
2170
SharedDtor()2171 inline void DebugInfoResultProto::SharedDtor() {
2172 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
2173 if (this != internal_default_instance()) delete _impl_.status_;
2174 if (this != internal_default_instance()) delete _impl_.debug_info_;
2175 }
2176
SetCachedSize(int size) const2177 void DebugInfoResultProto::SetCachedSize(int size) const {
2178 _impl_._cached_size_.Set(size);
2179 }
2180
Clear()2181 void DebugInfoResultProto::Clear() {
2182 // @@protoc_insertion_point(message_clear_start:icing.lib.DebugInfoResultProto)
2183 ::uint32_t cached_has_bits = 0;
2184 // Prevent compiler warnings about cached_has_bits being unused
2185 (void) cached_has_bits;
2186
2187 cached_has_bits = _impl_._has_bits_[0];
2188 if (cached_has_bits & 0x00000003u) {
2189 if (cached_has_bits & 0x00000001u) {
2190 GOOGLE_DCHECK(_impl_.status_ != nullptr);
2191 _impl_.status_->Clear();
2192 }
2193 if (cached_has_bits & 0x00000002u) {
2194 GOOGLE_DCHECK(_impl_.debug_info_ != nullptr);
2195 _impl_.debug_info_->Clear();
2196 }
2197 }
2198 _impl_._has_bits_.Clear();
2199 _internal_metadata_.Clear<std::string>();
2200 }
2201
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)2202 const char* DebugInfoResultProto::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
2203 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
2204 _Internal::HasBits has_bits{};
2205 while (!ctx->Done(&ptr)) {
2206 ::uint32_t tag;
2207 ptr = ::_pbi::ReadTag(ptr, &tag);
2208 switch (tag >> 3) {
2209 // optional .icing.lib.StatusProto status = 1;
2210 case 1:
2211 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
2212 ptr = ctx->ParseMessage(_internal_mutable_status(), ptr);
2213 CHK_(ptr);
2214 } else {
2215 goto handle_unusual;
2216 }
2217 continue;
2218 // optional .icing.lib.DebugInfoProto debug_info = 2;
2219 case 2:
2220 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
2221 ptr = ctx->ParseMessage(_internal_mutable_debug_info(), ptr);
2222 CHK_(ptr);
2223 } else {
2224 goto handle_unusual;
2225 }
2226 continue;
2227 default:
2228 goto handle_unusual;
2229 } // switch
2230 handle_unusual:
2231 if ((tag == 0) || ((tag & 7) == 4)) {
2232 CHK_(ptr);
2233 ctx->SetLastTag(tag);
2234 goto message_done;
2235 }
2236 ptr = UnknownFieldParse(
2237 tag,
2238 _internal_metadata_.mutable_unknown_fields<std::string>(),
2239 ptr, ctx);
2240 CHK_(ptr != nullptr);
2241 } // while
2242 message_done:
2243 _impl_._has_bits_.Or(has_bits);
2244 return ptr;
2245 failure:
2246 ptr = nullptr;
2247 goto message_done;
2248 #undef CHK_
2249 }
2250
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const2251 ::uint8_t* DebugInfoResultProto::_InternalSerialize(
2252 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
2253 // @@protoc_insertion_point(serialize_to_array_start:icing.lib.DebugInfoResultProto)
2254 ::uint32_t cached_has_bits = 0;
2255 (void) cached_has_bits;
2256
2257 cached_has_bits = _impl_._has_bits_[0];
2258 // optional .icing.lib.StatusProto status = 1;
2259 if (cached_has_bits & 0x00000001u) {
2260 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
2261 InternalWriteMessage(1, _Internal::status(this),
2262 _Internal::status(this).GetCachedSize(), target, stream);
2263 }
2264
2265 // optional .icing.lib.DebugInfoProto debug_info = 2;
2266 if (cached_has_bits & 0x00000002u) {
2267 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
2268 InternalWriteMessage(2, _Internal::debug_info(this),
2269 _Internal::debug_info(this).GetCachedSize(), target, stream);
2270 }
2271
2272 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2273 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
2274 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
2275 }
2276 // @@protoc_insertion_point(serialize_to_array_end:icing.lib.DebugInfoResultProto)
2277 return target;
2278 }
2279
ByteSizeLong() const2280 size_t DebugInfoResultProto::ByteSizeLong() const {
2281 // @@protoc_insertion_point(message_byte_size_start:icing.lib.DebugInfoResultProto)
2282 size_t total_size = 0;
2283
2284 ::uint32_t cached_has_bits = 0;
2285 // Prevent compiler warnings about cached_has_bits being unused
2286 (void) cached_has_bits;
2287
2288 cached_has_bits = _impl_._has_bits_[0];
2289 if (cached_has_bits & 0x00000003u) {
2290 // optional .icing.lib.StatusProto status = 1;
2291 if (cached_has_bits & 0x00000001u) {
2292 total_size += 1 +
2293 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
2294 *_impl_.status_);
2295 }
2296
2297 // optional .icing.lib.DebugInfoProto debug_info = 2;
2298 if (cached_has_bits & 0x00000002u) {
2299 total_size += 1 +
2300 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
2301 *_impl_.debug_info_);
2302 }
2303
2304 }
2305 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2306 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
2307 }
2308 int cached_size = ::_pbi::ToCachedSize(total_size);
2309 SetCachedSize(cached_size);
2310 return total_size;
2311 }
2312
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)2313 void DebugInfoResultProto::CheckTypeAndMergeFrom(
2314 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
2315 MergeFrom(*::_pbi::DownCast<const DebugInfoResultProto*>(
2316 &from));
2317 }
2318
MergeFrom(const DebugInfoResultProto & from)2319 void DebugInfoResultProto::MergeFrom(const DebugInfoResultProto& from) {
2320 DebugInfoResultProto* const _this = this;
2321 // @@protoc_insertion_point(class_specific_merge_from_start:icing.lib.DebugInfoResultProto)
2322 GOOGLE_DCHECK_NE(&from, _this);
2323 ::uint32_t cached_has_bits = 0;
2324 (void) cached_has_bits;
2325
2326 cached_has_bits = from._impl_._has_bits_[0];
2327 if (cached_has_bits & 0x00000003u) {
2328 if (cached_has_bits & 0x00000001u) {
2329 _this->_internal_mutable_status()->::icing::lib::StatusProto::MergeFrom(
2330 from._internal_status());
2331 }
2332 if (cached_has_bits & 0x00000002u) {
2333 _this->_internal_mutable_debug_info()->::icing::lib::DebugInfoProto::MergeFrom(
2334 from._internal_debug_info());
2335 }
2336 }
2337 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2338 }
2339
CopyFrom(const DebugInfoResultProto & from)2340 void DebugInfoResultProto::CopyFrom(const DebugInfoResultProto& from) {
2341 // @@protoc_insertion_point(class_specific_copy_from_start:icing.lib.DebugInfoResultProto)
2342 if (&from == this) return;
2343 Clear();
2344 MergeFrom(from);
2345 }
2346
IsInitialized() const2347 bool DebugInfoResultProto::IsInitialized() const {
2348 return true;
2349 }
2350
InternalSwap(DebugInfoResultProto * other)2351 void DebugInfoResultProto::InternalSwap(DebugInfoResultProto* other) {
2352 using std::swap;
2353 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2354 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
2355 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
2356 PROTOBUF_FIELD_OFFSET(DebugInfoResultProto, _impl_.debug_info_)
2357 + sizeof(DebugInfoResultProto::_impl_.debug_info_) // NOLINT
2358 - PROTOBUF_FIELD_OFFSET(DebugInfoResultProto, _impl_.status_)>(
2359 reinterpret_cast<char*>(&_impl_.status_),
2360 reinterpret_cast<char*>(&other->_impl_.status_));
2361 }
2362
GetTypeName() const2363 std::string DebugInfoResultProto::GetTypeName() const {
2364 return "icing.lib.DebugInfoResultProto";
2365 }
2366
2367
2368 // @@protoc_insertion_point(namespace_scope)
2369 } // namespace lib
2370 } // namespace icing
2371 PROTOBUF_NAMESPACE_OPEN
2372 template<> PROTOBUF_NOINLINE ::icing::lib::LogSeverity*
CreateMaybeMessage(Arena * arena)2373 Arena::CreateMaybeMessage< ::icing::lib::LogSeverity >(Arena* arena) {
2374 return Arena::CreateMessageInternal< ::icing::lib::LogSeverity >(arena);
2375 }
2376 template<> PROTOBUF_NOINLINE ::icing::lib::DebugInfoVerbosity*
CreateMaybeMessage(Arena * arena)2377 Arena::CreateMaybeMessage< ::icing::lib::DebugInfoVerbosity >(Arena* arena) {
2378 return Arena::CreateMessageInternal< ::icing::lib::DebugInfoVerbosity >(arena);
2379 }
2380 template<> PROTOBUF_NOINLINE ::icing::lib::IndexDebugInfoProto*
CreateMaybeMessage(Arena * arena)2381 Arena::CreateMaybeMessage< ::icing::lib::IndexDebugInfoProto >(Arena* arena) {
2382 return Arena::CreateMessageInternal< ::icing::lib::IndexDebugInfoProto >(arena);
2383 }
2384 template<> PROTOBUF_NOINLINE ::icing::lib::DocumentDebugInfoProto_CorpusInfo*
CreateMaybeMessage(Arena * arena)2385 Arena::CreateMaybeMessage< ::icing::lib::DocumentDebugInfoProto_CorpusInfo >(Arena* arena) {
2386 return Arena::CreateMessageInternal< ::icing::lib::DocumentDebugInfoProto_CorpusInfo >(arena);
2387 }
2388 template<> PROTOBUF_NOINLINE ::icing::lib::DocumentDebugInfoProto*
CreateMaybeMessage(Arena * arena)2389 Arena::CreateMaybeMessage< ::icing::lib::DocumentDebugInfoProto >(Arena* arena) {
2390 return Arena::CreateMessageInternal< ::icing::lib::DocumentDebugInfoProto >(arena);
2391 }
2392 template<> PROTOBUF_NOINLINE ::icing::lib::SchemaDebugInfoProto*
CreateMaybeMessage(Arena * arena)2393 Arena::CreateMaybeMessage< ::icing::lib::SchemaDebugInfoProto >(Arena* arena) {
2394 return Arena::CreateMessageInternal< ::icing::lib::SchemaDebugInfoProto >(arena);
2395 }
2396 template<> PROTOBUF_NOINLINE ::icing::lib::DebugInfoProto*
CreateMaybeMessage(Arena * arena)2397 Arena::CreateMaybeMessage< ::icing::lib::DebugInfoProto >(Arena* arena) {
2398 return Arena::CreateMessageInternal< ::icing::lib::DebugInfoProto >(arena);
2399 }
2400 template<> PROTOBUF_NOINLINE ::icing::lib::DebugInfoResultProto*
CreateMaybeMessage(Arena * arena)2401 Arena::CreateMaybeMessage< ::icing::lib::DebugInfoResultProto >(Arena* arena) {
2402 return Arena::CreateMessageInternal< ::icing::lib::DebugInfoResultProto >(arena);
2403 }
2404 PROTOBUF_NAMESPACE_CLOSE
2405
2406 // @@protoc_insertion_point(global_scope)
2407 #include <google/protobuf/port_undef.inc>
2408