1 // Generated by the protocol buffer compiler.  DO NOT EDIT!
2 // source: icing/proto/optimize.proto
3 
4 #include "icing/proto/optimize.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 {
OptimizeResultProto(::_pbi::ConstantInitialized)23 PROTOBUF_CONSTEXPR OptimizeResultProto::OptimizeResultProto(
24     ::_pbi::ConstantInitialized): _impl_{
25     /*decltype(_impl_._has_bits_)*/{}
26   , /*decltype(_impl_._cached_size_)*/{}
27   , /*decltype(_impl_.status_)*/nullptr
28   , /*decltype(_impl_.optimize_stats_)*/nullptr} {}
29 struct OptimizeResultProtoDefaultTypeInternal {
OptimizeResultProtoDefaultTypeInternalicing::lib::OptimizeResultProtoDefaultTypeInternal30   PROTOBUF_CONSTEXPR OptimizeResultProtoDefaultTypeInternal()
31       : _instance(::_pbi::ConstantInitialized{}) {}
~OptimizeResultProtoDefaultTypeInternalicing::lib::OptimizeResultProtoDefaultTypeInternal32   ~OptimizeResultProtoDefaultTypeInternal() {}
33   union {  // NOLINT(misc-non-private-member-variables-in-classes)
34     OptimizeResultProto _instance;
35   };
36 };
37 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 OptimizeResultProtoDefaultTypeInternal _OptimizeResultProto_default_instance_;
GetOptimizeInfoResultProto(::_pbi::ConstantInitialized)38 PROTOBUF_CONSTEXPR GetOptimizeInfoResultProto::GetOptimizeInfoResultProto(
39     ::_pbi::ConstantInitialized): _impl_{
40     /*decltype(_impl_._has_bits_)*/{}
41   , /*decltype(_impl_._cached_size_)*/{}
42   , /*decltype(_impl_.status_)*/nullptr
43   , /*decltype(_impl_.optimizable_docs_)*/::int64_t{0}
44   , /*decltype(_impl_.estimated_optimizable_bytes_)*/::int64_t{0}
45   , /*decltype(_impl_.time_since_last_optimize_ms_)*/::int64_t{0}} {}
46 struct GetOptimizeInfoResultProtoDefaultTypeInternal {
GetOptimizeInfoResultProtoDefaultTypeInternalicing::lib::GetOptimizeInfoResultProtoDefaultTypeInternal47   PROTOBUF_CONSTEXPR GetOptimizeInfoResultProtoDefaultTypeInternal()
48       : _instance(::_pbi::ConstantInitialized{}) {}
~GetOptimizeInfoResultProtoDefaultTypeInternalicing::lib::GetOptimizeInfoResultProtoDefaultTypeInternal49   ~GetOptimizeInfoResultProtoDefaultTypeInternal() {}
50   union {  // NOLINT(misc-non-private-member-variables-in-classes)
51     GetOptimizeInfoResultProto _instance;
52   };
53 };
54 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetOptimizeInfoResultProtoDefaultTypeInternal _GetOptimizeInfoResultProto_default_instance_;
OptimizeStatsProto(::_pbi::ConstantInitialized)55 PROTOBUF_CONSTEXPR OptimizeStatsProto::OptimizeStatsProto(
56     ::_pbi::ConstantInitialized): _impl_{
57     /*decltype(_impl_._has_bits_)*/{}
58   , /*decltype(_impl_._cached_size_)*/{}
59   , /*decltype(_impl_.latency_ms_)*/0
60   , /*decltype(_impl_.document_store_optimize_latency_ms_)*/0
61   , /*decltype(_impl_.index_restoration_latency_ms_)*/0
62   , /*decltype(_impl_.num_original_documents_)*/0
63   , /*decltype(_impl_.num_deleted_documents_)*/0
64   , /*decltype(_impl_.num_expired_documents_)*/0
65   , /*decltype(_impl_.storage_size_before_)*/::int64_t{0}
66   , /*decltype(_impl_.storage_size_after_)*/::int64_t{0}
67   , /*decltype(_impl_.time_since_last_optimize_ms_)*/::int64_t{0}
68   , /*decltype(_impl_.index_restoration_mode_)*/0
69   , /*decltype(_impl_.num_original_namespaces_)*/0
70   , /*decltype(_impl_.num_deleted_namespaces_)*/0} {}
71 struct OptimizeStatsProtoDefaultTypeInternal {
OptimizeStatsProtoDefaultTypeInternalicing::lib::OptimizeStatsProtoDefaultTypeInternal72   PROTOBUF_CONSTEXPR OptimizeStatsProtoDefaultTypeInternal()
73       : _instance(::_pbi::ConstantInitialized{}) {}
~OptimizeStatsProtoDefaultTypeInternalicing::lib::OptimizeStatsProtoDefaultTypeInternal74   ~OptimizeStatsProtoDefaultTypeInternal() {}
75   union {  // NOLINT(misc-non-private-member-variables-in-classes)
76     OptimizeStatsProto _instance;
77   };
78 };
79 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 OptimizeStatsProtoDefaultTypeInternal _OptimizeStatsProto_default_instance_;
80 }  // namespace lib
81 }  // namespace icing
82 namespace icing {
83 namespace lib {
OptimizeStatsProto_IndexRestorationMode_IsValid(int value)84 bool OptimizeStatsProto_IndexRestorationMode_IsValid(int value) {
85   switch (value) {
86     case 0:
87     case 1:
88       return true;
89     default:
90       return false;
91   }
92 }
93 
94 static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> OptimizeStatsProto_IndexRestorationMode_strings[2] = {};
95 
96 static const char OptimizeStatsProto_IndexRestorationMode_names[] =
97   "FULL_INDEX_REBUILD"
98   "INDEX_TRANSLATION";
99 
100 static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry OptimizeStatsProto_IndexRestorationMode_entries[] = {
101   { {OptimizeStatsProto_IndexRestorationMode_names + 0, 18}, 1 },
102   { {OptimizeStatsProto_IndexRestorationMode_names + 18, 17}, 0 },
103 };
104 
105 static const int OptimizeStatsProto_IndexRestorationMode_entries_by_number[] = {
106   1, // 0 -> INDEX_TRANSLATION
107   0, // 1 -> FULL_INDEX_REBUILD
108 };
109 
OptimizeStatsProto_IndexRestorationMode_Name(OptimizeStatsProto_IndexRestorationMode value)110 const std::string& OptimizeStatsProto_IndexRestorationMode_Name(
111     OptimizeStatsProto_IndexRestorationMode value) {
112   static const bool dummy =
113       ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
114           OptimizeStatsProto_IndexRestorationMode_entries,
115           OptimizeStatsProto_IndexRestorationMode_entries_by_number,
116           2, OptimizeStatsProto_IndexRestorationMode_strings);
117   (void) dummy;
118   int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
119       OptimizeStatsProto_IndexRestorationMode_entries,
120       OptimizeStatsProto_IndexRestorationMode_entries_by_number,
121       2, value);
122   return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
123                      OptimizeStatsProto_IndexRestorationMode_strings[idx].get();
124 }
OptimizeStatsProto_IndexRestorationMode_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,OptimizeStatsProto_IndexRestorationMode * value)125 bool OptimizeStatsProto_IndexRestorationMode_Parse(
126     ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, OptimizeStatsProto_IndexRestorationMode* value) {
127   int int_value;
128   bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
129       OptimizeStatsProto_IndexRestorationMode_entries, 2, name, &int_value);
130   if (success) {
131     *value = static_cast<OptimizeStatsProto_IndexRestorationMode>(int_value);
132   }
133   return success;
134 }
135 #if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
136 constexpr OptimizeStatsProto_IndexRestorationMode OptimizeStatsProto::INDEX_TRANSLATION;
137 constexpr OptimizeStatsProto_IndexRestorationMode OptimizeStatsProto::FULL_INDEX_REBUILD;
138 constexpr OptimizeStatsProto_IndexRestorationMode OptimizeStatsProto::IndexRestorationMode_MIN;
139 constexpr OptimizeStatsProto_IndexRestorationMode OptimizeStatsProto::IndexRestorationMode_MAX;
140 constexpr int OptimizeStatsProto::IndexRestorationMode_ARRAYSIZE;
141 #endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
142 
143 // ===================================================================
144 
145 class OptimizeResultProto::_Internal {
146  public:
147   using HasBits = decltype(std::declval<OptimizeResultProto>()._impl_._has_bits_);
148   static const ::icing::lib::StatusProto& status(const OptimizeResultProto* msg);
set_has_status(HasBits * has_bits)149   static void set_has_status(HasBits* has_bits) {
150     (*has_bits)[0] |= 1u;
151   }
152   static const ::icing::lib::OptimizeStatsProto& optimize_stats(const OptimizeResultProto* msg);
set_has_optimize_stats(HasBits * has_bits)153   static void set_has_optimize_stats(HasBits* has_bits) {
154     (*has_bits)[0] |= 2u;
155   }
156 };
157 
158 const ::icing::lib::StatusProto&
status(const OptimizeResultProto * msg)159 OptimizeResultProto::_Internal::status(const OptimizeResultProto* msg) {
160   return *msg->_impl_.status_;
161 }
162 const ::icing::lib::OptimizeStatsProto&
optimize_stats(const OptimizeResultProto * msg)163 OptimizeResultProto::_Internal::optimize_stats(const OptimizeResultProto* msg) {
164   return *msg->_impl_.optimize_stats_;
165 }
clear_status()166 void OptimizeResultProto::clear_status() {
167   if (_impl_.status_ != nullptr) _impl_.status_->Clear();
168   _impl_._has_bits_[0] &= ~0x00000001u;
169 }
OptimizeResultProto(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)170 OptimizeResultProto::OptimizeResultProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
171                          bool is_message_owned)
172   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
173   SharedCtor(arena, is_message_owned);
174   // @@protoc_insertion_point(arena_constructor:icing.lib.OptimizeResultProto)
175 }
OptimizeResultProto(const OptimizeResultProto & from)176 OptimizeResultProto::OptimizeResultProto(const OptimizeResultProto& from)
177   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
178   OptimizeResultProto* const _this = this; (void)_this;
179   new (&_impl_) Impl_{
180       decltype(_impl_._has_bits_){from._impl_._has_bits_}
181     , /*decltype(_impl_._cached_size_)*/{}
182     , decltype(_impl_.status_){nullptr}
183     , decltype(_impl_.optimize_stats_){nullptr}};
184 
185   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
186   if (from._internal_has_status()) {
187     _this->_impl_.status_ = new ::icing::lib::StatusProto(*from._impl_.status_);
188   }
189   if (from._internal_has_optimize_stats()) {
190     _this->_impl_.optimize_stats_ = new ::icing::lib::OptimizeStatsProto(*from._impl_.optimize_stats_);
191   }
192   // @@protoc_insertion_point(copy_constructor:icing.lib.OptimizeResultProto)
193 }
194 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)195 inline void OptimizeResultProto::SharedCtor(
196     ::_pb::Arena* arena, bool is_message_owned) {
197   (void)arena;
198   (void)is_message_owned;
199   new (&_impl_) Impl_{
200       decltype(_impl_._has_bits_){}
201     , /*decltype(_impl_._cached_size_)*/{}
202     , decltype(_impl_.status_){nullptr}
203     , decltype(_impl_.optimize_stats_){nullptr}
204   };
205 }
206 
~OptimizeResultProto()207 OptimizeResultProto::~OptimizeResultProto() {
208   // @@protoc_insertion_point(destructor:icing.lib.OptimizeResultProto)
209   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
210   (void)arena;
211     return;
212   }
213   SharedDtor();
214 }
215 
SharedDtor()216 inline void OptimizeResultProto::SharedDtor() {
217   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
218   if (this != internal_default_instance()) delete _impl_.status_;
219   if (this != internal_default_instance()) delete _impl_.optimize_stats_;
220 }
221 
SetCachedSize(int size) const222 void OptimizeResultProto::SetCachedSize(int size) const {
223   _impl_._cached_size_.Set(size);
224 }
225 
Clear()226 void OptimizeResultProto::Clear() {
227 // @@protoc_insertion_point(message_clear_start:icing.lib.OptimizeResultProto)
228   ::uint32_t cached_has_bits = 0;
229   // Prevent compiler warnings about cached_has_bits being unused
230   (void) cached_has_bits;
231 
232   cached_has_bits = _impl_._has_bits_[0];
233   if (cached_has_bits & 0x00000003u) {
234     if (cached_has_bits & 0x00000001u) {
235       GOOGLE_DCHECK(_impl_.status_ != nullptr);
236       _impl_.status_->Clear();
237     }
238     if (cached_has_bits & 0x00000002u) {
239       GOOGLE_DCHECK(_impl_.optimize_stats_ != nullptr);
240       _impl_.optimize_stats_->Clear();
241     }
242   }
243   _impl_._has_bits_.Clear();
244   _internal_metadata_.Clear<std::string>();
245 }
246 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)247 const char* OptimizeResultProto::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
248 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
249   _Internal::HasBits has_bits{};
250   while (!ctx->Done(&ptr)) {
251     ::uint32_t tag;
252     ptr = ::_pbi::ReadTag(ptr, &tag);
253     switch (tag >> 3) {
254       // optional .icing.lib.StatusProto status = 1;
255       case 1:
256         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
257           ptr = ctx->ParseMessage(_internal_mutable_status(), ptr);
258           CHK_(ptr);
259         } else {
260           goto handle_unusual;
261         }
262         continue;
263       // optional .icing.lib.OptimizeStatsProto optimize_stats = 2;
264       case 2:
265         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
266           ptr = ctx->ParseMessage(_internal_mutable_optimize_stats(), ptr);
267           CHK_(ptr);
268         } else {
269           goto handle_unusual;
270         }
271         continue;
272       default:
273         goto handle_unusual;
274     }  // switch
275   handle_unusual:
276     if ((tag == 0) || ((tag & 7) == 4)) {
277       CHK_(ptr);
278       ctx->SetLastTag(tag);
279       goto message_done;
280     }
281     ptr = UnknownFieldParse(
282         tag,
283         _internal_metadata_.mutable_unknown_fields<std::string>(),
284         ptr, ctx);
285     CHK_(ptr != nullptr);
286   }  // while
287 message_done:
288   _impl_._has_bits_.Or(has_bits);
289   return ptr;
290 failure:
291   ptr = nullptr;
292   goto message_done;
293 #undef CHK_
294 }
295 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const296 ::uint8_t* OptimizeResultProto::_InternalSerialize(
297     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
298   // @@protoc_insertion_point(serialize_to_array_start:icing.lib.OptimizeResultProto)
299   ::uint32_t cached_has_bits = 0;
300   (void) cached_has_bits;
301 
302   cached_has_bits = _impl_._has_bits_[0];
303   // optional .icing.lib.StatusProto status = 1;
304   if (cached_has_bits & 0x00000001u) {
305     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
306       InternalWriteMessage(1, _Internal::status(this),
307         _Internal::status(this).GetCachedSize(), target, stream);
308   }
309 
310   // optional .icing.lib.OptimizeStatsProto optimize_stats = 2;
311   if (cached_has_bits & 0x00000002u) {
312     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
313       InternalWriteMessage(2, _Internal::optimize_stats(this),
314         _Internal::optimize_stats(this).GetCachedSize(), target, stream);
315   }
316 
317   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
318     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
319         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
320   }
321   // @@protoc_insertion_point(serialize_to_array_end:icing.lib.OptimizeResultProto)
322   return target;
323 }
324 
ByteSizeLong() const325 size_t OptimizeResultProto::ByteSizeLong() const {
326 // @@protoc_insertion_point(message_byte_size_start:icing.lib.OptimizeResultProto)
327   size_t total_size = 0;
328 
329   ::uint32_t cached_has_bits = 0;
330   // Prevent compiler warnings about cached_has_bits being unused
331   (void) cached_has_bits;
332 
333   cached_has_bits = _impl_._has_bits_[0];
334   if (cached_has_bits & 0x00000003u) {
335     // optional .icing.lib.StatusProto status = 1;
336     if (cached_has_bits & 0x00000001u) {
337       total_size += 1 +
338         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
339           *_impl_.status_);
340     }
341 
342     // optional .icing.lib.OptimizeStatsProto optimize_stats = 2;
343     if (cached_has_bits & 0x00000002u) {
344       total_size += 1 +
345         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
346           *_impl_.optimize_stats_);
347     }
348 
349   }
350   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
351     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
352   }
353   int cached_size = ::_pbi::ToCachedSize(total_size);
354   SetCachedSize(cached_size);
355   return total_size;
356 }
357 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)358 void OptimizeResultProto::CheckTypeAndMergeFrom(
359     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
360   MergeFrom(*::_pbi::DownCast<const OptimizeResultProto*>(
361       &from));
362 }
363 
MergeFrom(const OptimizeResultProto & from)364 void OptimizeResultProto::MergeFrom(const OptimizeResultProto& from) {
365   OptimizeResultProto* const _this = this;
366   // @@protoc_insertion_point(class_specific_merge_from_start:icing.lib.OptimizeResultProto)
367   GOOGLE_DCHECK_NE(&from, _this);
368   ::uint32_t cached_has_bits = 0;
369   (void) cached_has_bits;
370 
371   cached_has_bits = from._impl_._has_bits_[0];
372   if (cached_has_bits & 0x00000003u) {
373     if (cached_has_bits & 0x00000001u) {
374       _this->_internal_mutable_status()->::icing::lib::StatusProto::MergeFrom(
375           from._internal_status());
376     }
377     if (cached_has_bits & 0x00000002u) {
378       _this->_internal_mutable_optimize_stats()->::icing::lib::OptimizeStatsProto::MergeFrom(
379           from._internal_optimize_stats());
380     }
381   }
382   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
383 }
384 
CopyFrom(const OptimizeResultProto & from)385 void OptimizeResultProto::CopyFrom(const OptimizeResultProto& from) {
386 // @@protoc_insertion_point(class_specific_copy_from_start:icing.lib.OptimizeResultProto)
387   if (&from == this) return;
388   Clear();
389   MergeFrom(from);
390 }
391 
IsInitialized() const392 bool OptimizeResultProto::IsInitialized() const {
393   return true;
394 }
395 
InternalSwap(OptimizeResultProto * other)396 void OptimizeResultProto::InternalSwap(OptimizeResultProto* other) {
397   using std::swap;
398   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
399   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
400   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
401       PROTOBUF_FIELD_OFFSET(OptimizeResultProto, _impl_.optimize_stats_)
402       + sizeof(OptimizeResultProto::_impl_.optimize_stats_)  // NOLINT
403       - PROTOBUF_FIELD_OFFSET(OptimizeResultProto, _impl_.status_)>(
404           reinterpret_cast<char*>(&_impl_.status_),
405           reinterpret_cast<char*>(&other->_impl_.status_));
406 }
407 
GetTypeName() const408 std::string OptimizeResultProto::GetTypeName() const {
409   return "icing.lib.OptimizeResultProto";
410 }
411 
412 
413 // ===================================================================
414 
415 class GetOptimizeInfoResultProto::_Internal {
416  public:
417   using HasBits = decltype(std::declval<GetOptimizeInfoResultProto>()._impl_._has_bits_);
418   static const ::icing::lib::StatusProto& status(const GetOptimizeInfoResultProto* msg);
set_has_status(HasBits * has_bits)419   static void set_has_status(HasBits* has_bits) {
420     (*has_bits)[0] |= 1u;
421   }
set_has_optimizable_docs(HasBits * has_bits)422   static void set_has_optimizable_docs(HasBits* has_bits) {
423     (*has_bits)[0] |= 2u;
424   }
set_has_estimated_optimizable_bytes(HasBits * has_bits)425   static void set_has_estimated_optimizable_bytes(HasBits* has_bits) {
426     (*has_bits)[0] |= 4u;
427   }
set_has_time_since_last_optimize_ms(HasBits * has_bits)428   static void set_has_time_since_last_optimize_ms(HasBits* has_bits) {
429     (*has_bits)[0] |= 8u;
430   }
431 };
432 
433 const ::icing::lib::StatusProto&
status(const GetOptimizeInfoResultProto * msg)434 GetOptimizeInfoResultProto::_Internal::status(const GetOptimizeInfoResultProto* msg) {
435   return *msg->_impl_.status_;
436 }
clear_status()437 void GetOptimizeInfoResultProto::clear_status() {
438   if (_impl_.status_ != nullptr) _impl_.status_->Clear();
439   _impl_._has_bits_[0] &= ~0x00000001u;
440 }
GetOptimizeInfoResultProto(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)441 GetOptimizeInfoResultProto::GetOptimizeInfoResultProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
442                          bool is_message_owned)
443   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
444   SharedCtor(arena, is_message_owned);
445   // @@protoc_insertion_point(arena_constructor:icing.lib.GetOptimizeInfoResultProto)
446 }
GetOptimizeInfoResultProto(const GetOptimizeInfoResultProto & from)447 GetOptimizeInfoResultProto::GetOptimizeInfoResultProto(const GetOptimizeInfoResultProto& from)
448   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
449   GetOptimizeInfoResultProto* const _this = this; (void)_this;
450   new (&_impl_) Impl_{
451       decltype(_impl_._has_bits_){from._impl_._has_bits_}
452     , /*decltype(_impl_._cached_size_)*/{}
453     , decltype(_impl_.status_){nullptr}
454     , decltype(_impl_.optimizable_docs_){}
455     , decltype(_impl_.estimated_optimizable_bytes_){}
456     , decltype(_impl_.time_since_last_optimize_ms_){}};
457 
458   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
459   if (from._internal_has_status()) {
460     _this->_impl_.status_ = new ::icing::lib::StatusProto(*from._impl_.status_);
461   }
462   ::memcpy(&_impl_.optimizable_docs_, &from._impl_.optimizable_docs_,
463     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.time_since_last_optimize_ms_) -
464     reinterpret_cast<char*>(&_impl_.optimizable_docs_)) + sizeof(_impl_.time_since_last_optimize_ms_));
465   // @@protoc_insertion_point(copy_constructor:icing.lib.GetOptimizeInfoResultProto)
466 }
467 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)468 inline void GetOptimizeInfoResultProto::SharedCtor(
469     ::_pb::Arena* arena, bool is_message_owned) {
470   (void)arena;
471   (void)is_message_owned;
472   new (&_impl_) Impl_{
473       decltype(_impl_._has_bits_){}
474     , /*decltype(_impl_._cached_size_)*/{}
475     , decltype(_impl_.status_){nullptr}
476     , decltype(_impl_.optimizable_docs_){::int64_t{0}}
477     , decltype(_impl_.estimated_optimizable_bytes_){::int64_t{0}}
478     , decltype(_impl_.time_since_last_optimize_ms_){::int64_t{0}}
479   };
480 }
481 
~GetOptimizeInfoResultProto()482 GetOptimizeInfoResultProto::~GetOptimizeInfoResultProto() {
483   // @@protoc_insertion_point(destructor:icing.lib.GetOptimizeInfoResultProto)
484   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
485   (void)arena;
486     return;
487   }
488   SharedDtor();
489 }
490 
SharedDtor()491 inline void GetOptimizeInfoResultProto::SharedDtor() {
492   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
493   if (this != internal_default_instance()) delete _impl_.status_;
494 }
495 
SetCachedSize(int size) const496 void GetOptimizeInfoResultProto::SetCachedSize(int size) const {
497   _impl_._cached_size_.Set(size);
498 }
499 
Clear()500 void GetOptimizeInfoResultProto::Clear() {
501 // @@protoc_insertion_point(message_clear_start:icing.lib.GetOptimizeInfoResultProto)
502   ::uint32_t cached_has_bits = 0;
503   // Prevent compiler warnings about cached_has_bits being unused
504   (void) cached_has_bits;
505 
506   cached_has_bits = _impl_._has_bits_[0];
507   if (cached_has_bits & 0x00000001u) {
508     GOOGLE_DCHECK(_impl_.status_ != nullptr);
509     _impl_.status_->Clear();
510   }
511   if (cached_has_bits & 0x0000000eu) {
512     ::memset(&_impl_.optimizable_docs_, 0, static_cast<size_t>(
513         reinterpret_cast<char*>(&_impl_.time_since_last_optimize_ms_) -
514         reinterpret_cast<char*>(&_impl_.optimizable_docs_)) + sizeof(_impl_.time_since_last_optimize_ms_));
515   }
516   _impl_._has_bits_.Clear();
517   _internal_metadata_.Clear<std::string>();
518 }
519 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)520 const char* GetOptimizeInfoResultProto::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
521 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
522   _Internal::HasBits has_bits{};
523   while (!ctx->Done(&ptr)) {
524     ::uint32_t tag;
525     ptr = ::_pbi::ReadTag(ptr, &tag);
526     switch (tag >> 3) {
527       // optional .icing.lib.StatusProto status = 1;
528       case 1:
529         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
530           ptr = ctx->ParseMessage(_internal_mutable_status(), ptr);
531           CHK_(ptr);
532         } else {
533           goto handle_unusual;
534         }
535         continue;
536       // optional int64 optimizable_docs = 2;
537       case 2:
538         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
539           _Internal::set_has_optimizable_docs(&has_bits);
540           _impl_.optimizable_docs_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
541           CHK_(ptr);
542         } else {
543           goto handle_unusual;
544         }
545         continue;
546       // optional int64 estimated_optimizable_bytes = 3;
547       case 3:
548         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
549           _Internal::set_has_estimated_optimizable_bytes(&has_bits);
550           _impl_.estimated_optimizable_bytes_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
551           CHK_(ptr);
552         } else {
553           goto handle_unusual;
554         }
555         continue;
556       // optional int64 time_since_last_optimize_ms = 4;
557       case 4:
558         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
559           _Internal::set_has_time_since_last_optimize_ms(&has_bits);
560           _impl_.time_since_last_optimize_ms_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
561           CHK_(ptr);
562         } else {
563           goto handle_unusual;
564         }
565         continue;
566       default:
567         goto handle_unusual;
568     }  // switch
569   handle_unusual:
570     if ((tag == 0) || ((tag & 7) == 4)) {
571       CHK_(ptr);
572       ctx->SetLastTag(tag);
573       goto message_done;
574     }
575     ptr = UnknownFieldParse(
576         tag,
577         _internal_metadata_.mutable_unknown_fields<std::string>(),
578         ptr, ctx);
579     CHK_(ptr != nullptr);
580   }  // while
581 message_done:
582   _impl_._has_bits_.Or(has_bits);
583   return ptr;
584 failure:
585   ptr = nullptr;
586   goto message_done;
587 #undef CHK_
588 }
589 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const590 ::uint8_t* GetOptimizeInfoResultProto::_InternalSerialize(
591     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
592   // @@protoc_insertion_point(serialize_to_array_start:icing.lib.GetOptimizeInfoResultProto)
593   ::uint32_t cached_has_bits = 0;
594   (void) cached_has_bits;
595 
596   cached_has_bits = _impl_._has_bits_[0];
597   // optional .icing.lib.StatusProto status = 1;
598   if (cached_has_bits & 0x00000001u) {
599     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
600       InternalWriteMessage(1, _Internal::status(this),
601         _Internal::status(this).GetCachedSize(), target, stream);
602   }
603 
604   // optional int64 optimizable_docs = 2;
605   if (cached_has_bits & 0x00000002u) {
606     target = stream->EnsureSpace(target);
607     target = ::_pbi::WireFormatLite::WriteInt64ToArray(2, this->_internal_optimizable_docs(), target);
608   }
609 
610   // optional int64 estimated_optimizable_bytes = 3;
611   if (cached_has_bits & 0x00000004u) {
612     target = stream->EnsureSpace(target);
613     target = ::_pbi::WireFormatLite::WriteInt64ToArray(3, this->_internal_estimated_optimizable_bytes(), target);
614   }
615 
616   // optional int64 time_since_last_optimize_ms = 4;
617   if (cached_has_bits & 0x00000008u) {
618     target = stream->EnsureSpace(target);
619     target = ::_pbi::WireFormatLite::WriteInt64ToArray(4, this->_internal_time_since_last_optimize_ms(), target);
620   }
621 
622   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
623     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
624         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
625   }
626   // @@protoc_insertion_point(serialize_to_array_end:icing.lib.GetOptimizeInfoResultProto)
627   return target;
628 }
629 
ByteSizeLong() const630 size_t GetOptimizeInfoResultProto::ByteSizeLong() const {
631 // @@protoc_insertion_point(message_byte_size_start:icing.lib.GetOptimizeInfoResultProto)
632   size_t total_size = 0;
633 
634   ::uint32_t cached_has_bits = 0;
635   // Prevent compiler warnings about cached_has_bits being unused
636   (void) cached_has_bits;
637 
638   cached_has_bits = _impl_._has_bits_[0];
639   if (cached_has_bits & 0x0000000fu) {
640     // optional .icing.lib.StatusProto status = 1;
641     if (cached_has_bits & 0x00000001u) {
642       total_size += 1 +
643         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
644           *_impl_.status_);
645     }
646 
647     // optional int64 optimizable_docs = 2;
648     if (cached_has_bits & 0x00000002u) {
649       total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_optimizable_docs());
650     }
651 
652     // optional int64 estimated_optimizable_bytes = 3;
653     if (cached_has_bits & 0x00000004u) {
654       total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_estimated_optimizable_bytes());
655     }
656 
657     // optional int64 time_since_last_optimize_ms = 4;
658     if (cached_has_bits & 0x00000008u) {
659       total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_time_since_last_optimize_ms());
660     }
661 
662   }
663   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
664     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
665   }
666   int cached_size = ::_pbi::ToCachedSize(total_size);
667   SetCachedSize(cached_size);
668   return total_size;
669 }
670 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)671 void GetOptimizeInfoResultProto::CheckTypeAndMergeFrom(
672     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
673   MergeFrom(*::_pbi::DownCast<const GetOptimizeInfoResultProto*>(
674       &from));
675 }
676 
MergeFrom(const GetOptimizeInfoResultProto & from)677 void GetOptimizeInfoResultProto::MergeFrom(const GetOptimizeInfoResultProto& from) {
678   GetOptimizeInfoResultProto* const _this = this;
679   // @@protoc_insertion_point(class_specific_merge_from_start:icing.lib.GetOptimizeInfoResultProto)
680   GOOGLE_DCHECK_NE(&from, _this);
681   ::uint32_t cached_has_bits = 0;
682   (void) cached_has_bits;
683 
684   cached_has_bits = from._impl_._has_bits_[0];
685   if (cached_has_bits & 0x0000000fu) {
686     if (cached_has_bits & 0x00000001u) {
687       _this->_internal_mutable_status()->::icing::lib::StatusProto::MergeFrom(
688           from._internal_status());
689     }
690     if (cached_has_bits & 0x00000002u) {
691       _this->_impl_.optimizable_docs_ = from._impl_.optimizable_docs_;
692     }
693     if (cached_has_bits & 0x00000004u) {
694       _this->_impl_.estimated_optimizable_bytes_ = from._impl_.estimated_optimizable_bytes_;
695     }
696     if (cached_has_bits & 0x00000008u) {
697       _this->_impl_.time_since_last_optimize_ms_ = from._impl_.time_since_last_optimize_ms_;
698     }
699     _this->_impl_._has_bits_[0] |= cached_has_bits;
700   }
701   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
702 }
703 
CopyFrom(const GetOptimizeInfoResultProto & from)704 void GetOptimizeInfoResultProto::CopyFrom(const GetOptimizeInfoResultProto& from) {
705 // @@protoc_insertion_point(class_specific_copy_from_start:icing.lib.GetOptimizeInfoResultProto)
706   if (&from == this) return;
707   Clear();
708   MergeFrom(from);
709 }
710 
IsInitialized() const711 bool GetOptimizeInfoResultProto::IsInitialized() const {
712   return true;
713 }
714 
InternalSwap(GetOptimizeInfoResultProto * other)715 void GetOptimizeInfoResultProto::InternalSwap(GetOptimizeInfoResultProto* other) {
716   using std::swap;
717   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
718   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
719   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
720       PROTOBUF_FIELD_OFFSET(GetOptimizeInfoResultProto, _impl_.time_since_last_optimize_ms_)
721       + sizeof(GetOptimizeInfoResultProto::_impl_.time_since_last_optimize_ms_)  // NOLINT
722       - PROTOBUF_FIELD_OFFSET(GetOptimizeInfoResultProto, _impl_.status_)>(
723           reinterpret_cast<char*>(&_impl_.status_),
724           reinterpret_cast<char*>(&other->_impl_.status_));
725 }
726 
GetTypeName() const727 std::string GetOptimizeInfoResultProto::GetTypeName() const {
728   return "icing.lib.GetOptimizeInfoResultProto";
729 }
730 
731 
732 // ===================================================================
733 
734 class OptimizeStatsProto::_Internal {
735  public:
736   using HasBits = decltype(std::declval<OptimizeStatsProto>()._impl_._has_bits_);
set_has_latency_ms(HasBits * has_bits)737   static void set_has_latency_ms(HasBits* has_bits) {
738     (*has_bits)[0] |= 1u;
739   }
set_has_document_store_optimize_latency_ms(HasBits * has_bits)740   static void set_has_document_store_optimize_latency_ms(HasBits* has_bits) {
741     (*has_bits)[0] |= 2u;
742   }
set_has_index_restoration_latency_ms(HasBits * has_bits)743   static void set_has_index_restoration_latency_ms(HasBits* has_bits) {
744     (*has_bits)[0] |= 4u;
745   }
set_has_num_original_documents(HasBits * has_bits)746   static void set_has_num_original_documents(HasBits* has_bits) {
747     (*has_bits)[0] |= 8u;
748   }
set_has_num_deleted_documents(HasBits * has_bits)749   static void set_has_num_deleted_documents(HasBits* has_bits) {
750     (*has_bits)[0] |= 16u;
751   }
set_has_num_expired_documents(HasBits * has_bits)752   static void set_has_num_expired_documents(HasBits* has_bits) {
753     (*has_bits)[0] |= 32u;
754   }
set_has_storage_size_before(HasBits * has_bits)755   static void set_has_storage_size_before(HasBits* has_bits) {
756     (*has_bits)[0] |= 64u;
757   }
set_has_storage_size_after(HasBits * has_bits)758   static void set_has_storage_size_after(HasBits* has_bits) {
759     (*has_bits)[0] |= 128u;
760   }
set_has_time_since_last_optimize_ms(HasBits * has_bits)761   static void set_has_time_since_last_optimize_ms(HasBits* has_bits) {
762     (*has_bits)[0] |= 256u;
763   }
set_has_index_restoration_mode(HasBits * has_bits)764   static void set_has_index_restoration_mode(HasBits* has_bits) {
765     (*has_bits)[0] |= 512u;
766   }
set_has_num_original_namespaces(HasBits * has_bits)767   static void set_has_num_original_namespaces(HasBits* has_bits) {
768     (*has_bits)[0] |= 1024u;
769   }
set_has_num_deleted_namespaces(HasBits * has_bits)770   static void set_has_num_deleted_namespaces(HasBits* has_bits) {
771     (*has_bits)[0] |= 2048u;
772   }
773 };
774 
OptimizeStatsProto(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)775 OptimizeStatsProto::OptimizeStatsProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
776                          bool is_message_owned)
777   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
778   SharedCtor(arena, is_message_owned);
779   // @@protoc_insertion_point(arena_constructor:icing.lib.OptimizeStatsProto)
780 }
OptimizeStatsProto(const OptimizeStatsProto & from)781 OptimizeStatsProto::OptimizeStatsProto(const OptimizeStatsProto& from)
782   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
783   OptimizeStatsProto* const _this = this; (void)_this;
784   new (&_impl_) Impl_{
785       decltype(_impl_._has_bits_){from._impl_._has_bits_}
786     , /*decltype(_impl_._cached_size_)*/{}
787     , decltype(_impl_.latency_ms_){}
788     , decltype(_impl_.document_store_optimize_latency_ms_){}
789     , decltype(_impl_.index_restoration_latency_ms_){}
790     , decltype(_impl_.num_original_documents_){}
791     , decltype(_impl_.num_deleted_documents_){}
792     , decltype(_impl_.num_expired_documents_){}
793     , decltype(_impl_.storage_size_before_){}
794     , decltype(_impl_.storage_size_after_){}
795     , decltype(_impl_.time_since_last_optimize_ms_){}
796     , decltype(_impl_.index_restoration_mode_){}
797     , decltype(_impl_.num_original_namespaces_){}
798     , decltype(_impl_.num_deleted_namespaces_){}};
799 
800   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
801   ::memcpy(&_impl_.latency_ms_, &from._impl_.latency_ms_,
802     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.num_deleted_namespaces_) -
803     reinterpret_cast<char*>(&_impl_.latency_ms_)) + sizeof(_impl_.num_deleted_namespaces_));
804   // @@protoc_insertion_point(copy_constructor:icing.lib.OptimizeStatsProto)
805 }
806 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)807 inline void OptimizeStatsProto::SharedCtor(
808     ::_pb::Arena* arena, bool is_message_owned) {
809   (void)arena;
810   (void)is_message_owned;
811   new (&_impl_) Impl_{
812       decltype(_impl_._has_bits_){}
813     , /*decltype(_impl_._cached_size_)*/{}
814     , decltype(_impl_.latency_ms_){0}
815     , decltype(_impl_.document_store_optimize_latency_ms_){0}
816     , decltype(_impl_.index_restoration_latency_ms_){0}
817     , decltype(_impl_.num_original_documents_){0}
818     , decltype(_impl_.num_deleted_documents_){0}
819     , decltype(_impl_.num_expired_documents_){0}
820     , decltype(_impl_.storage_size_before_){::int64_t{0}}
821     , decltype(_impl_.storage_size_after_){::int64_t{0}}
822     , decltype(_impl_.time_since_last_optimize_ms_){::int64_t{0}}
823     , decltype(_impl_.index_restoration_mode_){0}
824     , decltype(_impl_.num_original_namespaces_){0}
825     , decltype(_impl_.num_deleted_namespaces_){0}
826   };
827 }
828 
~OptimizeStatsProto()829 OptimizeStatsProto::~OptimizeStatsProto() {
830   // @@protoc_insertion_point(destructor:icing.lib.OptimizeStatsProto)
831   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
832   (void)arena;
833     return;
834   }
835   SharedDtor();
836 }
837 
SharedDtor()838 inline void OptimizeStatsProto::SharedDtor() {
839   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
840 }
841 
SetCachedSize(int size) const842 void OptimizeStatsProto::SetCachedSize(int size) const {
843   _impl_._cached_size_.Set(size);
844 }
845 
Clear()846 void OptimizeStatsProto::Clear() {
847 // @@protoc_insertion_point(message_clear_start:icing.lib.OptimizeStatsProto)
848   ::uint32_t cached_has_bits = 0;
849   // Prevent compiler warnings about cached_has_bits being unused
850   (void) cached_has_bits;
851 
852   cached_has_bits = _impl_._has_bits_[0];
853   if (cached_has_bits & 0x000000ffu) {
854     ::memset(&_impl_.latency_ms_, 0, static_cast<size_t>(
855         reinterpret_cast<char*>(&_impl_.storage_size_after_) -
856         reinterpret_cast<char*>(&_impl_.latency_ms_)) + sizeof(_impl_.storage_size_after_));
857   }
858   if (cached_has_bits & 0x00000f00u) {
859     ::memset(&_impl_.time_since_last_optimize_ms_, 0, static_cast<size_t>(
860         reinterpret_cast<char*>(&_impl_.num_deleted_namespaces_) -
861         reinterpret_cast<char*>(&_impl_.time_since_last_optimize_ms_)) + sizeof(_impl_.num_deleted_namespaces_));
862   }
863   _impl_._has_bits_.Clear();
864   _internal_metadata_.Clear<std::string>();
865 }
866 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)867 const char* OptimizeStatsProto::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
868 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
869   _Internal::HasBits has_bits{};
870   while (!ctx->Done(&ptr)) {
871     ::uint32_t tag;
872     ptr = ::_pbi::ReadTag(ptr, &tag);
873     switch (tag >> 3) {
874       // optional int32 latency_ms = 1;
875       case 1:
876         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
877           _Internal::set_has_latency_ms(&has_bits);
878           _impl_.latency_ms_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
879           CHK_(ptr);
880         } else {
881           goto handle_unusual;
882         }
883         continue;
884       // optional int32 document_store_optimize_latency_ms = 2;
885       case 2:
886         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
887           _Internal::set_has_document_store_optimize_latency_ms(&has_bits);
888           _impl_.document_store_optimize_latency_ms_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
889           CHK_(ptr);
890         } else {
891           goto handle_unusual;
892         }
893         continue;
894       // optional int32 index_restoration_latency_ms = 3;
895       case 3:
896         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
897           _Internal::set_has_index_restoration_latency_ms(&has_bits);
898           _impl_.index_restoration_latency_ms_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
899           CHK_(ptr);
900         } else {
901           goto handle_unusual;
902         }
903         continue;
904       // optional int32 num_original_documents = 4;
905       case 4:
906         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
907           _Internal::set_has_num_original_documents(&has_bits);
908           _impl_.num_original_documents_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
909           CHK_(ptr);
910         } else {
911           goto handle_unusual;
912         }
913         continue;
914       // optional int32 num_deleted_documents = 5;
915       case 5:
916         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
917           _Internal::set_has_num_deleted_documents(&has_bits);
918           _impl_.num_deleted_documents_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
919           CHK_(ptr);
920         } else {
921           goto handle_unusual;
922         }
923         continue;
924       // optional int32 num_expired_documents = 6;
925       case 6:
926         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 48)) {
927           _Internal::set_has_num_expired_documents(&has_bits);
928           _impl_.num_expired_documents_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
929           CHK_(ptr);
930         } else {
931           goto handle_unusual;
932         }
933         continue;
934       // optional int64 storage_size_before = 7;
935       case 7:
936         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 56)) {
937           _Internal::set_has_storage_size_before(&has_bits);
938           _impl_.storage_size_before_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
939           CHK_(ptr);
940         } else {
941           goto handle_unusual;
942         }
943         continue;
944       // optional int64 storage_size_after = 8;
945       case 8:
946         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 64)) {
947           _Internal::set_has_storage_size_after(&has_bits);
948           _impl_.storage_size_after_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
949           CHK_(ptr);
950         } else {
951           goto handle_unusual;
952         }
953         continue;
954       // optional int64 time_since_last_optimize_ms = 9;
955       case 9:
956         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 72)) {
957           _Internal::set_has_time_since_last_optimize_ms(&has_bits);
958           _impl_.time_since_last_optimize_ms_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
959           CHK_(ptr);
960         } else {
961           goto handle_unusual;
962         }
963         continue;
964       // optional .icing.lib.OptimizeStatsProto.IndexRestorationMode index_restoration_mode = 10;
965       case 10:
966         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 80)) {
967           ::uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
968           CHK_(ptr);
969           if (PROTOBUF_PREDICT_TRUE(::icing::lib::OptimizeStatsProto_IndexRestorationMode_IsValid(val))) {
970             _internal_set_index_restoration_mode(static_cast<::icing::lib::OptimizeStatsProto_IndexRestorationMode>(val));
971           } else {
972             ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(10, val, mutable_unknown_fields());
973           }
974         } else {
975           goto handle_unusual;
976         }
977         continue;
978       // optional int32 num_original_namespaces = 11;
979       case 11:
980         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 88)) {
981           _Internal::set_has_num_original_namespaces(&has_bits);
982           _impl_.num_original_namespaces_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
983           CHK_(ptr);
984         } else {
985           goto handle_unusual;
986         }
987         continue;
988       // optional int32 num_deleted_namespaces = 12;
989       case 12:
990         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 96)) {
991           _Internal::set_has_num_deleted_namespaces(&has_bits);
992           _impl_.num_deleted_namespaces_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
993           CHK_(ptr);
994         } else {
995           goto handle_unusual;
996         }
997         continue;
998       default:
999         goto handle_unusual;
1000     }  // switch
1001   handle_unusual:
1002     if ((tag == 0) || ((tag & 7) == 4)) {
1003       CHK_(ptr);
1004       ctx->SetLastTag(tag);
1005       goto message_done;
1006     }
1007     ptr = UnknownFieldParse(
1008         tag,
1009         _internal_metadata_.mutable_unknown_fields<std::string>(),
1010         ptr, ctx);
1011     CHK_(ptr != nullptr);
1012   }  // while
1013 message_done:
1014   _impl_._has_bits_.Or(has_bits);
1015   return ptr;
1016 failure:
1017   ptr = nullptr;
1018   goto message_done;
1019 #undef CHK_
1020 }
1021 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1022 ::uint8_t* OptimizeStatsProto::_InternalSerialize(
1023     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1024   // @@protoc_insertion_point(serialize_to_array_start:icing.lib.OptimizeStatsProto)
1025   ::uint32_t cached_has_bits = 0;
1026   (void) cached_has_bits;
1027 
1028   cached_has_bits = _impl_._has_bits_[0];
1029   // optional int32 latency_ms = 1;
1030   if (cached_has_bits & 0x00000001u) {
1031     target = stream->EnsureSpace(target);
1032     target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_latency_ms(), target);
1033   }
1034 
1035   // optional int32 document_store_optimize_latency_ms = 2;
1036   if (cached_has_bits & 0x00000002u) {
1037     target = stream->EnsureSpace(target);
1038     target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_document_store_optimize_latency_ms(), target);
1039   }
1040 
1041   // optional int32 index_restoration_latency_ms = 3;
1042   if (cached_has_bits & 0x00000004u) {
1043     target = stream->EnsureSpace(target);
1044     target = ::_pbi::WireFormatLite::WriteInt32ToArray(3, this->_internal_index_restoration_latency_ms(), target);
1045   }
1046 
1047   // optional int32 num_original_documents = 4;
1048   if (cached_has_bits & 0x00000008u) {
1049     target = stream->EnsureSpace(target);
1050     target = ::_pbi::WireFormatLite::WriteInt32ToArray(4, this->_internal_num_original_documents(), target);
1051   }
1052 
1053   // optional int32 num_deleted_documents = 5;
1054   if (cached_has_bits & 0x00000010u) {
1055     target = stream->EnsureSpace(target);
1056     target = ::_pbi::WireFormatLite::WriteInt32ToArray(5, this->_internal_num_deleted_documents(), target);
1057   }
1058 
1059   // optional int32 num_expired_documents = 6;
1060   if (cached_has_bits & 0x00000020u) {
1061     target = stream->EnsureSpace(target);
1062     target = ::_pbi::WireFormatLite::WriteInt32ToArray(6, this->_internal_num_expired_documents(), target);
1063   }
1064 
1065   // optional int64 storage_size_before = 7;
1066   if (cached_has_bits & 0x00000040u) {
1067     target = stream->EnsureSpace(target);
1068     target = ::_pbi::WireFormatLite::WriteInt64ToArray(7, this->_internal_storage_size_before(), target);
1069   }
1070 
1071   // optional int64 storage_size_after = 8;
1072   if (cached_has_bits & 0x00000080u) {
1073     target = stream->EnsureSpace(target);
1074     target = ::_pbi::WireFormatLite::WriteInt64ToArray(8, this->_internal_storage_size_after(), target);
1075   }
1076 
1077   // optional int64 time_since_last_optimize_ms = 9;
1078   if (cached_has_bits & 0x00000100u) {
1079     target = stream->EnsureSpace(target);
1080     target = ::_pbi::WireFormatLite::WriteInt64ToArray(9, this->_internal_time_since_last_optimize_ms(), target);
1081   }
1082 
1083   // optional .icing.lib.OptimizeStatsProto.IndexRestorationMode index_restoration_mode = 10;
1084   if (cached_has_bits & 0x00000200u) {
1085     target = stream->EnsureSpace(target);
1086     target = ::_pbi::WireFormatLite::WriteEnumToArray(
1087       10, this->_internal_index_restoration_mode(), target);
1088   }
1089 
1090   // optional int32 num_original_namespaces = 11;
1091   if (cached_has_bits & 0x00000400u) {
1092     target = stream->EnsureSpace(target);
1093     target = ::_pbi::WireFormatLite::WriteInt32ToArray(11, this->_internal_num_original_namespaces(), target);
1094   }
1095 
1096   // optional int32 num_deleted_namespaces = 12;
1097   if (cached_has_bits & 0x00000800u) {
1098     target = stream->EnsureSpace(target);
1099     target = ::_pbi::WireFormatLite::WriteInt32ToArray(12, this->_internal_num_deleted_namespaces(), target);
1100   }
1101 
1102   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1103     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1104         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1105   }
1106   // @@protoc_insertion_point(serialize_to_array_end:icing.lib.OptimizeStatsProto)
1107   return target;
1108 }
1109 
ByteSizeLong() const1110 size_t OptimizeStatsProto::ByteSizeLong() const {
1111 // @@protoc_insertion_point(message_byte_size_start:icing.lib.OptimizeStatsProto)
1112   size_t total_size = 0;
1113 
1114   ::uint32_t cached_has_bits = 0;
1115   // Prevent compiler warnings about cached_has_bits being unused
1116   (void) cached_has_bits;
1117 
1118   cached_has_bits = _impl_._has_bits_[0];
1119   if (cached_has_bits & 0x000000ffu) {
1120     // optional int32 latency_ms = 1;
1121     if (cached_has_bits & 0x00000001u) {
1122       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_latency_ms());
1123     }
1124 
1125     // optional int32 document_store_optimize_latency_ms = 2;
1126     if (cached_has_bits & 0x00000002u) {
1127       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_document_store_optimize_latency_ms());
1128     }
1129 
1130     // optional int32 index_restoration_latency_ms = 3;
1131     if (cached_has_bits & 0x00000004u) {
1132       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_index_restoration_latency_ms());
1133     }
1134 
1135     // optional int32 num_original_documents = 4;
1136     if (cached_has_bits & 0x00000008u) {
1137       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_num_original_documents());
1138     }
1139 
1140     // optional int32 num_deleted_documents = 5;
1141     if (cached_has_bits & 0x00000010u) {
1142       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_num_deleted_documents());
1143     }
1144 
1145     // optional int32 num_expired_documents = 6;
1146     if (cached_has_bits & 0x00000020u) {
1147       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_num_expired_documents());
1148     }
1149 
1150     // optional int64 storage_size_before = 7;
1151     if (cached_has_bits & 0x00000040u) {
1152       total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_storage_size_before());
1153     }
1154 
1155     // optional int64 storage_size_after = 8;
1156     if (cached_has_bits & 0x00000080u) {
1157       total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_storage_size_after());
1158     }
1159 
1160   }
1161   if (cached_has_bits & 0x00000f00u) {
1162     // optional int64 time_since_last_optimize_ms = 9;
1163     if (cached_has_bits & 0x00000100u) {
1164       total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_time_since_last_optimize_ms());
1165     }
1166 
1167     // optional .icing.lib.OptimizeStatsProto.IndexRestorationMode index_restoration_mode = 10;
1168     if (cached_has_bits & 0x00000200u) {
1169       total_size += 1 +
1170         ::_pbi::WireFormatLite::EnumSize(this->_internal_index_restoration_mode());
1171     }
1172 
1173     // optional int32 num_original_namespaces = 11;
1174     if (cached_has_bits & 0x00000400u) {
1175       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_num_original_namespaces());
1176     }
1177 
1178     // optional int32 num_deleted_namespaces = 12;
1179     if (cached_has_bits & 0x00000800u) {
1180       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_num_deleted_namespaces());
1181     }
1182 
1183   }
1184   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1185     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1186   }
1187   int cached_size = ::_pbi::ToCachedSize(total_size);
1188   SetCachedSize(cached_size);
1189   return total_size;
1190 }
1191 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1192 void OptimizeStatsProto::CheckTypeAndMergeFrom(
1193     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1194   MergeFrom(*::_pbi::DownCast<const OptimizeStatsProto*>(
1195       &from));
1196 }
1197 
MergeFrom(const OptimizeStatsProto & from)1198 void OptimizeStatsProto::MergeFrom(const OptimizeStatsProto& from) {
1199   OptimizeStatsProto* const _this = this;
1200   // @@protoc_insertion_point(class_specific_merge_from_start:icing.lib.OptimizeStatsProto)
1201   GOOGLE_DCHECK_NE(&from, _this);
1202   ::uint32_t cached_has_bits = 0;
1203   (void) cached_has_bits;
1204 
1205   cached_has_bits = from._impl_._has_bits_[0];
1206   if (cached_has_bits & 0x000000ffu) {
1207     if (cached_has_bits & 0x00000001u) {
1208       _this->_impl_.latency_ms_ = from._impl_.latency_ms_;
1209     }
1210     if (cached_has_bits & 0x00000002u) {
1211       _this->_impl_.document_store_optimize_latency_ms_ = from._impl_.document_store_optimize_latency_ms_;
1212     }
1213     if (cached_has_bits & 0x00000004u) {
1214       _this->_impl_.index_restoration_latency_ms_ = from._impl_.index_restoration_latency_ms_;
1215     }
1216     if (cached_has_bits & 0x00000008u) {
1217       _this->_impl_.num_original_documents_ = from._impl_.num_original_documents_;
1218     }
1219     if (cached_has_bits & 0x00000010u) {
1220       _this->_impl_.num_deleted_documents_ = from._impl_.num_deleted_documents_;
1221     }
1222     if (cached_has_bits & 0x00000020u) {
1223       _this->_impl_.num_expired_documents_ = from._impl_.num_expired_documents_;
1224     }
1225     if (cached_has_bits & 0x00000040u) {
1226       _this->_impl_.storage_size_before_ = from._impl_.storage_size_before_;
1227     }
1228     if (cached_has_bits & 0x00000080u) {
1229       _this->_impl_.storage_size_after_ = from._impl_.storage_size_after_;
1230     }
1231     _this->_impl_._has_bits_[0] |= cached_has_bits;
1232   }
1233   if (cached_has_bits & 0x00000f00u) {
1234     if (cached_has_bits & 0x00000100u) {
1235       _this->_impl_.time_since_last_optimize_ms_ = from._impl_.time_since_last_optimize_ms_;
1236     }
1237     if (cached_has_bits & 0x00000200u) {
1238       _this->_impl_.index_restoration_mode_ = from._impl_.index_restoration_mode_;
1239     }
1240     if (cached_has_bits & 0x00000400u) {
1241       _this->_impl_.num_original_namespaces_ = from._impl_.num_original_namespaces_;
1242     }
1243     if (cached_has_bits & 0x00000800u) {
1244       _this->_impl_.num_deleted_namespaces_ = from._impl_.num_deleted_namespaces_;
1245     }
1246     _this->_impl_._has_bits_[0] |= cached_has_bits;
1247   }
1248   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1249 }
1250 
CopyFrom(const OptimizeStatsProto & from)1251 void OptimizeStatsProto::CopyFrom(const OptimizeStatsProto& from) {
1252 // @@protoc_insertion_point(class_specific_copy_from_start:icing.lib.OptimizeStatsProto)
1253   if (&from == this) return;
1254   Clear();
1255   MergeFrom(from);
1256 }
1257 
IsInitialized() const1258 bool OptimizeStatsProto::IsInitialized() const {
1259   return true;
1260 }
1261 
InternalSwap(OptimizeStatsProto * other)1262 void OptimizeStatsProto::InternalSwap(OptimizeStatsProto* other) {
1263   using std::swap;
1264   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1265   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
1266   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
1267       PROTOBUF_FIELD_OFFSET(OptimizeStatsProto, _impl_.num_deleted_namespaces_)
1268       + sizeof(OptimizeStatsProto::_impl_.num_deleted_namespaces_)  // NOLINT
1269       - PROTOBUF_FIELD_OFFSET(OptimizeStatsProto, _impl_.latency_ms_)>(
1270           reinterpret_cast<char*>(&_impl_.latency_ms_),
1271           reinterpret_cast<char*>(&other->_impl_.latency_ms_));
1272 }
1273 
GetTypeName() const1274 std::string OptimizeStatsProto::GetTypeName() const {
1275   return "icing.lib.OptimizeStatsProto";
1276 }
1277 
1278 
1279 // @@protoc_insertion_point(namespace_scope)
1280 }  // namespace lib
1281 }  // namespace icing
1282 PROTOBUF_NAMESPACE_OPEN
1283 template<> PROTOBUF_NOINLINE ::icing::lib::OptimizeResultProto*
CreateMaybeMessage(Arena * arena)1284 Arena::CreateMaybeMessage< ::icing::lib::OptimizeResultProto >(Arena* arena) {
1285   return Arena::CreateMessageInternal< ::icing::lib::OptimizeResultProto >(arena);
1286 }
1287 template<> PROTOBUF_NOINLINE ::icing::lib::GetOptimizeInfoResultProto*
CreateMaybeMessage(Arena * arena)1288 Arena::CreateMaybeMessage< ::icing::lib::GetOptimizeInfoResultProto >(Arena* arena) {
1289   return Arena::CreateMessageInternal< ::icing::lib::GetOptimizeInfoResultProto >(arena);
1290 }
1291 template<> PROTOBUF_NOINLINE ::icing::lib::OptimizeStatsProto*
CreateMaybeMessage(Arena * arena)1292 Arena::CreateMaybeMessage< ::icing::lib::OptimizeStatsProto >(Arena* arena) {
1293   return Arena::CreateMessageInternal< ::icing::lib::OptimizeStatsProto >(arena);
1294 }
1295 PROTOBUF_NAMESPACE_CLOSE
1296 
1297 // @@protoc_insertion_point(global_scope)
1298 #include <google/protobuf/port_undef.inc>
1299