1 // Generated by the protocol buffer compiler. DO NOT EDIT!
2 // source: icing/proto/blob.proto
3
4 #ifndef GOOGLE_PROTOBUF_INCLUDED_icing_2fproto_2fblob_2eproto
5 #define GOOGLE_PROTOBUF_INCLUDED_icing_2fproto_2fblob_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 "icing/proto/document.pb.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_2fblob_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_2fblob_2eproto {
45 static const ::uint32_t offsets[];
46 };
47 namespace icing {
48 namespace lib {
49 class BlobInfoProto;
50 struct BlobInfoProtoDefaultTypeInternal;
51 extern BlobInfoProtoDefaultTypeInternal _BlobInfoProto_default_instance_;
52 class BlobProto;
53 struct BlobProtoDefaultTypeInternal;
54 extern BlobProtoDefaultTypeInternal _BlobProto_default_instance_;
55 } // namespace lib
56 } // namespace icing
57 PROTOBUF_NAMESPACE_OPEN
58 template<> ::icing::lib::BlobInfoProto* Arena::CreateMaybeMessage<::icing::lib::BlobInfoProto>(Arena*);
59 template<> ::icing::lib::BlobProto* Arena::CreateMaybeMessage<::icing::lib::BlobProto>(Arena*);
60 PROTOBUF_NAMESPACE_CLOSE
61 namespace icing {
62 namespace lib {
63
64 // ===================================================================
65
66 class BlobProto final :
67 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:icing.lib.BlobProto) */ {
68 public:
BlobProto()69 inline BlobProto() : BlobProto(nullptr) {}
70 ~BlobProto() override;
71 explicit PROTOBUF_CONSTEXPR BlobProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
72
73 BlobProto(const BlobProto& from);
BlobProto(BlobProto && from)74 BlobProto(BlobProto&& from) noexcept
75 : BlobProto() {
76 *this = ::std::move(from);
77 }
78
79 inline BlobProto& operator=(const BlobProto& from) {
80 if (this == &from) return *this;
81 CopyFrom(from);
82 return *this;
83 }
84 inline BlobProto& operator=(BlobProto&& from) noexcept {
85 if (this == &from) return *this;
86 if (GetOwningArena() == from.GetOwningArena()
87 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
88 && GetOwningArena() != nullptr
89 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
90 ) {
91 InternalSwap(&from);
92 } else {
93 CopyFrom(from);
94 }
95 return *this;
96 }
97
unknown_fields()98 inline const std::string& unknown_fields() const {
99 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
100 }
mutable_unknown_fields()101 inline std::string* mutable_unknown_fields() {
102 return _internal_metadata_.mutable_unknown_fields<std::string>();
103 }
104
default_instance()105 static const BlobProto& default_instance() {
106 return *internal_default_instance();
107 }
internal_default_instance()108 static inline const BlobProto* internal_default_instance() {
109 return reinterpret_cast<const BlobProto*>(
110 &_BlobProto_default_instance_);
111 }
112 static constexpr int kIndexInFileMessages =
113 0;
114
swap(BlobProto & a,BlobProto & b)115 friend void swap(BlobProto& a, BlobProto& b) {
116 a.Swap(&b);
117 }
Swap(BlobProto * other)118 inline void Swap(BlobProto* other) {
119 if (other == this) return;
120 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
121 if (GetOwningArena() != nullptr &&
122 GetOwningArena() == other->GetOwningArena()) {
123 #else // PROTOBUF_FORCE_COPY_IN_SWAP
124 if (GetOwningArena() == other->GetOwningArena()) {
125 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
126 InternalSwap(other);
127 } else {
128 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
129 }
130 }
131 void UnsafeArenaSwap(BlobProto* other) {
132 if (other == this) return;
133 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
134 InternalSwap(other);
135 }
136
137 // implements Message ----------------------------------------------
138
139 BlobProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
140 return CreateMaybeMessage<BlobProto>(arena);
141 }
142 BlobProto* New() const {
143 return New(nullptr);
144 }
145 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
146 void CopyFrom(const BlobProto& from);
147 void MergeFrom(const BlobProto& from);
148 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
149 bool IsInitialized() const final;
150
151 size_t ByteSizeLong() const final;
152 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
153 ::uint8_t* _InternalSerialize(
154 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
155 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
156
157 private:
158 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
159 void SharedDtor();
160 void SetCachedSize(int size) const;
161 void InternalSwap(BlobProto* other);
162
163 private:
164 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
165 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
166 return "icing.lib.BlobProto";
167 }
168 protected:
169 explicit BlobProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
170 bool is_message_owned = false);
171 public:
172
173 std::string GetTypeName() const final;
174
175 // nested types ----------------------------------------------------
176
177 // accessors -------------------------------------------------------
178
179 enum : int {
180 kStatusFieldNumber = 1,
181 kFileDescriptorFieldNumber = 2,
182 };
183 // optional .icing.lib.StatusProto status = 1;
184 bool has_status() const;
185 private:
186 bool _internal_has_status() const;
187 public:
188 void clear_status();
189 const ::icing::lib::StatusProto& status() const;
190 PROTOBUF_NODISCARD ::icing::lib::StatusProto* release_status();
191 ::icing::lib::StatusProto* mutable_status();
192 void set_allocated_status(::icing::lib::StatusProto* status);
193 private:
194 const ::icing::lib::StatusProto& _internal_status() const;
195 ::icing::lib::StatusProto* _internal_mutable_status();
196 public:
197 void unsafe_arena_set_allocated_status(
198 ::icing::lib::StatusProto* status);
199 ::icing::lib::StatusProto* unsafe_arena_release_status();
200
201 // optional int32 file_descriptor = 2;
202 bool has_file_descriptor() const;
203 private:
204 bool _internal_has_file_descriptor() const;
205 public:
206 void clear_file_descriptor();
207 ::int32_t file_descriptor() const;
208 void set_file_descriptor(::int32_t value);
209 private:
210 ::int32_t _internal_file_descriptor() const;
211 void _internal_set_file_descriptor(::int32_t value);
212 public:
213
214 // @@protoc_insertion_point(class_scope:icing.lib.BlobProto)
215 private:
216 class _Internal;
217
218 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
219 typedef void InternalArenaConstructable_;
220 typedef void DestructorSkippable_;
221 struct Impl_ {
222 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
223 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
224 ::icing::lib::StatusProto* status_;
225 ::int32_t file_descriptor_;
226 };
227 union { Impl_ _impl_; };
228 friend struct ::TableStruct_icing_2fproto_2fblob_2eproto;
229 };
230 // -------------------------------------------------------------------
231
232 class BlobInfoProto final :
233 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:icing.lib.BlobInfoProto) */ {
234 public:
BlobInfoProto()235 inline BlobInfoProto() : BlobInfoProto(nullptr) {}
236 ~BlobInfoProto() override;
237 explicit PROTOBUF_CONSTEXPR BlobInfoProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
238
239 BlobInfoProto(const BlobInfoProto& from);
BlobInfoProto(BlobInfoProto && from)240 BlobInfoProto(BlobInfoProto&& from) noexcept
241 : BlobInfoProto() {
242 *this = ::std::move(from);
243 }
244
245 inline BlobInfoProto& operator=(const BlobInfoProto& from) {
246 if (this == &from) return *this;
247 CopyFrom(from);
248 return *this;
249 }
250 inline BlobInfoProto& operator=(BlobInfoProto&& from) noexcept {
251 if (this == &from) return *this;
252 if (GetOwningArena() == from.GetOwningArena()
253 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
254 && GetOwningArena() != nullptr
255 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
256 ) {
257 InternalSwap(&from);
258 } else {
259 CopyFrom(from);
260 }
261 return *this;
262 }
263
unknown_fields()264 inline const std::string& unknown_fields() const {
265 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
266 }
mutable_unknown_fields()267 inline std::string* mutable_unknown_fields() {
268 return _internal_metadata_.mutable_unknown_fields<std::string>();
269 }
270
default_instance()271 static const BlobInfoProto& default_instance() {
272 return *internal_default_instance();
273 }
internal_default_instance()274 static inline const BlobInfoProto* internal_default_instance() {
275 return reinterpret_cast<const BlobInfoProto*>(
276 &_BlobInfoProto_default_instance_);
277 }
278 static constexpr int kIndexInFileMessages =
279 1;
280
swap(BlobInfoProto & a,BlobInfoProto & b)281 friend void swap(BlobInfoProto& a, BlobInfoProto& b) {
282 a.Swap(&b);
283 }
Swap(BlobInfoProto * other)284 inline void Swap(BlobInfoProto* other) {
285 if (other == this) return;
286 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
287 if (GetOwningArena() != nullptr &&
288 GetOwningArena() == other->GetOwningArena()) {
289 #else // PROTOBUF_FORCE_COPY_IN_SWAP
290 if (GetOwningArena() == other->GetOwningArena()) {
291 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
292 InternalSwap(other);
293 } else {
294 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
295 }
296 }
297 void UnsafeArenaSwap(BlobInfoProto* other) {
298 if (other == this) return;
299 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
300 InternalSwap(other);
301 }
302
303 // implements Message ----------------------------------------------
304
305 BlobInfoProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
306 return CreateMaybeMessage<BlobInfoProto>(arena);
307 }
308 BlobInfoProto* New() const {
309 return New(nullptr);
310 }
311 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
312 void CopyFrom(const BlobInfoProto& from);
313 void MergeFrom(const BlobInfoProto& from);
314 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
315 bool IsInitialized() const final;
316
317 size_t ByteSizeLong() const final;
318 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
319 ::uint8_t* _InternalSerialize(
320 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
321 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
322
323 private:
324 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
325 void SharedDtor();
326 void SetCachedSize(int size) const;
327 void InternalSwap(BlobInfoProto* other);
328
329 private:
330 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
331 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
332 return "icing.lib.BlobInfoProto";
333 }
334 protected:
335 explicit BlobInfoProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
336 bool is_message_owned = false);
337 public:
338
339 std::string GetTypeName() const final;
340
341 // nested types ----------------------------------------------------
342
343 // accessors -------------------------------------------------------
344
345 enum : int {
346 kBlobHandleFieldNumber = 1,
347 kCreationTimeMsFieldNumber = 2,
348 kIsCommittedFieldNumber = 3,
349 };
350 // optional .icing.lib.PropertyProto.BlobHandleProto blob_handle = 1;
351 bool has_blob_handle() const;
352 private:
353 bool _internal_has_blob_handle() const;
354 public:
355 void clear_blob_handle();
356 const ::icing::lib::PropertyProto_BlobHandleProto& blob_handle() const;
357 PROTOBUF_NODISCARD ::icing::lib::PropertyProto_BlobHandleProto* release_blob_handle();
358 ::icing::lib::PropertyProto_BlobHandleProto* mutable_blob_handle();
359 void set_allocated_blob_handle(::icing::lib::PropertyProto_BlobHandleProto* blob_handle);
360 private:
361 const ::icing::lib::PropertyProto_BlobHandleProto& _internal_blob_handle() const;
362 ::icing::lib::PropertyProto_BlobHandleProto* _internal_mutable_blob_handle();
363 public:
364 void unsafe_arena_set_allocated_blob_handle(
365 ::icing::lib::PropertyProto_BlobHandleProto* blob_handle);
366 ::icing::lib::PropertyProto_BlobHandleProto* unsafe_arena_release_blob_handle();
367
368 // optional int64 creation_time_ms = 2;
369 bool has_creation_time_ms() const;
370 private:
371 bool _internal_has_creation_time_ms() const;
372 public:
373 void clear_creation_time_ms();
374 ::int64_t creation_time_ms() const;
375 void set_creation_time_ms(::int64_t value);
376 private:
377 ::int64_t _internal_creation_time_ms() const;
378 void _internal_set_creation_time_ms(::int64_t value);
379 public:
380
381 // optional bool is_committed = 3;
382 bool has_is_committed() const;
383 private:
384 bool _internal_has_is_committed() const;
385 public:
386 void clear_is_committed();
387 bool is_committed() const;
388 void set_is_committed(bool value);
389 private:
390 bool _internal_is_committed() const;
391 void _internal_set_is_committed(bool value);
392 public:
393
394 // @@protoc_insertion_point(class_scope:icing.lib.BlobInfoProto)
395 private:
396 class _Internal;
397
398 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
399 typedef void InternalArenaConstructable_;
400 typedef void DestructorSkippable_;
401 struct Impl_ {
402 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
403 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
404 ::icing::lib::PropertyProto_BlobHandleProto* blob_handle_;
405 ::int64_t creation_time_ms_;
406 bool is_committed_;
407 };
408 union { Impl_ _impl_; };
409 friend struct ::TableStruct_icing_2fproto_2fblob_2eproto;
410 };
411 // ===================================================================
412
413
414 // ===================================================================
415
416 #ifdef __GNUC__
417 #pragma GCC diagnostic push
418 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
419 #endif // __GNUC__
420 // BlobProto
421
422 // optional .icing.lib.StatusProto status = 1;
_internal_has_status()423 inline bool BlobProto::_internal_has_status() const {
424 bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
425 PROTOBUF_ASSUME(!value || _impl_.status_ != nullptr);
426 return value;
427 }
has_status()428 inline bool BlobProto::has_status() const {
429 return _internal_has_status();
430 }
_internal_status()431 inline const ::icing::lib::StatusProto& BlobProto::_internal_status() const {
432 const ::icing::lib::StatusProto* p = _impl_.status_;
433 return p != nullptr ? *p : reinterpret_cast<const ::icing::lib::StatusProto&>(
434 ::icing::lib::_StatusProto_default_instance_);
435 }
status()436 inline const ::icing::lib::StatusProto& BlobProto::status() const {
437 // @@protoc_insertion_point(field_get:icing.lib.BlobProto.status)
438 return _internal_status();
439 }
unsafe_arena_set_allocated_status(::icing::lib::StatusProto * status)440 inline void BlobProto::unsafe_arena_set_allocated_status(
441 ::icing::lib::StatusProto* status) {
442 if (GetArenaForAllocation() == nullptr) {
443 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.status_);
444 }
445 _impl_.status_ = status;
446 if (status) {
447 _impl_._has_bits_[0] |= 0x00000001u;
448 } else {
449 _impl_._has_bits_[0] &= ~0x00000001u;
450 }
451 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:icing.lib.BlobProto.status)
452 }
release_status()453 inline ::icing::lib::StatusProto* BlobProto::release_status() {
454 _impl_._has_bits_[0] &= ~0x00000001u;
455 ::icing::lib::StatusProto* temp = _impl_.status_;
456 _impl_.status_ = nullptr;
457 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
458 auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
459 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
460 if (GetArenaForAllocation() == nullptr) { delete old; }
461 #else // PROTOBUF_FORCE_COPY_IN_RELEASE
462 if (GetArenaForAllocation() != nullptr) {
463 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
464 }
465 #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
466 return temp;
467 }
unsafe_arena_release_status()468 inline ::icing::lib::StatusProto* BlobProto::unsafe_arena_release_status() {
469 // @@protoc_insertion_point(field_release:icing.lib.BlobProto.status)
470 _impl_._has_bits_[0] &= ~0x00000001u;
471 ::icing::lib::StatusProto* temp = _impl_.status_;
472 _impl_.status_ = nullptr;
473 return temp;
474 }
_internal_mutable_status()475 inline ::icing::lib::StatusProto* BlobProto::_internal_mutable_status() {
476 _impl_._has_bits_[0] |= 0x00000001u;
477 if (_impl_.status_ == nullptr) {
478 auto* p = CreateMaybeMessage<::icing::lib::StatusProto>(GetArenaForAllocation());
479 _impl_.status_ = p;
480 }
481 return _impl_.status_;
482 }
mutable_status()483 inline ::icing::lib::StatusProto* BlobProto::mutable_status() {
484 ::icing::lib::StatusProto* _msg = _internal_mutable_status();
485 // @@protoc_insertion_point(field_mutable:icing.lib.BlobProto.status)
486 return _msg;
487 }
set_allocated_status(::icing::lib::StatusProto * status)488 inline void BlobProto::set_allocated_status(::icing::lib::StatusProto* status) {
489 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
490 if (message_arena == nullptr) {
491 delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.status_);
492 }
493 if (status) {
494 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
495 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
496 reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(status));
497 if (message_arena != submessage_arena) {
498 status = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
499 message_arena, status, submessage_arena);
500 }
501 _impl_._has_bits_[0] |= 0x00000001u;
502 } else {
503 _impl_._has_bits_[0] &= ~0x00000001u;
504 }
505 _impl_.status_ = status;
506 // @@protoc_insertion_point(field_set_allocated:icing.lib.BlobProto.status)
507 }
508
509 // optional int32 file_descriptor = 2;
_internal_has_file_descriptor()510 inline bool BlobProto::_internal_has_file_descriptor() const {
511 bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
512 return value;
513 }
has_file_descriptor()514 inline bool BlobProto::has_file_descriptor() const {
515 return _internal_has_file_descriptor();
516 }
clear_file_descriptor()517 inline void BlobProto::clear_file_descriptor() {
518 _impl_.file_descriptor_ = 0;
519 _impl_._has_bits_[0] &= ~0x00000002u;
520 }
_internal_file_descriptor()521 inline ::int32_t BlobProto::_internal_file_descriptor() const {
522 return _impl_.file_descriptor_;
523 }
file_descriptor()524 inline ::int32_t BlobProto::file_descriptor() const {
525 // @@protoc_insertion_point(field_get:icing.lib.BlobProto.file_descriptor)
526 return _internal_file_descriptor();
527 }
_internal_set_file_descriptor(::int32_t value)528 inline void BlobProto::_internal_set_file_descriptor(::int32_t value) {
529 _impl_._has_bits_[0] |= 0x00000002u;
530 _impl_.file_descriptor_ = value;
531 }
set_file_descriptor(::int32_t value)532 inline void BlobProto::set_file_descriptor(::int32_t value) {
533 _internal_set_file_descriptor(value);
534 // @@protoc_insertion_point(field_set:icing.lib.BlobProto.file_descriptor)
535 }
536
537 // -------------------------------------------------------------------
538
539 // BlobInfoProto
540
541 // optional .icing.lib.PropertyProto.BlobHandleProto blob_handle = 1;
_internal_has_blob_handle()542 inline bool BlobInfoProto::_internal_has_blob_handle() const {
543 bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
544 PROTOBUF_ASSUME(!value || _impl_.blob_handle_ != nullptr);
545 return value;
546 }
has_blob_handle()547 inline bool BlobInfoProto::has_blob_handle() const {
548 return _internal_has_blob_handle();
549 }
_internal_blob_handle()550 inline const ::icing::lib::PropertyProto_BlobHandleProto& BlobInfoProto::_internal_blob_handle() const {
551 const ::icing::lib::PropertyProto_BlobHandleProto* p = _impl_.blob_handle_;
552 return p != nullptr ? *p : reinterpret_cast<const ::icing::lib::PropertyProto_BlobHandleProto&>(
553 ::icing::lib::_PropertyProto_BlobHandleProto_default_instance_);
554 }
blob_handle()555 inline const ::icing::lib::PropertyProto_BlobHandleProto& BlobInfoProto::blob_handle() const {
556 // @@protoc_insertion_point(field_get:icing.lib.BlobInfoProto.blob_handle)
557 return _internal_blob_handle();
558 }
unsafe_arena_set_allocated_blob_handle(::icing::lib::PropertyProto_BlobHandleProto * blob_handle)559 inline void BlobInfoProto::unsafe_arena_set_allocated_blob_handle(
560 ::icing::lib::PropertyProto_BlobHandleProto* blob_handle) {
561 if (GetArenaForAllocation() == nullptr) {
562 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.blob_handle_);
563 }
564 _impl_.blob_handle_ = blob_handle;
565 if (blob_handle) {
566 _impl_._has_bits_[0] |= 0x00000001u;
567 } else {
568 _impl_._has_bits_[0] &= ~0x00000001u;
569 }
570 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:icing.lib.BlobInfoProto.blob_handle)
571 }
release_blob_handle()572 inline ::icing::lib::PropertyProto_BlobHandleProto* BlobInfoProto::release_blob_handle() {
573 _impl_._has_bits_[0] &= ~0x00000001u;
574 ::icing::lib::PropertyProto_BlobHandleProto* temp = _impl_.blob_handle_;
575 _impl_.blob_handle_ = nullptr;
576 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
577 auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
578 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
579 if (GetArenaForAllocation() == nullptr) { delete old; }
580 #else // PROTOBUF_FORCE_COPY_IN_RELEASE
581 if (GetArenaForAllocation() != nullptr) {
582 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
583 }
584 #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
585 return temp;
586 }
unsafe_arena_release_blob_handle()587 inline ::icing::lib::PropertyProto_BlobHandleProto* BlobInfoProto::unsafe_arena_release_blob_handle() {
588 // @@protoc_insertion_point(field_release:icing.lib.BlobInfoProto.blob_handle)
589 _impl_._has_bits_[0] &= ~0x00000001u;
590 ::icing::lib::PropertyProto_BlobHandleProto* temp = _impl_.blob_handle_;
591 _impl_.blob_handle_ = nullptr;
592 return temp;
593 }
_internal_mutable_blob_handle()594 inline ::icing::lib::PropertyProto_BlobHandleProto* BlobInfoProto::_internal_mutable_blob_handle() {
595 _impl_._has_bits_[0] |= 0x00000001u;
596 if (_impl_.blob_handle_ == nullptr) {
597 auto* p = CreateMaybeMessage<::icing::lib::PropertyProto_BlobHandleProto>(GetArenaForAllocation());
598 _impl_.blob_handle_ = p;
599 }
600 return _impl_.blob_handle_;
601 }
mutable_blob_handle()602 inline ::icing::lib::PropertyProto_BlobHandleProto* BlobInfoProto::mutable_blob_handle() {
603 ::icing::lib::PropertyProto_BlobHandleProto* _msg = _internal_mutable_blob_handle();
604 // @@protoc_insertion_point(field_mutable:icing.lib.BlobInfoProto.blob_handle)
605 return _msg;
606 }
set_allocated_blob_handle(::icing::lib::PropertyProto_BlobHandleProto * blob_handle)607 inline void BlobInfoProto::set_allocated_blob_handle(::icing::lib::PropertyProto_BlobHandleProto* blob_handle) {
608 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
609 if (message_arena == nullptr) {
610 delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.blob_handle_);
611 }
612 if (blob_handle) {
613 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
614 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
615 reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(blob_handle));
616 if (message_arena != submessage_arena) {
617 blob_handle = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
618 message_arena, blob_handle, submessage_arena);
619 }
620 _impl_._has_bits_[0] |= 0x00000001u;
621 } else {
622 _impl_._has_bits_[0] &= ~0x00000001u;
623 }
624 _impl_.blob_handle_ = blob_handle;
625 // @@protoc_insertion_point(field_set_allocated:icing.lib.BlobInfoProto.blob_handle)
626 }
627
628 // optional int64 creation_time_ms = 2;
_internal_has_creation_time_ms()629 inline bool BlobInfoProto::_internal_has_creation_time_ms() const {
630 bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
631 return value;
632 }
has_creation_time_ms()633 inline bool BlobInfoProto::has_creation_time_ms() const {
634 return _internal_has_creation_time_ms();
635 }
clear_creation_time_ms()636 inline void BlobInfoProto::clear_creation_time_ms() {
637 _impl_.creation_time_ms_ = ::int64_t{0};
638 _impl_._has_bits_[0] &= ~0x00000002u;
639 }
_internal_creation_time_ms()640 inline ::int64_t BlobInfoProto::_internal_creation_time_ms() const {
641 return _impl_.creation_time_ms_;
642 }
creation_time_ms()643 inline ::int64_t BlobInfoProto::creation_time_ms() const {
644 // @@protoc_insertion_point(field_get:icing.lib.BlobInfoProto.creation_time_ms)
645 return _internal_creation_time_ms();
646 }
_internal_set_creation_time_ms(::int64_t value)647 inline void BlobInfoProto::_internal_set_creation_time_ms(::int64_t value) {
648 _impl_._has_bits_[0] |= 0x00000002u;
649 _impl_.creation_time_ms_ = value;
650 }
set_creation_time_ms(::int64_t value)651 inline void BlobInfoProto::set_creation_time_ms(::int64_t value) {
652 _internal_set_creation_time_ms(value);
653 // @@protoc_insertion_point(field_set:icing.lib.BlobInfoProto.creation_time_ms)
654 }
655
656 // optional bool is_committed = 3;
_internal_has_is_committed()657 inline bool BlobInfoProto::_internal_has_is_committed() const {
658 bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
659 return value;
660 }
has_is_committed()661 inline bool BlobInfoProto::has_is_committed() const {
662 return _internal_has_is_committed();
663 }
clear_is_committed()664 inline void BlobInfoProto::clear_is_committed() {
665 _impl_.is_committed_ = false;
666 _impl_._has_bits_[0] &= ~0x00000004u;
667 }
_internal_is_committed()668 inline bool BlobInfoProto::_internal_is_committed() const {
669 return _impl_.is_committed_;
670 }
is_committed()671 inline bool BlobInfoProto::is_committed() const {
672 // @@protoc_insertion_point(field_get:icing.lib.BlobInfoProto.is_committed)
673 return _internal_is_committed();
674 }
_internal_set_is_committed(bool value)675 inline void BlobInfoProto::_internal_set_is_committed(bool value) {
676 _impl_._has_bits_[0] |= 0x00000004u;
677 _impl_.is_committed_ = value;
678 }
set_is_committed(bool value)679 inline void BlobInfoProto::set_is_committed(bool value) {
680 _internal_set_is_committed(value);
681 // @@protoc_insertion_point(field_set:icing.lib.BlobInfoProto.is_committed)
682 }
683
684 #ifdef __GNUC__
685 #pragma GCC diagnostic pop
686 #endif // __GNUC__
687 // -------------------------------------------------------------------
688
689
690 // @@protoc_insertion_point(namespace_scope)
691
692 } // namespace lib
693 } // namespace icing
694
695 // @@protoc_insertion_point(global_scope)
696
697 #include <google/protobuf/port_undef.inc>
698 #endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_icing_2fproto_2fblob_2eproto
699