1 // Generated by the protocol buffer compiler.  DO NOT EDIT!
2 // source: icing/proto/persist.proto
3 
4 #include "icing/proto/persist.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 {
PersistType(::_pbi::ConstantInitialized)23 PROTOBUF_CONSTEXPR PersistType::PersistType(
24     ::_pbi::ConstantInitialized): _impl_{
25     /*decltype(_impl_._has_bits_)*/{}
26   , /*decltype(_impl_._cached_size_)*/{}
27   , /*decltype(_impl_.code_)*/0} {}
28 struct PersistTypeDefaultTypeInternal {
PersistTypeDefaultTypeInternalicing::lib::PersistTypeDefaultTypeInternal29   PROTOBUF_CONSTEXPR PersistTypeDefaultTypeInternal()
30       : _instance(::_pbi::ConstantInitialized{}) {}
~PersistTypeDefaultTypeInternalicing::lib::PersistTypeDefaultTypeInternal31   ~PersistTypeDefaultTypeInternal() {}
32   union {  // NOLINT(misc-non-private-member-variables-in-classes)
33     PersistType _instance;
34   };
35 };
36 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PersistTypeDefaultTypeInternal _PersistType_default_instance_;
PersistToDiskResultProto(::_pbi::ConstantInitialized)37 PROTOBUF_CONSTEXPR PersistToDiskResultProto::PersistToDiskResultProto(
38     ::_pbi::ConstantInitialized): _impl_{
39     /*decltype(_impl_._has_bits_)*/{}
40   , /*decltype(_impl_._cached_size_)*/{}
41   , /*decltype(_impl_.status_)*/nullptr} {}
42 struct PersistToDiskResultProtoDefaultTypeInternal {
PersistToDiskResultProtoDefaultTypeInternalicing::lib::PersistToDiskResultProtoDefaultTypeInternal43   PROTOBUF_CONSTEXPR PersistToDiskResultProtoDefaultTypeInternal()
44       : _instance(::_pbi::ConstantInitialized{}) {}
~PersistToDiskResultProtoDefaultTypeInternalicing::lib::PersistToDiskResultProtoDefaultTypeInternal45   ~PersistToDiskResultProtoDefaultTypeInternal() {}
46   union {  // NOLINT(misc-non-private-member-variables-in-classes)
47     PersistToDiskResultProto _instance;
48   };
49 };
50 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PersistToDiskResultProtoDefaultTypeInternal _PersistToDiskResultProto_default_instance_;
51 }  // namespace lib
52 }  // namespace icing
53 namespace icing {
54 namespace lib {
PersistType_Code_IsValid(int value)55 bool PersistType_Code_IsValid(int value) {
56   switch (value) {
57     case 0:
58     case 1:
59     case 2:
60     case 3:
61       return true;
62     default:
63       return false;
64   }
65 }
66 
67 static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> PersistType_Code_strings[4] = {};
68 
69 static const char PersistType_Code_names[] =
70   "FULL"
71   "LITE"
72   "RECOVERY_PROOF"
73   "UNKNOWN";
74 
75 static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry PersistType_Code_entries[] = {
76   { {PersistType_Code_names + 0, 4}, 2 },
77   { {PersistType_Code_names + 4, 4}, 1 },
78   { {PersistType_Code_names + 8, 14}, 3 },
79   { {PersistType_Code_names + 22, 7}, 0 },
80 };
81 
82 static const int PersistType_Code_entries_by_number[] = {
83   3, // 0 -> UNKNOWN
84   1, // 1 -> LITE
85   0, // 2 -> FULL
86   2, // 3 -> RECOVERY_PROOF
87 };
88 
PersistType_Code_Name(PersistType_Code value)89 const std::string& PersistType_Code_Name(
90     PersistType_Code value) {
91   static const bool dummy =
92       ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
93           PersistType_Code_entries,
94           PersistType_Code_entries_by_number,
95           4, PersistType_Code_strings);
96   (void) dummy;
97   int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
98       PersistType_Code_entries,
99       PersistType_Code_entries_by_number,
100       4, value);
101   return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
102                      PersistType_Code_strings[idx].get();
103 }
PersistType_Code_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,PersistType_Code * value)104 bool PersistType_Code_Parse(
105     ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PersistType_Code* value) {
106   int int_value;
107   bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
108       PersistType_Code_entries, 4, name, &int_value);
109   if (success) {
110     *value = static_cast<PersistType_Code>(int_value);
111   }
112   return success;
113 }
114 #if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
115 constexpr PersistType_Code PersistType::UNKNOWN;
116 constexpr PersistType_Code PersistType::LITE;
117 constexpr PersistType_Code PersistType::FULL;
118 constexpr PersistType_Code PersistType::RECOVERY_PROOF;
119 constexpr PersistType_Code PersistType::Code_MIN;
120 constexpr PersistType_Code PersistType::Code_MAX;
121 constexpr int PersistType::Code_ARRAYSIZE;
122 #endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
123 
124 // ===================================================================
125 
126 class PersistType::_Internal {
127  public:
128   using HasBits = decltype(std::declval<PersistType>()._impl_._has_bits_);
set_has_code(HasBits * has_bits)129   static void set_has_code(HasBits* has_bits) {
130     (*has_bits)[0] |= 1u;
131   }
132 };
133 
PersistType(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)134 PersistType::PersistType(::PROTOBUF_NAMESPACE_ID::Arena* arena,
135                          bool is_message_owned)
136   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
137   SharedCtor(arena, is_message_owned);
138   // @@protoc_insertion_point(arena_constructor:icing.lib.PersistType)
139 }
PersistType(const PersistType & from)140 PersistType::PersistType(const PersistType& from)
141   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
142   PersistType* const _this = this; (void)_this;
143   new (&_impl_) Impl_{
144       decltype(_impl_._has_bits_){from._impl_._has_bits_}
145     , /*decltype(_impl_._cached_size_)*/{}
146     , decltype(_impl_.code_){}};
147 
148   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
149   _this->_impl_.code_ = from._impl_.code_;
150   // @@protoc_insertion_point(copy_constructor:icing.lib.PersistType)
151 }
152 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)153 inline void PersistType::SharedCtor(
154     ::_pb::Arena* arena, bool is_message_owned) {
155   (void)arena;
156   (void)is_message_owned;
157   new (&_impl_) Impl_{
158       decltype(_impl_._has_bits_){}
159     , /*decltype(_impl_._cached_size_)*/{}
160     , decltype(_impl_.code_){0}
161   };
162 }
163 
~PersistType()164 PersistType::~PersistType() {
165   // @@protoc_insertion_point(destructor:icing.lib.PersistType)
166   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
167   (void)arena;
168     return;
169   }
170   SharedDtor();
171 }
172 
SharedDtor()173 inline void PersistType::SharedDtor() {
174   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
175 }
176 
SetCachedSize(int size) const177 void PersistType::SetCachedSize(int size) const {
178   _impl_._cached_size_.Set(size);
179 }
180 
Clear()181 void PersistType::Clear() {
182 // @@protoc_insertion_point(message_clear_start:icing.lib.PersistType)
183   ::uint32_t cached_has_bits = 0;
184   // Prevent compiler warnings about cached_has_bits being unused
185   (void) cached_has_bits;
186 
187   _impl_.code_ = 0;
188   _impl_._has_bits_.Clear();
189   _internal_metadata_.Clear<std::string>();
190 }
191 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)192 const char* PersistType::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
193 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
194   _Internal::HasBits has_bits{};
195   while (!ctx->Done(&ptr)) {
196     ::uint32_t tag;
197     ptr = ::_pbi::ReadTag(ptr, &tag);
198     switch (tag >> 3) {
199       // optional .icing.lib.PersistType.Code code = 1;
200       case 1:
201         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
202           ::uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
203           CHK_(ptr);
204           if (PROTOBUF_PREDICT_TRUE(::icing::lib::PersistType_Code_IsValid(val))) {
205             _internal_set_code(static_cast<::icing::lib::PersistType_Code>(val));
206           } else {
207             ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
208           }
209         } else {
210           goto handle_unusual;
211         }
212         continue;
213       default:
214         goto handle_unusual;
215     }  // switch
216   handle_unusual:
217     if ((tag == 0) || ((tag & 7) == 4)) {
218       CHK_(ptr);
219       ctx->SetLastTag(tag);
220       goto message_done;
221     }
222     ptr = UnknownFieldParse(
223         tag,
224         _internal_metadata_.mutable_unknown_fields<std::string>(),
225         ptr, ctx);
226     CHK_(ptr != nullptr);
227   }  // while
228 message_done:
229   _impl_._has_bits_.Or(has_bits);
230   return ptr;
231 failure:
232   ptr = nullptr;
233   goto message_done;
234 #undef CHK_
235 }
236 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const237 ::uint8_t* PersistType::_InternalSerialize(
238     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
239   // @@protoc_insertion_point(serialize_to_array_start:icing.lib.PersistType)
240   ::uint32_t cached_has_bits = 0;
241   (void) cached_has_bits;
242 
243   cached_has_bits = _impl_._has_bits_[0];
244   // optional .icing.lib.PersistType.Code code = 1;
245   if (cached_has_bits & 0x00000001u) {
246     target = stream->EnsureSpace(target);
247     target = ::_pbi::WireFormatLite::WriteEnumToArray(
248       1, this->_internal_code(), target);
249   }
250 
251   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
252     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
253         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
254   }
255   // @@protoc_insertion_point(serialize_to_array_end:icing.lib.PersistType)
256   return target;
257 }
258 
ByteSizeLong() const259 size_t PersistType::ByteSizeLong() const {
260 // @@protoc_insertion_point(message_byte_size_start:icing.lib.PersistType)
261   size_t total_size = 0;
262 
263   ::uint32_t cached_has_bits = 0;
264   // Prevent compiler warnings about cached_has_bits being unused
265   (void) cached_has_bits;
266 
267   // optional .icing.lib.PersistType.Code code = 1;
268   cached_has_bits = _impl_._has_bits_[0];
269   if (cached_has_bits & 0x00000001u) {
270     total_size += 1 +
271       ::_pbi::WireFormatLite::EnumSize(this->_internal_code());
272   }
273 
274   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
275     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
276   }
277   int cached_size = ::_pbi::ToCachedSize(total_size);
278   SetCachedSize(cached_size);
279   return total_size;
280 }
281 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)282 void PersistType::CheckTypeAndMergeFrom(
283     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
284   MergeFrom(*::_pbi::DownCast<const PersistType*>(
285       &from));
286 }
287 
MergeFrom(const PersistType & from)288 void PersistType::MergeFrom(const PersistType& from) {
289   PersistType* const _this = this;
290   // @@protoc_insertion_point(class_specific_merge_from_start:icing.lib.PersistType)
291   GOOGLE_DCHECK_NE(&from, _this);
292   ::uint32_t cached_has_bits = 0;
293   (void) cached_has_bits;
294 
295   if (from._internal_has_code()) {
296     _this->_internal_set_code(from._internal_code());
297   }
298   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
299 }
300 
CopyFrom(const PersistType & from)301 void PersistType::CopyFrom(const PersistType& from) {
302 // @@protoc_insertion_point(class_specific_copy_from_start:icing.lib.PersistType)
303   if (&from == this) return;
304   Clear();
305   MergeFrom(from);
306 }
307 
IsInitialized() const308 bool PersistType::IsInitialized() const {
309   return true;
310 }
311 
InternalSwap(PersistType * other)312 void PersistType::InternalSwap(PersistType* other) {
313   using std::swap;
314   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
315   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
316   swap(_impl_.code_, other->_impl_.code_);
317 }
318 
GetTypeName() const319 std::string PersistType::GetTypeName() const {
320   return "icing.lib.PersistType";
321 }
322 
323 
324 // ===================================================================
325 
326 class PersistToDiskResultProto::_Internal {
327  public:
328   using HasBits = decltype(std::declval<PersistToDiskResultProto>()._impl_._has_bits_);
329   static const ::icing::lib::StatusProto& status(const PersistToDiskResultProto* msg);
set_has_status(HasBits * has_bits)330   static void set_has_status(HasBits* has_bits) {
331     (*has_bits)[0] |= 1u;
332   }
333 };
334 
335 const ::icing::lib::StatusProto&
status(const PersistToDiskResultProto * msg)336 PersistToDiskResultProto::_Internal::status(const PersistToDiskResultProto* msg) {
337   return *msg->_impl_.status_;
338 }
clear_status()339 void PersistToDiskResultProto::clear_status() {
340   if (_impl_.status_ != nullptr) _impl_.status_->Clear();
341   _impl_._has_bits_[0] &= ~0x00000001u;
342 }
PersistToDiskResultProto(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)343 PersistToDiskResultProto::PersistToDiskResultProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
344                          bool is_message_owned)
345   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
346   SharedCtor(arena, is_message_owned);
347   // @@protoc_insertion_point(arena_constructor:icing.lib.PersistToDiskResultProto)
348 }
PersistToDiskResultProto(const PersistToDiskResultProto & from)349 PersistToDiskResultProto::PersistToDiskResultProto(const PersistToDiskResultProto& from)
350   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
351   PersistToDiskResultProto* const _this = this; (void)_this;
352   new (&_impl_) Impl_{
353       decltype(_impl_._has_bits_){from._impl_._has_bits_}
354     , /*decltype(_impl_._cached_size_)*/{}
355     , decltype(_impl_.status_){nullptr}};
356 
357   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
358   if (from._internal_has_status()) {
359     _this->_impl_.status_ = new ::icing::lib::StatusProto(*from._impl_.status_);
360   }
361   // @@protoc_insertion_point(copy_constructor:icing.lib.PersistToDiskResultProto)
362 }
363 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)364 inline void PersistToDiskResultProto::SharedCtor(
365     ::_pb::Arena* arena, bool is_message_owned) {
366   (void)arena;
367   (void)is_message_owned;
368   new (&_impl_) Impl_{
369       decltype(_impl_._has_bits_){}
370     , /*decltype(_impl_._cached_size_)*/{}
371     , decltype(_impl_.status_){nullptr}
372   };
373 }
374 
~PersistToDiskResultProto()375 PersistToDiskResultProto::~PersistToDiskResultProto() {
376   // @@protoc_insertion_point(destructor:icing.lib.PersistToDiskResultProto)
377   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
378   (void)arena;
379     return;
380   }
381   SharedDtor();
382 }
383 
SharedDtor()384 inline void PersistToDiskResultProto::SharedDtor() {
385   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
386   if (this != internal_default_instance()) delete _impl_.status_;
387 }
388 
SetCachedSize(int size) const389 void PersistToDiskResultProto::SetCachedSize(int size) const {
390   _impl_._cached_size_.Set(size);
391 }
392 
Clear()393 void PersistToDiskResultProto::Clear() {
394 // @@protoc_insertion_point(message_clear_start:icing.lib.PersistToDiskResultProto)
395   ::uint32_t cached_has_bits = 0;
396   // Prevent compiler warnings about cached_has_bits being unused
397   (void) cached_has_bits;
398 
399   cached_has_bits = _impl_._has_bits_[0];
400   if (cached_has_bits & 0x00000001u) {
401     GOOGLE_DCHECK(_impl_.status_ != nullptr);
402     _impl_.status_->Clear();
403   }
404   _impl_._has_bits_.Clear();
405   _internal_metadata_.Clear<std::string>();
406 }
407 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)408 const char* PersistToDiskResultProto::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
409 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
410   _Internal::HasBits has_bits{};
411   while (!ctx->Done(&ptr)) {
412     ::uint32_t tag;
413     ptr = ::_pbi::ReadTag(ptr, &tag);
414     switch (tag >> 3) {
415       // optional .icing.lib.StatusProto status = 1;
416       case 1:
417         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
418           ptr = ctx->ParseMessage(_internal_mutable_status(), ptr);
419           CHK_(ptr);
420         } else {
421           goto handle_unusual;
422         }
423         continue;
424       default:
425         goto handle_unusual;
426     }  // switch
427   handle_unusual:
428     if ((tag == 0) || ((tag & 7) == 4)) {
429       CHK_(ptr);
430       ctx->SetLastTag(tag);
431       goto message_done;
432     }
433     ptr = UnknownFieldParse(
434         tag,
435         _internal_metadata_.mutable_unknown_fields<std::string>(),
436         ptr, ctx);
437     CHK_(ptr != nullptr);
438   }  // while
439 message_done:
440   _impl_._has_bits_.Or(has_bits);
441   return ptr;
442 failure:
443   ptr = nullptr;
444   goto message_done;
445 #undef CHK_
446 }
447 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const448 ::uint8_t* PersistToDiskResultProto::_InternalSerialize(
449     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
450   // @@protoc_insertion_point(serialize_to_array_start:icing.lib.PersistToDiskResultProto)
451   ::uint32_t cached_has_bits = 0;
452   (void) cached_has_bits;
453 
454   cached_has_bits = _impl_._has_bits_[0];
455   // optional .icing.lib.StatusProto status = 1;
456   if (cached_has_bits & 0x00000001u) {
457     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
458       InternalWriteMessage(1, _Internal::status(this),
459         _Internal::status(this).GetCachedSize(), target, stream);
460   }
461 
462   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
463     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
464         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
465   }
466   // @@protoc_insertion_point(serialize_to_array_end:icing.lib.PersistToDiskResultProto)
467   return target;
468 }
469 
ByteSizeLong() const470 size_t PersistToDiskResultProto::ByteSizeLong() const {
471 // @@protoc_insertion_point(message_byte_size_start:icing.lib.PersistToDiskResultProto)
472   size_t total_size = 0;
473 
474   ::uint32_t cached_has_bits = 0;
475   // Prevent compiler warnings about cached_has_bits being unused
476   (void) cached_has_bits;
477 
478   // optional .icing.lib.StatusProto status = 1;
479   cached_has_bits = _impl_._has_bits_[0];
480   if (cached_has_bits & 0x00000001u) {
481     total_size += 1 +
482       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
483         *_impl_.status_);
484   }
485 
486   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
487     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
488   }
489   int cached_size = ::_pbi::ToCachedSize(total_size);
490   SetCachedSize(cached_size);
491   return total_size;
492 }
493 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)494 void PersistToDiskResultProto::CheckTypeAndMergeFrom(
495     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
496   MergeFrom(*::_pbi::DownCast<const PersistToDiskResultProto*>(
497       &from));
498 }
499 
MergeFrom(const PersistToDiskResultProto & from)500 void PersistToDiskResultProto::MergeFrom(const PersistToDiskResultProto& from) {
501   PersistToDiskResultProto* const _this = this;
502   // @@protoc_insertion_point(class_specific_merge_from_start:icing.lib.PersistToDiskResultProto)
503   GOOGLE_DCHECK_NE(&from, _this);
504   ::uint32_t cached_has_bits = 0;
505   (void) cached_has_bits;
506 
507   if (from._internal_has_status()) {
508     _this->_internal_mutable_status()->::icing::lib::StatusProto::MergeFrom(
509         from._internal_status());
510   }
511   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
512 }
513 
CopyFrom(const PersistToDiskResultProto & from)514 void PersistToDiskResultProto::CopyFrom(const PersistToDiskResultProto& from) {
515 // @@protoc_insertion_point(class_specific_copy_from_start:icing.lib.PersistToDiskResultProto)
516   if (&from == this) return;
517   Clear();
518   MergeFrom(from);
519 }
520 
IsInitialized() const521 bool PersistToDiskResultProto::IsInitialized() const {
522   return true;
523 }
524 
InternalSwap(PersistToDiskResultProto * other)525 void PersistToDiskResultProto::InternalSwap(PersistToDiskResultProto* other) {
526   using std::swap;
527   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
528   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
529   swap(_impl_.status_, other->_impl_.status_);
530 }
531 
GetTypeName() const532 std::string PersistToDiskResultProto::GetTypeName() const {
533   return "icing.lib.PersistToDiskResultProto";
534 }
535 
536 
537 // @@protoc_insertion_point(namespace_scope)
538 }  // namespace lib
539 }  // namespace icing
540 PROTOBUF_NAMESPACE_OPEN
541 template<> PROTOBUF_NOINLINE ::icing::lib::PersistType*
CreateMaybeMessage(Arena * arena)542 Arena::CreateMaybeMessage< ::icing::lib::PersistType >(Arena* arena) {
543   return Arena::CreateMessageInternal< ::icing::lib::PersistType >(arena);
544 }
545 template<> PROTOBUF_NOINLINE ::icing::lib::PersistToDiskResultProto*
CreateMaybeMessage(Arena * arena)546 Arena::CreateMaybeMessage< ::icing::lib::PersistToDiskResultProto >(Arena* arena) {
547   return Arena::CreateMessageInternal< ::icing::lib::PersistToDiskResultProto >(arena);
548 }
549 PROTOBUF_NAMESPACE_CLOSE
550 
551 // @@protoc_insertion_point(global_scope)
552 #include <google/protobuf/port_undef.inc>
553