1 // Generated by the protocol buffer compiler. DO NOT EDIT!
2 // source: icing/proto/persist.proto
3
4 #ifndef GOOGLE_PROTOBUF_INCLUDED_icing_2fproto_2fpersist_2eproto
5 #define GOOGLE_PROTOBUF_INCLUDED_icing_2fproto_2fpersist_2eproto
6
7 #include <cstdint>
8 #include <limits>
9 #include <string>
10
11 #include <google/protobuf/port_def.inc>
12 #if PROTOBUF_VERSION < 3021000
13 #error This file was generated by a newer version of protoc which is
14 #error incompatible with your Protocol Buffer headers. Please update
15 #error your headers.
16 #endif
17 #if 3021012 < PROTOBUF_MIN_PROTOC_VERSION
18 #error This file was generated by an older version of protoc which is
19 #error incompatible with your Protocol Buffer headers. Please
20 #error regenerate this file with a newer version of protoc.
21 #endif
22
23 #include <google/protobuf/port_undef.inc>
24 #include <google/protobuf/io/coded_stream.h>
25 #include <google/protobuf/arena.h>
26 #include <google/protobuf/arenastring.h>
27 #include <google/protobuf/generated_message_util.h>
28 #include <google/protobuf/metadata_lite.h>
29 #include <google/protobuf/message_lite.h>
30 #include <google/protobuf/repeated_field.h> // IWYU pragma: export
31 #include <google/protobuf/extension_set.h> // IWYU pragma: export
32 #include <google/protobuf/generated_enum_util.h>
33 #include "icing/proto/status.pb.h"
34 // @@protoc_insertion_point(includes)
35 #include <google/protobuf/port_def.inc>
36 #define PROTOBUF_INTERNAL_EXPORT_icing_2fproto_2fpersist_2eproto
37 PROTOBUF_NAMESPACE_OPEN
38 namespace internal {
39 class AnyMetadata;
40 } // namespace internal
41 PROTOBUF_NAMESPACE_CLOSE
42
43 // Internal implementation detail -- do not use these members.
44 struct TableStruct_icing_2fproto_2fpersist_2eproto {
45 static const ::uint32_t offsets[];
46 };
47 namespace icing {
48 namespace lib {
49 class PersistToDiskResultProto;
50 struct PersistToDiskResultProtoDefaultTypeInternal;
51 extern PersistToDiskResultProtoDefaultTypeInternal _PersistToDiskResultProto_default_instance_;
52 class PersistType;
53 struct PersistTypeDefaultTypeInternal;
54 extern PersistTypeDefaultTypeInternal _PersistType_default_instance_;
55 } // namespace lib
56 } // namespace icing
57 PROTOBUF_NAMESPACE_OPEN
58 template<> ::icing::lib::PersistToDiskResultProto* Arena::CreateMaybeMessage<::icing::lib::PersistToDiskResultProto>(Arena*);
59 template<> ::icing::lib::PersistType* Arena::CreateMaybeMessage<::icing::lib::PersistType>(Arena*);
60 PROTOBUF_NAMESPACE_CLOSE
61 namespace icing {
62 namespace lib {
63
64 enum PersistType_Code : int {
65 PersistType_Code_UNKNOWN = 0,
66 PersistType_Code_LITE = 1,
67 PersistType_Code_FULL = 2,
68 PersistType_Code_RECOVERY_PROOF = 3
69 };
70 bool PersistType_Code_IsValid(int value);
71 constexpr PersistType_Code PersistType_Code_Code_MIN = PersistType_Code_UNKNOWN;
72 constexpr PersistType_Code PersistType_Code_Code_MAX = PersistType_Code_RECOVERY_PROOF;
73 constexpr int PersistType_Code_Code_ARRAYSIZE = PersistType_Code_Code_MAX + 1;
74
75 const std::string& PersistType_Code_Name(PersistType_Code value);
76 template<typename T>
PersistType_Code_Name(T enum_t_value)77 inline const std::string& PersistType_Code_Name(T enum_t_value) {
78 static_assert(::std::is_same<T, PersistType_Code>::value ||
79 ::std::is_integral<T>::value,
80 "Incorrect type passed to function PersistType_Code_Name.");
81 return PersistType_Code_Name(static_cast<PersistType_Code>(enum_t_value));
82 }
83 bool PersistType_Code_Parse(
84 ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PersistType_Code* value);
85 // ===================================================================
86
87 class PersistType final :
88 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:icing.lib.PersistType) */ {
89 public:
PersistType()90 inline PersistType() : PersistType(nullptr) {}
91 ~PersistType() override;
92 explicit PROTOBUF_CONSTEXPR PersistType(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
93
94 PersistType(const PersistType& from);
PersistType(PersistType && from)95 PersistType(PersistType&& from) noexcept
96 : PersistType() {
97 *this = ::std::move(from);
98 }
99
100 inline PersistType& operator=(const PersistType& from) {
101 if (this == &from) return *this;
102 CopyFrom(from);
103 return *this;
104 }
105 inline PersistType& operator=(PersistType&& from) noexcept {
106 if (this == &from) return *this;
107 if (GetOwningArena() == from.GetOwningArena()
108 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
109 && GetOwningArena() != nullptr
110 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
111 ) {
112 InternalSwap(&from);
113 } else {
114 CopyFrom(from);
115 }
116 return *this;
117 }
118
unknown_fields()119 inline const std::string& unknown_fields() const {
120 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
121 }
mutable_unknown_fields()122 inline std::string* mutable_unknown_fields() {
123 return _internal_metadata_.mutable_unknown_fields<std::string>();
124 }
125
default_instance()126 static const PersistType& default_instance() {
127 return *internal_default_instance();
128 }
internal_default_instance()129 static inline const PersistType* internal_default_instance() {
130 return reinterpret_cast<const PersistType*>(
131 &_PersistType_default_instance_);
132 }
133 static constexpr int kIndexInFileMessages =
134 0;
135
swap(PersistType & a,PersistType & b)136 friend void swap(PersistType& a, PersistType& b) {
137 a.Swap(&b);
138 }
Swap(PersistType * other)139 inline void Swap(PersistType* other) {
140 if (other == this) return;
141 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
142 if (GetOwningArena() != nullptr &&
143 GetOwningArena() == other->GetOwningArena()) {
144 #else // PROTOBUF_FORCE_COPY_IN_SWAP
145 if (GetOwningArena() == other->GetOwningArena()) {
146 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
147 InternalSwap(other);
148 } else {
149 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
150 }
151 }
152 void UnsafeArenaSwap(PersistType* other) {
153 if (other == this) return;
154 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
155 InternalSwap(other);
156 }
157
158 // implements Message ----------------------------------------------
159
160 PersistType* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
161 return CreateMaybeMessage<PersistType>(arena);
162 }
163 PersistType* New() const {
164 return New(nullptr);
165 }
166 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
167 void CopyFrom(const PersistType& from);
168 void MergeFrom(const PersistType& from);
169 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
170 bool IsInitialized() const final;
171
172 size_t ByteSizeLong() const final;
173 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
174 ::uint8_t* _InternalSerialize(
175 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
176 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
177
178 private:
179 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
180 void SharedDtor();
181 void SetCachedSize(int size) const;
182 void InternalSwap(PersistType* other);
183
184 private:
185 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
186 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
187 return "icing.lib.PersistType";
188 }
189 protected:
190 explicit PersistType(::PROTOBUF_NAMESPACE_ID::Arena* arena,
191 bool is_message_owned = false);
192 public:
193
194 std::string GetTypeName() const final;
195
196 // nested types ----------------------------------------------------
197
198 typedef PersistType_Code Code;
199 static constexpr Code UNKNOWN =
200 PersistType_Code_UNKNOWN;
201 static constexpr Code LITE =
202 PersistType_Code_LITE;
203 static constexpr Code FULL =
204 PersistType_Code_FULL;
205 static constexpr Code RECOVERY_PROOF =
206 PersistType_Code_RECOVERY_PROOF;
207 static inline bool Code_IsValid(int value) {
208 return PersistType_Code_IsValid(value);
209 }
210 static constexpr Code Code_MIN =
211 PersistType_Code_Code_MIN;
212 static constexpr Code Code_MAX =
213 PersistType_Code_Code_MAX;
214 static constexpr int Code_ARRAYSIZE =
215 PersistType_Code_Code_ARRAYSIZE;
216 template<typename T>
217 static inline const std::string& Code_Name(T enum_t_value) {
218 static_assert(::std::is_same<T, Code>::value ||
219 ::std::is_integral<T>::value,
220 "Incorrect type passed to function Code_Name.");
221 return PersistType_Code_Name(enum_t_value);
222 }
223 static inline bool Code_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
224 Code* value) {
225 return PersistType_Code_Parse(name, value);
226 }
227
228 // accessors -------------------------------------------------------
229
230 enum : int {
231 kCodeFieldNumber = 1,
232 };
233 // optional .icing.lib.PersistType.Code code = 1;
234 bool has_code() const;
235 private:
236 bool _internal_has_code() const;
237 public:
238 void clear_code();
239 ::icing::lib::PersistType_Code code() const;
240 void set_code(::icing::lib::PersistType_Code value);
241 private:
242 ::icing::lib::PersistType_Code _internal_code() const;
243 void _internal_set_code(::icing::lib::PersistType_Code value);
244 public:
245
246 // @@protoc_insertion_point(class_scope:icing.lib.PersistType)
247 private:
248 class _Internal;
249
250 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
251 typedef void InternalArenaConstructable_;
252 typedef void DestructorSkippable_;
253 struct Impl_ {
254 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
255 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
256 int code_;
257 };
258 union { Impl_ _impl_; };
259 friend struct ::TableStruct_icing_2fproto_2fpersist_2eproto;
260 };
261 // -------------------------------------------------------------------
262
263 class PersistToDiskResultProto final :
264 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:icing.lib.PersistToDiskResultProto) */ {
265 public:
PersistToDiskResultProto()266 inline PersistToDiskResultProto() : PersistToDiskResultProto(nullptr) {}
267 ~PersistToDiskResultProto() override;
268 explicit PROTOBUF_CONSTEXPR PersistToDiskResultProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
269
270 PersistToDiskResultProto(const PersistToDiskResultProto& from);
PersistToDiskResultProto(PersistToDiskResultProto && from)271 PersistToDiskResultProto(PersistToDiskResultProto&& from) noexcept
272 : PersistToDiskResultProto() {
273 *this = ::std::move(from);
274 }
275
276 inline PersistToDiskResultProto& operator=(const PersistToDiskResultProto& from) {
277 if (this == &from) return *this;
278 CopyFrom(from);
279 return *this;
280 }
281 inline PersistToDiskResultProto& operator=(PersistToDiskResultProto&& from) noexcept {
282 if (this == &from) return *this;
283 if (GetOwningArena() == from.GetOwningArena()
284 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
285 && GetOwningArena() != nullptr
286 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
287 ) {
288 InternalSwap(&from);
289 } else {
290 CopyFrom(from);
291 }
292 return *this;
293 }
294
unknown_fields()295 inline const std::string& unknown_fields() const {
296 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
297 }
mutable_unknown_fields()298 inline std::string* mutable_unknown_fields() {
299 return _internal_metadata_.mutable_unknown_fields<std::string>();
300 }
301
default_instance()302 static const PersistToDiskResultProto& default_instance() {
303 return *internal_default_instance();
304 }
internal_default_instance()305 static inline const PersistToDiskResultProto* internal_default_instance() {
306 return reinterpret_cast<const PersistToDiskResultProto*>(
307 &_PersistToDiskResultProto_default_instance_);
308 }
309 static constexpr int kIndexInFileMessages =
310 1;
311
swap(PersistToDiskResultProto & a,PersistToDiskResultProto & b)312 friend void swap(PersistToDiskResultProto& a, PersistToDiskResultProto& b) {
313 a.Swap(&b);
314 }
Swap(PersistToDiskResultProto * other)315 inline void Swap(PersistToDiskResultProto* other) {
316 if (other == this) return;
317 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
318 if (GetOwningArena() != nullptr &&
319 GetOwningArena() == other->GetOwningArena()) {
320 #else // PROTOBUF_FORCE_COPY_IN_SWAP
321 if (GetOwningArena() == other->GetOwningArena()) {
322 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
323 InternalSwap(other);
324 } else {
325 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
326 }
327 }
328 void UnsafeArenaSwap(PersistToDiskResultProto* other) {
329 if (other == this) return;
330 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
331 InternalSwap(other);
332 }
333
334 // implements Message ----------------------------------------------
335
336 PersistToDiskResultProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
337 return CreateMaybeMessage<PersistToDiskResultProto>(arena);
338 }
339 PersistToDiskResultProto* New() const {
340 return New(nullptr);
341 }
342 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
343 void CopyFrom(const PersistToDiskResultProto& from);
344 void MergeFrom(const PersistToDiskResultProto& from);
345 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
346 bool IsInitialized() const final;
347
348 size_t ByteSizeLong() const final;
349 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
350 ::uint8_t* _InternalSerialize(
351 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
352 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
353
354 private:
355 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
356 void SharedDtor();
357 void SetCachedSize(int size) const;
358 void InternalSwap(PersistToDiskResultProto* other);
359
360 private:
361 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
362 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
363 return "icing.lib.PersistToDiskResultProto";
364 }
365 protected:
366 explicit PersistToDiskResultProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
367 bool is_message_owned = false);
368 public:
369
370 std::string GetTypeName() const final;
371
372 // nested types ----------------------------------------------------
373
374 // accessors -------------------------------------------------------
375
376 enum : int {
377 kStatusFieldNumber = 1,
378 };
379 // optional .icing.lib.StatusProto status = 1;
380 bool has_status() const;
381 private:
382 bool _internal_has_status() const;
383 public:
384 void clear_status();
385 const ::icing::lib::StatusProto& status() const;
386 PROTOBUF_NODISCARD ::icing::lib::StatusProto* release_status();
387 ::icing::lib::StatusProto* mutable_status();
388 void set_allocated_status(::icing::lib::StatusProto* status);
389 private:
390 const ::icing::lib::StatusProto& _internal_status() const;
391 ::icing::lib::StatusProto* _internal_mutable_status();
392 public:
393 void unsafe_arena_set_allocated_status(
394 ::icing::lib::StatusProto* status);
395 ::icing::lib::StatusProto* unsafe_arena_release_status();
396
397 // @@protoc_insertion_point(class_scope:icing.lib.PersistToDiskResultProto)
398 private:
399 class _Internal;
400
401 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
402 typedef void InternalArenaConstructable_;
403 typedef void DestructorSkippable_;
404 struct Impl_ {
405 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
406 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
407 ::icing::lib::StatusProto* status_;
408 };
409 union { Impl_ _impl_; };
410 friend struct ::TableStruct_icing_2fproto_2fpersist_2eproto;
411 };
412 // ===================================================================
413
414
415 // ===================================================================
416
417 #ifdef __GNUC__
418 #pragma GCC diagnostic push
419 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
420 #endif // __GNUC__
421 // PersistType
422
423 // optional .icing.lib.PersistType.Code code = 1;
_internal_has_code()424 inline bool PersistType::_internal_has_code() const {
425 bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
426 return value;
427 }
has_code()428 inline bool PersistType::has_code() const {
429 return _internal_has_code();
430 }
clear_code()431 inline void PersistType::clear_code() {
432 _impl_.code_ = 0;
433 _impl_._has_bits_[0] &= ~0x00000001u;
434 }
_internal_code()435 inline ::icing::lib::PersistType_Code PersistType::_internal_code() const {
436 return static_cast< ::icing::lib::PersistType_Code >(_impl_.code_);
437 }
code()438 inline ::icing::lib::PersistType_Code PersistType::code() const {
439 // @@protoc_insertion_point(field_get:icing.lib.PersistType.code)
440 return _internal_code();
441 }
_internal_set_code(::icing::lib::PersistType_Code value)442 inline void PersistType::_internal_set_code(::icing::lib::PersistType_Code value) {
443 assert(::icing::lib::PersistType_Code_IsValid(value));
444 _impl_._has_bits_[0] |= 0x00000001u;
445 _impl_.code_ = value;
446 }
set_code(::icing::lib::PersistType_Code value)447 inline void PersistType::set_code(::icing::lib::PersistType_Code value) {
448 _internal_set_code(value);
449 // @@protoc_insertion_point(field_set:icing.lib.PersistType.code)
450 }
451
452 // -------------------------------------------------------------------
453
454 // PersistToDiskResultProto
455
456 // optional .icing.lib.StatusProto status = 1;
_internal_has_status()457 inline bool PersistToDiskResultProto::_internal_has_status() const {
458 bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
459 PROTOBUF_ASSUME(!value || _impl_.status_ != nullptr);
460 return value;
461 }
has_status()462 inline bool PersistToDiskResultProto::has_status() const {
463 return _internal_has_status();
464 }
_internal_status()465 inline const ::icing::lib::StatusProto& PersistToDiskResultProto::_internal_status() const {
466 const ::icing::lib::StatusProto* p = _impl_.status_;
467 return p != nullptr ? *p : reinterpret_cast<const ::icing::lib::StatusProto&>(
468 ::icing::lib::_StatusProto_default_instance_);
469 }
status()470 inline const ::icing::lib::StatusProto& PersistToDiskResultProto::status() const {
471 // @@protoc_insertion_point(field_get:icing.lib.PersistToDiskResultProto.status)
472 return _internal_status();
473 }
unsafe_arena_set_allocated_status(::icing::lib::StatusProto * status)474 inline void PersistToDiskResultProto::unsafe_arena_set_allocated_status(
475 ::icing::lib::StatusProto* status) {
476 if (GetArenaForAllocation() == nullptr) {
477 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.status_);
478 }
479 _impl_.status_ = status;
480 if (status) {
481 _impl_._has_bits_[0] |= 0x00000001u;
482 } else {
483 _impl_._has_bits_[0] &= ~0x00000001u;
484 }
485 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:icing.lib.PersistToDiskResultProto.status)
486 }
release_status()487 inline ::icing::lib::StatusProto* PersistToDiskResultProto::release_status() {
488 _impl_._has_bits_[0] &= ~0x00000001u;
489 ::icing::lib::StatusProto* temp = _impl_.status_;
490 _impl_.status_ = nullptr;
491 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
492 auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
493 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
494 if (GetArenaForAllocation() == nullptr) { delete old; }
495 #else // PROTOBUF_FORCE_COPY_IN_RELEASE
496 if (GetArenaForAllocation() != nullptr) {
497 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
498 }
499 #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
500 return temp;
501 }
unsafe_arena_release_status()502 inline ::icing::lib::StatusProto* PersistToDiskResultProto::unsafe_arena_release_status() {
503 // @@protoc_insertion_point(field_release:icing.lib.PersistToDiskResultProto.status)
504 _impl_._has_bits_[0] &= ~0x00000001u;
505 ::icing::lib::StatusProto* temp = _impl_.status_;
506 _impl_.status_ = nullptr;
507 return temp;
508 }
_internal_mutable_status()509 inline ::icing::lib::StatusProto* PersistToDiskResultProto::_internal_mutable_status() {
510 _impl_._has_bits_[0] |= 0x00000001u;
511 if (_impl_.status_ == nullptr) {
512 auto* p = CreateMaybeMessage<::icing::lib::StatusProto>(GetArenaForAllocation());
513 _impl_.status_ = p;
514 }
515 return _impl_.status_;
516 }
mutable_status()517 inline ::icing::lib::StatusProto* PersistToDiskResultProto::mutable_status() {
518 ::icing::lib::StatusProto* _msg = _internal_mutable_status();
519 // @@protoc_insertion_point(field_mutable:icing.lib.PersistToDiskResultProto.status)
520 return _msg;
521 }
set_allocated_status(::icing::lib::StatusProto * status)522 inline void PersistToDiskResultProto::set_allocated_status(::icing::lib::StatusProto* status) {
523 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
524 if (message_arena == nullptr) {
525 delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.status_);
526 }
527 if (status) {
528 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
529 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
530 reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(status));
531 if (message_arena != submessage_arena) {
532 status = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
533 message_arena, status, submessage_arena);
534 }
535 _impl_._has_bits_[0] |= 0x00000001u;
536 } else {
537 _impl_._has_bits_[0] &= ~0x00000001u;
538 }
539 _impl_.status_ = status;
540 // @@protoc_insertion_point(field_set_allocated:icing.lib.PersistToDiskResultProto.status)
541 }
542
543 #ifdef __GNUC__
544 #pragma GCC diagnostic pop
545 #endif // __GNUC__
546 // -------------------------------------------------------------------
547
548
549 // @@protoc_insertion_point(namespace_scope)
550
551 } // namespace lib
552 } // namespace icing
553
554 PROTOBUF_NAMESPACE_OPEN
555
556 template <> struct is_proto_enum< ::icing::lib::PersistType_Code> : ::std::true_type {};
557
558 PROTOBUF_NAMESPACE_CLOSE
559
560 // @@protoc_insertion_point(global_scope)
561
562 #include <google/protobuf/port_undef.inc>
563 #endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_icing_2fproto_2fpersist_2eproto
564