1 // Generated by the protocol buffer compiler. DO NOT EDIT!
2 // source: ota_metadata.proto
3
4 #ifndef GOOGLE_PROTOBUF_INCLUDED_ota_5fmetadata_2eproto
5 #define GOOGLE_PROTOBUF_INCLUDED_ota_5fmetadata_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/map.h> // IWYU pragma: export
33 #include <google/protobuf/map_entry_lite.h>
34 #include <google/protobuf/map_field_lite.h>
35 #include <google/protobuf/generated_enum_util.h>
36 // @@protoc_insertion_point(includes)
37 #include <google/protobuf/port_def.inc>
38 #define PROTOBUF_INTERNAL_EXPORT_ota_5fmetadata_2eproto
39 PROTOBUF_NAMESPACE_OPEN
40 namespace internal {
41 class AnyMetadata;
42 } // namespace internal
43 PROTOBUF_NAMESPACE_CLOSE
44
45 // Internal implementation detail -- do not use these members.
46 struct TableStruct_ota_5fmetadata_2eproto {
47 static const ::uint32_t offsets[];
48 };
49 namespace build {
50 namespace tools {
51 namespace releasetools {
52 class ApexInfo;
53 struct ApexInfoDefaultTypeInternal;
54 extern ApexInfoDefaultTypeInternal _ApexInfo_default_instance_;
55 class ApexMetadata;
56 struct ApexMetadataDefaultTypeInternal;
57 extern ApexMetadataDefaultTypeInternal _ApexMetadata_default_instance_;
58 class DeviceState;
59 struct DeviceStateDefaultTypeInternal;
60 extern DeviceStateDefaultTypeInternal _DeviceState_default_instance_;
61 class OtaMetadata;
62 struct OtaMetadataDefaultTypeInternal;
63 extern OtaMetadataDefaultTypeInternal _OtaMetadata_default_instance_;
64 class OtaMetadata_PropertyFilesEntry_DoNotUse;
65 struct OtaMetadata_PropertyFilesEntry_DoNotUseDefaultTypeInternal;
66 extern OtaMetadata_PropertyFilesEntry_DoNotUseDefaultTypeInternal _OtaMetadata_PropertyFilesEntry_DoNotUse_default_instance_;
67 class PartitionState;
68 struct PartitionStateDefaultTypeInternal;
69 extern PartitionStateDefaultTypeInternal _PartitionState_default_instance_;
70 } // namespace releasetools
71 } // namespace tools
72 } // namespace build
73 PROTOBUF_NAMESPACE_OPEN
74 template<> ::build::tools::releasetools::ApexInfo* Arena::CreateMaybeMessage<::build::tools::releasetools::ApexInfo>(Arena*);
75 template<> ::build::tools::releasetools::ApexMetadata* Arena::CreateMaybeMessage<::build::tools::releasetools::ApexMetadata>(Arena*);
76 template<> ::build::tools::releasetools::DeviceState* Arena::CreateMaybeMessage<::build::tools::releasetools::DeviceState>(Arena*);
77 template<> ::build::tools::releasetools::OtaMetadata* Arena::CreateMaybeMessage<::build::tools::releasetools::OtaMetadata>(Arena*);
78 template<> ::build::tools::releasetools::OtaMetadata_PropertyFilesEntry_DoNotUse* Arena::CreateMaybeMessage<::build::tools::releasetools::OtaMetadata_PropertyFilesEntry_DoNotUse>(Arena*);
79 template<> ::build::tools::releasetools::PartitionState* Arena::CreateMaybeMessage<::build::tools::releasetools::PartitionState>(Arena*);
80 PROTOBUF_NAMESPACE_CLOSE
81 namespace build {
82 namespace tools {
83 namespace releasetools {
84
85 enum OtaMetadata_OtaType : int {
86 OtaMetadata_OtaType_UNKNOWN = 0,
87 OtaMetadata_OtaType_AB = 1,
88 OtaMetadata_OtaType_BLOCK = 2,
89 OtaMetadata_OtaType_BRICK = 3,
90 OtaMetadata_OtaType_OtaMetadata_OtaType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::int32_t>::min(),
91 OtaMetadata_OtaType_OtaMetadata_OtaType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::int32_t>::max()
92 };
93 bool OtaMetadata_OtaType_IsValid(int value);
94 constexpr OtaMetadata_OtaType OtaMetadata_OtaType_OtaType_MIN = OtaMetadata_OtaType_UNKNOWN;
95 constexpr OtaMetadata_OtaType OtaMetadata_OtaType_OtaType_MAX = OtaMetadata_OtaType_BRICK;
96 constexpr int OtaMetadata_OtaType_OtaType_ARRAYSIZE = OtaMetadata_OtaType_OtaType_MAX + 1;
97
98 const std::string& OtaMetadata_OtaType_Name(OtaMetadata_OtaType value);
99 template<typename T>
OtaMetadata_OtaType_Name(T enum_t_value)100 inline const std::string& OtaMetadata_OtaType_Name(T enum_t_value) {
101 static_assert(::std::is_same<T, OtaMetadata_OtaType>::value ||
102 ::std::is_integral<T>::value,
103 "Incorrect type passed to function OtaMetadata_OtaType_Name.");
104 return OtaMetadata_OtaType_Name(static_cast<OtaMetadata_OtaType>(enum_t_value));
105 }
106 bool OtaMetadata_OtaType_Parse(
107 ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, OtaMetadata_OtaType* value);
108 // ===================================================================
109
110 class PartitionState final :
111 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:build.tools.releasetools.PartitionState) */ {
112 public:
PartitionState()113 inline PartitionState() : PartitionState(nullptr) {}
114 ~PartitionState() override;
115 explicit PROTOBUF_CONSTEXPR PartitionState(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
116
117 PartitionState(const PartitionState& from);
PartitionState(PartitionState && from)118 PartitionState(PartitionState&& from) noexcept
119 : PartitionState() {
120 *this = ::std::move(from);
121 }
122
123 inline PartitionState& operator=(const PartitionState& from) {
124 if (this == &from) return *this;
125 CopyFrom(from);
126 return *this;
127 }
128 inline PartitionState& operator=(PartitionState&& from) noexcept {
129 if (this == &from) return *this;
130 if (GetOwningArena() == from.GetOwningArena()
131 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
132 && GetOwningArena() != nullptr
133 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
134 ) {
135 InternalSwap(&from);
136 } else {
137 CopyFrom(from);
138 }
139 return *this;
140 }
141
default_instance()142 static const PartitionState& default_instance() {
143 return *internal_default_instance();
144 }
internal_default_instance()145 static inline const PartitionState* internal_default_instance() {
146 return reinterpret_cast<const PartitionState*>(
147 &_PartitionState_default_instance_);
148 }
149 static constexpr int kIndexInFileMessages =
150 0;
151
swap(PartitionState & a,PartitionState & b)152 friend void swap(PartitionState& a, PartitionState& b) {
153 a.Swap(&b);
154 }
Swap(PartitionState * other)155 inline void Swap(PartitionState* other) {
156 if (other == this) return;
157 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
158 if (GetOwningArena() != nullptr &&
159 GetOwningArena() == other->GetOwningArena()) {
160 #else // PROTOBUF_FORCE_COPY_IN_SWAP
161 if (GetOwningArena() == other->GetOwningArena()) {
162 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
163 InternalSwap(other);
164 } else {
165 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
166 }
167 }
168 void UnsafeArenaSwap(PartitionState* other) {
169 if (other == this) return;
170 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
171 InternalSwap(other);
172 }
173
174 // implements Message ----------------------------------------------
175
176 PartitionState* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
177 return CreateMaybeMessage<PartitionState>(arena);
178 }
179 PartitionState* New() const {
180 return New(nullptr);
181 }
182 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
183 void CopyFrom(const PartitionState& from);
184 void MergeFrom(const PartitionState& from);
185 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
186 bool IsInitialized() const final;
187
188 size_t ByteSizeLong() const final;
189 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
190 ::uint8_t* _InternalSerialize(
191 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
192 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
193
194 private:
195 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
196 void SharedDtor();
197 void SetCachedSize(int size) const;
198 void InternalSwap(PartitionState* other);
199
200 private:
201 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
202 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
203 return "build.tools.releasetools.PartitionState";
204 }
205 protected:
206 explicit PartitionState(::PROTOBUF_NAMESPACE_ID::Arena* arena,
207 bool is_message_owned = false);
208 public:
209
210 std::string GetTypeName() const final;
211
212 // nested types ----------------------------------------------------
213
214 // accessors -------------------------------------------------------
215
216 enum : int {
217 kDeviceFieldNumber = 2,
218 kBuildFieldNumber = 3,
219 kPartitionNameFieldNumber = 1,
220 kVersionFieldNumber = 4,
221 };
222 // repeated string device = 2;
223 int device_size() const;
224 private:
225 int _internal_device_size() const;
226 public:
227 void clear_device();
228 const std::string& device(int index) const;
229 std::string* mutable_device(int index);
230 void set_device(int index, const std::string& value);
231 void set_device(int index, std::string&& value);
232 void set_device(int index, const char* value);
233 void set_device(int index, const char* value, size_t size);
234 std::string* add_device();
235 void add_device(const std::string& value);
236 void add_device(std::string&& value);
237 void add_device(const char* value);
238 void add_device(const char* value, size_t size);
239 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& device() const;
240 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_device();
241 private:
242 const std::string& _internal_device(int index) const;
243 std::string* _internal_add_device();
244 public:
245
246 // repeated string build = 3;
247 int build_size() const;
248 private:
249 int _internal_build_size() const;
250 public:
251 void clear_build();
252 const std::string& build(int index) const;
253 std::string* mutable_build(int index);
254 void set_build(int index, const std::string& value);
255 void set_build(int index, std::string&& value);
256 void set_build(int index, const char* value);
257 void set_build(int index, const char* value, size_t size);
258 std::string* add_build();
259 void add_build(const std::string& value);
260 void add_build(std::string&& value);
261 void add_build(const char* value);
262 void add_build(const char* value, size_t size);
263 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& build() const;
264 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_build();
265 private:
266 const std::string& _internal_build(int index) const;
267 std::string* _internal_add_build();
268 public:
269
270 // string partition_name = 1;
271 void clear_partition_name();
272 const std::string& partition_name() const;
273 template <typename ArgT0 = const std::string&, typename... ArgT>
274 void set_partition_name(ArgT0&& arg0, ArgT... args);
275 std::string* mutable_partition_name();
276 PROTOBUF_NODISCARD std::string* release_partition_name();
277 void set_allocated_partition_name(std::string* partition_name);
278 private:
279 const std::string& _internal_partition_name() const;
280 inline PROTOBUF_ALWAYS_INLINE void _internal_set_partition_name(const std::string& value);
281 std::string* _internal_mutable_partition_name();
282 public:
283
284 // string version = 4;
285 void clear_version();
286 const std::string& version() const;
287 template <typename ArgT0 = const std::string&, typename... ArgT>
288 void set_version(ArgT0&& arg0, ArgT... args);
289 std::string* mutable_version();
290 PROTOBUF_NODISCARD std::string* release_version();
291 void set_allocated_version(std::string* version);
292 private:
293 const std::string& _internal_version() const;
294 inline PROTOBUF_ALWAYS_INLINE void _internal_set_version(const std::string& value);
295 std::string* _internal_mutable_version();
296 public:
297
298 // @@protoc_insertion_point(class_scope:build.tools.releasetools.PartitionState)
299 private:
300 class _Internal;
301
302 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
303 typedef void InternalArenaConstructable_;
304 typedef void DestructorSkippable_;
305 struct Impl_ {
306 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> device_;
307 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> build_;
308 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr partition_name_;
309 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr version_;
310 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
311 };
312 union { Impl_ _impl_; };
313 friend struct ::TableStruct_ota_5fmetadata_2eproto;
314 };
315 // -------------------------------------------------------------------
316
317 class DeviceState final :
318 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:build.tools.releasetools.DeviceState) */ {
319 public:
DeviceState()320 inline DeviceState() : DeviceState(nullptr) {}
321 ~DeviceState() override;
322 explicit PROTOBUF_CONSTEXPR DeviceState(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
323
324 DeviceState(const DeviceState& from);
DeviceState(DeviceState && from)325 DeviceState(DeviceState&& from) noexcept
326 : DeviceState() {
327 *this = ::std::move(from);
328 }
329
330 inline DeviceState& operator=(const DeviceState& from) {
331 if (this == &from) return *this;
332 CopyFrom(from);
333 return *this;
334 }
335 inline DeviceState& operator=(DeviceState&& from) noexcept {
336 if (this == &from) return *this;
337 if (GetOwningArena() == from.GetOwningArena()
338 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
339 && GetOwningArena() != nullptr
340 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
341 ) {
342 InternalSwap(&from);
343 } else {
344 CopyFrom(from);
345 }
346 return *this;
347 }
348
default_instance()349 static const DeviceState& default_instance() {
350 return *internal_default_instance();
351 }
internal_default_instance()352 static inline const DeviceState* internal_default_instance() {
353 return reinterpret_cast<const DeviceState*>(
354 &_DeviceState_default_instance_);
355 }
356 static constexpr int kIndexInFileMessages =
357 1;
358
swap(DeviceState & a,DeviceState & b)359 friend void swap(DeviceState& a, DeviceState& b) {
360 a.Swap(&b);
361 }
Swap(DeviceState * other)362 inline void Swap(DeviceState* other) {
363 if (other == this) return;
364 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
365 if (GetOwningArena() != nullptr &&
366 GetOwningArena() == other->GetOwningArena()) {
367 #else // PROTOBUF_FORCE_COPY_IN_SWAP
368 if (GetOwningArena() == other->GetOwningArena()) {
369 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
370 InternalSwap(other);
371 } else {
372 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
373 }
374 }
375 void UnsafeArenaSwap(DeviceState* other) {
376 if (other == this) return;
377 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
378 InternalSwap(other);
379 }
380
381 // implements Message ----------------------------------------------
382
383 DeviceState* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
384 return CreateMaybeMessage<DeviceState>(arena);
385 }
386 DeviceState* New() const {
387 return New(nullptr);
388 }
389 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
390 void CopyFrom(const DeviceState& from);
391 void MergeFrom(const DeviceState& from);
392 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
393 bool IsInitialized() const final;
394
395 size_t ByteSizeLong() const final;
396 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
397 ::uint8_t* _InternalSerialize(
398 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
399 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
400
401 private:
402 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
403 void SharedDtor();
404 void SetCachedSize(int size) const;
405 void InternalSwap(DeviceState* other);
406
407 private:
408 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
409 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
410 return "build.tools.releasetools.DeviceState";
411 }
412 protected:
413 explicit DeviceState(::PROTOBUF_NAMESPACE_ID::Arena* arena,
414 bool is_message_owned = false);
415 public:
416
417 std::string GetTypeName() const final;
418
419 // nested types ----------------------------------------------------
420
421 // accessors -------------------------------------------------------
422
423 enum : int {
424 kDeviceFieldNumber = 1,
425 kBuildFieldNumber = 2,
426 kPartitionStateFieldNumber = 7,
427 kBuildIncrementalFieldNumber = 3,
428 kSdkLevelFieldNumber = 5,
429 kSecurityPatchLevelFieldNumber = 6,
430 kTimestampFieldNumber = 4,
431 };
432 // repeated string device = 1;
433 int device_size() const;
434 private:
435 int _internal_device_size() const;
436 public:
437 void clear_device();
438 const std::string& device(int index) const;
439 std::string* mutable_device(int index);
440 void set_device(int index, const std::string& value);
441 void set_device(int index, std::string&& value);
442 void set_device(int index, const char* value);
443 void set_device(int index, const char* value, size_t size);
444 std::string* add_device();
445 void add_device(const std::string& value);
446 void add_device(std::string&& value);
447 void add_device(const char* value);
448 void add_device(const char* value, size_t size);
449 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& device() const;
450 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_device();
451 private:
452 const std::string& _internal_device(int index) const;
453 std::string* _internal_add_device();
454 public:
455
456 // repeated string build = 2;
457 int build_size() const;
458 private:
459 int _internal_build_size() const;
460 public:
461 void clear_build();
462 const std::string& build(int index) const;
463 std::string* mutable_build(int index);
464 void set_build(int index, const std::string& value);
465 void set_build(int index, std::string&& value);
466 void set_build(int index, const char* value);
467 void set_build(int index, const char* value, size_t size);
468 std::string* add_build();
469 void add_build(const std::string& value);
470 void add_build(std::string&& value);
471 void add_build(const char* value);
472 void add_build(const char* value, size_t size);
473 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& build() const;
474 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_build();
475 private:
476 const std::string& _internal_build(int index) const;
477 std::string* _internal_add_build();
478 public:
479
480 // repeated .build.tools.releasetools.PartitionState partition_state = 7;
481 int partition_state_size() const;
482 private:
483 int _internal_partition_state_size() const;
484 public:
485 void clear_partition_state();
486 ::build::tools::releasetools::PartitionState* mutable_partition_state(int index);
487 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::build::tools::releasetools::PartitionState >*
488 mutable_partition_state();
489 private:
490 const ::build::tools::releasetools::PartitionState& _internal_partition_state(int index) const;
491 ::build::tools::releasetools::PartitionState* _internal_add_partition_state();
492 public:
493 const ::build::tools::releasetools::PartitionState& partition_state(int index) const;
494 ::build::tools::releasetools::PartitionState* add_partition_state();
495 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::build::tools::releasetools::PartitionState >&
496 partition_state() const;
497
498 // string build_incremental = 3;
499 void clear_build_incremental();
500 const std::string& build_incremental() const;
501 template <typename ArgT0 = const std::string&, typename... ArgT>
502 void set_build_incremental(ArgT0&& arg0, ArgT... args);
503 std::string* mutable_build_incremental();
504 PROTOBUF_NODISCARD std::string* release_build_incremental();
505 void set_allocated_build_incremental(std::string* build_incremental);
506 private:
507 const std::string& _internal_build_incremental() const;
508 inline PROTOBUF_ALWAYS_INLINE void _internal_set_build_incremental(const std::string& value);
509 std::string* _internal_mutable_build_incremental();
510 public:
511
512 // string sdk_level = 5;
513 void clear_sdk_level();
514 const std::string& sdk_level() const;
515 template <typename ArgT0 = const std::string&, typename... ArgT>
516 void set_sdk_level(ArgT0&& arg0, ArgT... args);
517 std::string* mutable_sdk_level();
518 PROTOBUF_NODISCARD std::string* release_sdk_level();
519 void set_allocated_sdk_level(std::string* sdk_level);
520 private:
521 const std::string& _internal_sdk_level() const;
522 inline PROTOBUF_ALWAYS_INLINE void _internal_set_sdk_level(const std::string& value);
523 std::string* _internal_mutable_sdk_level();
524 public:
525
526 // string security_patch_level = 6;
527 void clear_security_patch_level();
528 const std::string& security_patch_level() const;
529 template <typename ArgT0 = const std::string&, typename... ArgT>
530 void set_security_patch_level(ArgT0&& arg0, ArgT... args);
531 std::string* mutable_security_patch_level();
532 PROTOBUF_NODISCARD std::string* release_security_patch_level();
533 void set_allocated_security_patch_level(std::string* security_patch_level);
534 private:
535 const std::string& _internal_security_patch_level() const;
536 inline PROTOBUF_ALWAYS_INLINE void _internal_set_security_patch_level(const std::string& value);
537 std::string* _internal_mutable_security_patch_level();
538 public:
539
540 // int64 timestamp = 4;
541 void clear_timestamp();
542 ::int64_t timestamp() const;
543 void set_timestamp(::int64_t value);
544 private:
545 ::int64_t _internal_timestamp() const;
546 void _internal_set_timestamp(::int64_t value);
547 public:
548
549 // @@protoc_insertion_point(class_scope:build.tools.releasetools.DeviceState)
550 private:
551 class _Internal;
552
553 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
554 typedef void InternalArenaConstructable_;
555 typedef void DestructorSkippable_;
556 struct Impl_ {
557 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> device_;
558 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> build_;
559 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::build::tools::releasetools::PartitionState > partition_state_;
560 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr build_incremental_;
561 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr sdk_level_;
562 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr security_patch_level_;
563 ::int64_t timestamp_;
564 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
565 };
566 union { Impl_ _impl_; };
567 friend struct ::TableStruct_ota_5fmetadata_2eproto;
568 };
569 // -------------------------------------------------------------------
570
571 class ApexInfo final :
572 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:build.tools.releasetools.ApexInfo) */ {
573 public:
ApexInfo()574 inline ApexInfo() : ApexInfo(nullptr) {}
575 ~ApexInfo() override;
576 explicit PROTOBUF_CONSTEXPR ApexInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
577
578 ApexInfo(const ApexInfo& from);
ApexInfo(ApexInfo && from)579 ApexInfo(ApexInfo&& from) noexcept
580 : ApexInfo() {
581 *this = ::std::move(from);
582 }
583
584 inline ApexInfo& operator=(const ApexInfo& from) {
585 if (this == &from) return *this;
586 CopyFrom(from);
587 return *this;
588 }
589 inline ApexInfo& operator=(ApexInfo&& from) noexcept {
590 if (this == &from) return *this;
591 if (GetOwningArena() == from.GetOwningArena()
592 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
593 && GetOwningArena() != nullptr
594 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
595 ) {
596 InternalSwap(&from);
597 } else {
598 CopyFrom(from);
599 }
600 return *this;
601 }
602
default_instance()603 static const ApexInfo& default_instance() {
604 return *internal_default_instance();
605 }
internal_default_instance()606 static inline const ApexInfo* internal_default_instance() {
607 return reinterpret_cast<const ApexInfo*>(
608 &_ApexInfo_default_instance_);
609 }
610 static constexpr int kIndexInFileMessages =
611 2;
612
swap(ApexInfo & a,ApexInfo & b)613 friend void swap(ApexInfo& a, ApexInfo& b) {
614 a.Swap(&b);
615 }
Swap(ApexInfo * other)616 inline void Swap(ApexInfo* other) {
617 if (other == this) return;
618 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
619 if (GetOwningArena() != nullptr &&
620 GetOwningArena() == other->GetOwningArena()) {
621 #else // PROTOBUF_FORCE_COPY_IN_SWAP
622 if (GetOwningArena() == other->GetOwningArena()) {
623 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
624 InternalSwap(other);
625 } else {
626 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
627 }
628 }
629 void UnsafeArenaSwap(ApexInfo* other) {
630 if (other == this) return;
631 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
632 InternalSwap(other);
633 }
634
635 // implements Message ----------------------------------------------
636
637 ApexInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
638 return CreateMaybeMessage<ApexInfo>(arena);
639 }
640 ApexInfo* New() const {
641 return New(nullptr);
642 }
643 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
644 void CopyFrom(const ApexInfo& from);
645 void MergeFrom(const ApexInfo& from);
646 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
647 bool IsInitialized() const final;
648
649 size_t ByteSizeLong() const final;
650 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
651 ::uint8_t* _InternalSerialize(
652 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
653 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
654
655 private:
656 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
657 void SharedDtor();
658 void SetCachedSize(int size) const;
659 void InternalSwap(ApexInfo* other);
660
661 private:
662 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
663 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
664 return "build.tools.releasetools.ApexInfo";
665 }
666 protected:
667 explicit ApexInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
668 bool is_message_owned = false);
669 public:
670
671 std::string GetTypeName() const final;
672
673 // nested types ----------------------------------------------------
674
675 // accessors -------------------------------------------------------
676
677 enum : int {
678 kPackageNameFieldNumber = 1,
679 kVersionFieldNumber = 2,
680 kDecompressedSizeFieldNumber = 4,
681 kSourceVersionFieldNumber = 5,
682 kIsCompressedFieldNumber = 3,
683 };
684 // string package_name = 1;
685 void clear_package_name();
686 const std::string& package_name() const;
687 template <typename ArgT0 = const std::string&, typename... ArgT>
688 void set_package_name(ArgT0&& arg0, ArgT... args);
689 std::string* mutable_package_name();
690 PROTOBUF_NODISCARD std::string* release_package_name();
691 void set_allocated_package_name(std::string* package_name);
692 private:
693 const std::string& _internal_package_name() const;
694 inline PROTOBUF_ALWAYS_INLINE void _internal_set_package_name(const std::string& value);
695 std::string* _internal_mutable_package_name();
696 public:
697
698 // int64 version = 2;
699 void clear_version();
700 ::int64_t version() const;
701 void set_version(::int64_t value);
702 private:
703 ::int64_t _internal_version() const;
704 void _internal_set_version(::int64_t value);
705 public:
706
707 // int64 decompressed_size = 4;
708 void clear_decompressed_size();
709 ::int64_t decompressed_size() const;
710 void set_decompressed_size(::int64_t value);
711 private:
712 ::int64_t _internal_decompressed_size() const;
713 void _internal_set_decompressed_size(::int64_t value);
714 public:
715
716 // int64 source_version = 5;
717 void clear_source_version();
718 ::int64_t source_version() const;
719 void set_source_version(::int64_t value);
720 private:
721 ::int64_t _internal_source_version() const;
722 void _internal_set_source_version(::int64_t value);
723 public:
724
725 // bool is_compressed = 3;
726 void clear_is_compressed();
727 bool is_compressed() const;
728 void set_is_compressed(bool value);
729 private:
730 bool _internal_is_compressed() const;
731 void _internal_set_is_compressed(bool value);
732 public:
733
734 // @@protoc_insertion_point(class_scope:build.tools.releasetools.ApexInfo)
735 private:
736 class _Internal;
737
738 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
739 typedef void InternalArenaConstructable_;
740 typedef void DestructorSkippable_;
741 struct Impl_ {
742 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr package_name_;
743 ::int64_t version_;
744 ::int64_t decompressed_size_;
745 ::int64_t source_version_;
746 bool is_compressed_;
747 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
748 };
749 union { Impl_ _impl_; };
750 friend struct ::TableStruct_ota_5fmetadata_2eproto;
751 };
752 // -------------------------------------------------------------------
753
754 class ApexMetadata final :
755 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:build.tools.releasetools.ApexMetadata) */ {
756 public:
ApexMetadata()757 inline ApexMetadata() : ApexMetadata(nullptr) {}
758 ~ApexMetadata() override;
759 explicit PROTOBUF_CONSTEXPR ApexMetadata(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
760
761 ApexMetadata(const ApexMetadata& from);
ApexMetadata(ApexMetadata && from)762 ApexMetadata(ApexMetadata&& from) noexcept
763 : ApexMetadata() {
764 *this = ::std::move(from);
765 }
766
767 inline ApexMetadata& operator=(const ApexMetadata& from) {
768 if (this == &from) return *this;
769 CopyFrom(from);
770 return *this;
771 }
772 inline ApexMetadata& operator=(ApexMetadata&& from) noexcept {
773 if (this == &from) return *this;
774 if (GetOwningArena() == from.GetOwningArena()
775 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
776 && GetOwningArena() != nullptr
777 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
778 ) {
779 InternalSwap(&from);
780 } else {
781 CopyFrom(from);
782 }
783 return *this;
784 }
785
default_instance()786 static const ApexMetadata& default_instance() {
787 return *internal_default_instance();
788 }
internal_default_instance()789 static inline const ApexMetadata* internal_default_instance() {
790 return reinterpret_cast<const ApexMetadata*>(
791 &_ApexMetadata_default_instance_);
792 }
793 static constexpr int kIndexInFileMessages =
794 3;
795
swap(ApexMetadata & a,ApexMetadata & b)796 friend void swap(ApexMetadata& a, ApexMetadata& b) {
797 a.Swap(&b);
798 }
Swap(ApexMetadata * other)799 inline void Swap(ApexMetadata* other) {
800 if (other == this) return;
801 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
802 if (GetOwningArena() != nullptr &&
803 GetOwningArena() == other->GetOwningArena()) {
804 #else // PROTOBUF_FORCE_COPY_IN_SWAP
805 if (GetOwningArena() == other->GetOwningArena()) {
806 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
807 InternalSwap(other);
808 } else {
809 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
810 }
811 }
812 void UnsafeArenaSwap(ApexMetadata* other) {
813 if (other == this) return;
814 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
815 InternalSwap(other);
816 }
817
818 // implements Message ----------------------------------------------
819
820 ApexMetadata* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
821 return CreateMaybeMessage<ApexMetadata>(arena);
822 }
823 ApexMetadata* New() const {
824 return New(nullptr);
825 }
826 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
827 void CopyFrom(const ApexMetadata& from);
828 void MergeFrom(const ApexMetadata& from);
829 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
830 bool IsInitialized() const final;
831
832 size_t ByteSizeLong() const final;
833 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
834 ::uint8_t* _InternalSerialize(
835 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
836 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
837
838 private:
839 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
840 void SharedDtor();
841 void SetCachedSize(int size) const;
842 void InternalSwap(ApexMetadata* other);
843
844 private:
845 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
846 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
847 return "build.tools.releasetools.ApexMetadata";
848 }
849 protected:
850 explicit ApexMetadata(::PROTOBUF_NAMESPACE_ID::Arena* arena,
851 bool is_message_owned = false);
852 public:
853
854 std::string GetTypeName() const final;
855
856 // nested types ----------------------------------------------------
857
858 // accessors -------------------------------------------------------
859
860 enum : int {
861 kApexInfoFieldNumber = 1,
862 };
863 // repeated .build.tools.releasetools.ApexInfo apex_info = 1;
864 int apex_info_size() const;
865 private:
866 int _internal_apex_info_size() const;
867 public:
868 void clear_apex_info();
869 ::build::tools::releasetools::ApexInfo* mutable_apex_info(int index);
870 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::build::tools::releasetools::ApexInfo >*
871 mutable_apex_info();
872 private:
873 const ::build::tools::releasetools::ApexInfo& _internal_apex_info(int index) const;
874 ::build::tools::releasetools::ApexInfo* _internal_add_apex_info();
875 public:
876 const ::build::tools::releasetools::ApexInfo& apex_info(int index) const;
877 ::build::tools::releasetools::ApexInfo* add_apex_info();
878 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::build::tools::releasetools::ApexInfo >&
879 apex_info() const;
880
881 // @@protoc_insertion_point(class_scope:build.tools.releasetools.ApexMetadata)
882 private:
883 class _Internal;
884
885 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
886 typedef void InternalArenaConstructable_;
887 typedef void DestructorSkippable_;
888 struct Impl_ {
889 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::build::tools::releasetools::ApexInfo > apex_info_;
890 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
891 };
892 union { Impl_ _impl_; };
893 friend struct ::TableStruct_ota_5fmetadata_2eproto;
894 };
895 // -------------------------------------------------------------------
896
897 class OtaMetadata_PropertyFilesEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntryLite<OtaMetadata_PropertyFilesEntry_DoNotUse,
898 std::string, std::string,
899 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
900 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING> {
901 public:
902 typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntryLite<OtaMetadata_PropertyFilesEntry_DoNotUse,
903 std::string, std::string,
904 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
905 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING> SuperType;
906 OtaMetadata_PropertyFilesEntry_DoNotUse();
907 explicit PROTOBUF_CONSTEXPR OtaMetadata_PropertyFilesEntry_DoNotUse(
908 ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
909 explicit OtaMetadata_PropertyFilesEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
910 void MergeFrom(const OtaMetadata_PropertyFilesEntry_DoNotUse& other);
internal_default_instance()911 static const OtaMetadata_PropertyFilesEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const OtaMetadata_PropertyFilesEntry_DoNotUse*>(&_OtaMetadata_PropertyFilesEntry_DoNotUse_default_instance_); }
ValidateKey(std::string * s)912 static bool ValidateKey(std::string* s) {
913 return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "build.tools.releasetools.OtaMetadata.PropertyFilesEntry.key");
914 }
ValidateValue(std::string * s)915 static bool ValidateValue(std::string* s) {
916 return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "build.tools.releasetools.OtaMetadata.PropertyFilesEntry.value");
917 }
918 friend struct ::TableStruct_ota_5fmetadata_2eproto;
919 };
920
921 // -------------------------------------------------------------------
922
923 class OtaMetadata final :
924 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:build.tools.releasetools.OtaMetadata) */ {
925 public:
OtaMetadata()926 inline OtaMetadata() : OtaMetadata(nullptr) {}
927 ~OtaMetadata() override;
928 explicit PROTOBUF_CONSTEXPR OtaMetadata(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
929
930 OtaMetadata(const OtaMetadata& from);
OtaMetadata(OtaMetadata && from)931 OtaMetadata(OtaMetadata&& from) noexcept
932 : OtaMetadata() {
933 *this = ::std::move(from);
934 }
935
936 inline OtaMetadata& operator=(const OtaMetadata& from) {
937 if (this == &from) return *this;
938 CopyFrom(from);
939 return *this;
940 }
941 inline OtaMetadata& operator=(OtaMetadata&& from) noexcept {
942 if (this == &from) return *this;
943 if (GetOwningArena() == from.GetOwningArena()
944 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
945 && GetOwningArena() != nullptr
946 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
947 ) {
948 InternalSwap(&from);
949 } else {
950 CopyFrom(from);
951 }
952 return *this;
953 }
954
default_instance()955 static const OtaMetadata& default_instance() {
956 return *internal_default_instance();
957 }
internal_default_instance()958 static inline const OtaMetadata* internal_default_instance() {
959 return reinterpret_cast<const OtaMetadata*>(
960 &_OtaMetadata_default_instance_);
961 }
962 static constexpr int kIndexInFileMessages =
963 5;
964
swap(OtaMetadata & a,OtaMetadata & b)965 friend void swap(OtaMetadata& a, OtaMetadata& b) {
966 a.Swap(&b);
967 }
Swap(OtaMetadata * other)968 inline void Swap(OtaMetadata* other) {
969 if (other == this) return;
970 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
971 if (GetOwningArena() != nullptr &&
972 GetOwningArena() == other->GetOwningArena()) {
973 #else // PROTOBUF_FORCE_COPY_IN_SWAP
974 if (GetOwningArena() == other->GetOwningArena()) {
975 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
976 InternalSwap(other);
977 } else {
978 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
979 }
980 }
981 void UnsafeArenaSwap(OtaMetadata* other) {
982 if (other == this) return;
983 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
984 InternalSwap(other);
985 }
986
987 // implements Message ----------------------------------------------
988
989 OtaMetadata* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
990 return CreateMaybeMessage<OtaMetadata>(arena);
991 }
992 OtaMetadata* New() const {
993 return New(nullptr);
994 }
995 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
996 void CopyFrom(const OtaMetadata& from);
997 void MergeFrom(const OtaMetadata& from);
998 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
999 bool IsInitialized() const final;
1000
1001 size_t ByteSizeLong() const final;
1002 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1003 ::uint8_t* _InternalSerialize(
1004 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1005 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1006
1007 private:
1008 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1009 void SharedDtor();
1010 void SetCachedSize(int size) const;
1011 void InternalSwap(OtaMetadata* other);
1012
1013 private:
1014 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1015 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1016 return "build.tools.releasetools.OtaMetadata";
1017 }
1018 protected:
1019 explicit OtaMetadata(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1020 bool is_message_owned = false);
1021 public:
1022
1023 std::string GetTypeName() const final;
1024
1025 // nested types ----------------------------------------------------
1026
1027
1028 typedef OtaMetadata_OtaType OtaType;
1029 static constexpr OtaType UNKNOWN =
1030 OtaMetadata_OtaType_UNKNOWN;
1031 static constexpr OtaType AB =
1032 OtaMetadata_OtaType_AB;
1033 static constexpr OtaType BLOCK =
1034 OtaMetadata_OtaType_BLOCK;
1035 static constexpr OtaType BRICK =
1036 OtaMetadata_OtaType_BRICK;
1037 static inline bool OtaType_IsValid(int value) {
1038 return OtaMetadata_OtaType_IsValid(value);
1039 }
1040 static constexpr OtaType OtaType_MIN =
1041 OtaMetadata_OtaType_OtaType_MIN;
1042 static constexpr OtaType OtaType_MAX =
1043 OtaMetadata_OtaType_OtaType_MAX;
1044 static constexpr int OtaType_ARRAYSIZE =
1045 OtaMetadata_OtaType_OtaType_ARRAYSIZE;
1046 template<typename T>
1047 static inline const std::string& OtaType_Name(T enum_t_value) {
1048 static_assert(::std::is_same<T, OtaType>::value ||
1049 ::std::is_integral<T>::value,
1050 "Incorrect type passed to function OtaType_Name.");
1051 return OtaMetadata_OtaType_Name(enum_t_value);
1052 }
1053 static inline bool OtaType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
1054 OtaType* value) {
1055 return OtaMetadata_OtaType_Parse(name, value);
1056 }
1057
1058 // accessors -------------------------------------------------------
1059
1060 enum : int {
1061 kPropertyFilesFieldNumber = 4,
1062 kPreconditionFieldNumber = 5,
1063 kPostconditionFieldNumber = 6,
1064 kTypeFieldNumber = 1,
1065 kWipeFieldNumber = 2,
1066 kDowngradeFieldNumber = 3,
1067 kRetrofitDynamicPartitionsFieldNumber = 7,
1068 kSplDowngradeFieldNumber = 9,
1069 kRequiredCacheFieldNumber = 8,
1070 };
1071 // map<string, string> property_files = 4;
1072 int property_files_size() const;
1073 private:
1074 int _internal_property_files_size() const;
1075 public:
1076 void clear_property_files();
1077 private:
1078 const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >&
1079 _internal_property_files() const;
1080 ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >*
1081 _internal_mutable_property_files();
1082 public:
1083 const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >&
1084 property_files() const;
1085 ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >*
1086 mutable_property_files();
1087
1088 // .build.tools.releasetools.DeviceState precondition = 5;
1089 bool has_precondition() const;
1090 private:
1091 bool _internal_has_precondition() const;
1092 public:
1093 void clear_precondition();
1094 const ::build::tools::releasetools::DeviceState& precondition() const;
1095 PROTOBUF_NODISCARD ::build::tools::releasetools::DeviceState* release_precondition();
1096 ::build::tools::releasetools::DeviceState* mutable_precondition();
1097 void set_allocated_precondition(::build::tools::releasetools::DeviceState* precondition);
1098 private:
1099 const ::build::tools::releasetools::DeviceState& _internal_precondition() const;
1100 ::build::tools::releasetools::DeviceState* _internal_mutable_precondition();
1101 public:
1102 void unsafe_arena_set_allocated_precondition(
1103 ::build::tools::releasetools::DeviceState* precondition);
1104 ::build::tools::releasetools::DeviceState* unsafe_arena_release_precondition();
1105
1106 // .build.tools.releasetools.DeviceState postcondition = 6;
1107 bool has_postcondition() const;
1108 private:
1109 bool _internal_has_postcondition() const;
1110 public:
1111 void clear_postcondition();
1112 const ::build::tools::releasetools::DeviceState& postcondition() const;
1113 PROTOBUF_NODISCARD ::build::tools::releasetools::DeviceState* release_postcondition();
1114 ::build::tools::releasetools::DeviceState* mutable_postcondition();
1115 void set_allocated_postcondition(::build::tools::releasetools::DeviceState* postcondition);
1116 private:
1117 const ::build::tools::releasetools::DeviceState& _internal_postcondition() const;
1118 ::build::tools::releasetools::DeviceState* _internal_mutable_postcondition();
1119 public:
1120 void unsafe_arena_set_allocated_postcondition(
1121 ::build::tools::releasetools::DeviceState* postcondition);
1122 ::build::tools::releasetools::DeviceState* unsafe_arena_release_postcondition();
1123
1124 // .build.tools.releasetools.OtaMetadata.OtaType type = 1;
1125 void clear_type();
1126 ::build::tools::releasetools::OtaMetadata_OtaType type() const;
1127 void set_type(::build::tools::releasetools::OtaMetadata_OtaType value);
1128 private:
1129 ::build::tools::releasetools::OtaMetadata_OtaType _internal_type() const;
1130 void _internal_set_type(::build::tools::releasetools::OtaMetadata_OtaType value);
1131 public:
1132
1133 // bool wipe = 2;
1134 void clear_wipe();
1135 bool wipe() const;
1136 void set_wipe(bool value);
1137 private:
1138 bool _internal_wipe() const;
1139 void _internal_set_wipe(bool value);
1140 public:
1141
1142 // bool downgrade = 3;
1143 void clear_downgrade();
1144 bool downgrade() const;
1145 void set_downgrade(bool value);
1146 private:
1147 bool _internal_downgrade() const;
1148 void _internal_set_downgrade(bool value);
1149 public:
1150
1151 // bool retrofit_dynamic_partitions = 7;
1152 void clear_retrofit_dynamic_partitions();
1153 bool retrofit_dynamic_partitions() const;
1154 void set_retrofit_dynamic_partitions(bool value);
1155 private:
1156 bool _internal_retrofit_dynamic_partitions() const;
1157 void _internal_set_retrofit_dynamic_partitions(bool value);
1158 public:
1159
1160 // bool spl_downgrade = 9;
1161 void clear_spl_downgrade();
1162 bool spl_downgrade() const;
1163 void set_spl_downgrade(bool value);
1164 private:
1165 bool _internal_spl_downgrade() const;
1166 void _internal_set_spl_downgrade(bool value);
1167 public:
1168
1169 // int64 required_cache = 8;
1170 void clear_required_cache();
1171 ::int64_t required_cache() const;
1172 void set_required_cache(::int64_t value);
1173 private:
1174 ::int64_t _internal_required_cache() const;
1175 void _internal_set_required_cache(::int64_t value);
1176 public:
1177
1178 // @@protoc_insertion_point(class_scope:build.tools.releasetools.OtaMetadata)
1179 private:
1180 class _Internal;
1181
1182 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1183 typedef void InternalArenaConstructable_;
1184 typedef void DestructorSkippable_;
1185 struct Impl_ {
1186 ::PROTOBUF_NAMESPACE_ID::internal::MapFieldLite<
1187 OtaMetadata_PropertyFilesEntry_DoNotUse,
1188 std::string, std::string,
1189 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
1190 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING> property_files_;
1191 ::build::tools::releasetools::DeviceState* precondition_;
1192 ::build::tools::releasetools::DeviceState* postcondition_;
1193 int type_;
1194 bool wipe_;
1195 bool downgrade_;
1196 bool retrofit_dynamic_partitions_;
1197 bool spl_downgrade_;
1198 ::int64_t required_cache_;
1199 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1200 };
1201 union { Impl_ _impl_; };
1202 friend struct ::TableStruct_ota_5fmetadata_2eproto;
1203 };
1204 // ===================================================================
1205
1206
1207 // ===================================================================
1208
1209 #ifdef __GNUC__
1210 #pragma GCC diagnostic push
1211 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
1212 #endif // __GNUC__
1213 // PartitionState
1214
1215 // string partition_name = 1;
clear_partition_name()1216 inline void PartitionState::clear_partition_name() {
1217 _impl_.partition_name_.ClearToEmpty();
1218 }
partition_name()1219 inline const std::string& PartitionState::partition_name() const {
1220 // @@protoc_insertion_point(field_get:build.tools.releasetools.PartitionState.partition_name)
1221 return _internal_partition_name();
1222 }
1223 template <typename ArgT0, typename... ArgT>
1224 inline PROTOBUF_ALWAYS_INLINE
set_partition_name(ArgT0 && arg0,ArgT...args)1225 void PartitionState::set_partition_name(ArgT0&& arg0, ArgT... args) {
1226
1227 _impl_.partition_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
1228 // @@protoc_insertion_point(field_set:build.tools.releasetools.PartitionState.partition_name)
1229 }
mutable_partition_name()1230 inline std::string* PartitionState::mutable_partition_name() {
1231 std::string* _s = _internal_mutable_partition_name();
1232 // @@protoc_insertion_point(field_mutable:build.tools.releasetools.PartitionState.partition_name)
1233 return _s;
1234 }
_internal_partition_name()1235 inline const std::string& PartitionState::_internal_partition_name() const {
1236 return _impl_.partition_name_.Get();
1237 }
_internal_set_partition_name(const std::string & value)1238 inline void PartitionState::_internal_set_partition_name(const std::string& value) {
1239
1240 _impl_.partition_name_.Set(value, GetArenaForAllocation());
1241 }
_internal_mutable_partition_name()1242 inline std::string* PartitionState::_internal_mutable_partition_name() {
1243
1244 return _impl_.partition_name_.Mutable(GetArenaForAllocation());
1245 }
release_partition_name()1246 inline std::string* PartitionState::release_partition_name() {
1247 // @@protoc_insertion_point(field_release:build.tools.releasetools.PartitionState.partition_name)
1248 return _impl_.partition_name_.Release();
1249 }
set_allocated_partition_name(std::string * partition_name)1250 inline void PartitionState::set_allocated_partition_name(std::string* partition_name) {
1251 _impl_.partition_name_.SetAllocated(partition_name, GetArenaForAllocation());
1252 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1253 if (_impl_.partition_name_.IsDefault()) {
1254 _impl_.partition_name_.Set("", GetArenaForAllocation());
1255 }
1256 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1257 // @@protoc_insertion_point(field_set_allocated:build.tools.releasetools.PartitionState.partition_name)
1258 }
1259
1260 // repeated string device = 2;
_internal_device_size()1261 inline int PartitionState::_internal_device_size() const {
1262 return _impl_.device_.size();
1263 }
device_size()1264 inline int PartitionState::device_size() const {
1265 return _internal_device_size();
1266 }
clear_device()1267 inline void PartitionState::clear_device() {
1268 _impl_.device_.Clear();
1269 }
add_device()1270 inline std::string* PartitionState::add_device() {
1271 std::string* _s = _internal_add_device();
1272 // @@protoc_insertion_point(field_add_mutable:build.tools.releasetools.PartitionState.device)
1273 return _s;
1274 }
_internal_device(int index)1275 inline const std::string& PartitionState::_internal_device(int index) const {
1276 return _impl_.device_.Get(index);
1277 }
device(int index)1278 inline const std::string& PartitionState::device(int index) const {
1279 // @@protoc_insertion_point(field_get:build.tools.releasetools.PartitionState.device)
1280 return _internal_device(index);
1281 }
mutable_device(int index)1282 inline std::string* PartitionState::mutable_device(int index) {
1283 // @@protoc_insertion_point(field_mutable:build.tools.releasetools.PartitionState.device)
1284 return _impl_.device_.Mutable(index);
1285 }
set_device(int index,const std::string & value)1286 inline void PartitionState::set_device(int index, const std::string& value) {
1287 _impl_.device_.Mutable(index)->assign(value);
1288 // @@protoc_insertion_point(field_set:build.tools.releasetools.PartitionState.device)
1289 }
set_device(int index,std::string && value)1290 inline void PartitionState::set_device(int index, std::string&& value) {
1291 _impl_.device_.Mutable(index)->assign(std::move(value));
1292 // @@protoc_insertion_point(field_set:build.tools.releasetools.PartitionState.device)
1293 }
set_device(int index,const char * value)1294 inline void PartitionState::set_device(int index, const char* value) {
1295 GOOGLE_DCHECK(value != nullptr);
1296 _impl_.device_.Mutable(index)->assign(value);
1297 // @@protoc_insertion_point(field_set_char:build.tools.releasetools.PartitionState.device)
1298 }
set_device(int index,const char * value,size_t size)1299 inline void PartitionState::set_device(int index, const char* value, size_t size) {
1300 _impl_.device_.Mutable(index)->assign(
1301 reinterpret_cast<const char*>(value), size);
1302 // @@protoc_insertion_point(field_set_pointer:build.tools.releasetools.PartitionState.device)
1303 }
_internal_add_device()1304 inline std::string* PartitionState::_internal_add_device() {
1305 return _impl_.device_.Add();
1306 }
add_device(const std::string & value)1307 inline void PartitionState::add_device(const std::string& value) {
1308 _impl_.device_.Add()->assign(value);
1309 // @@protoc_insertion_point(field_add:build.tools.releasetools.PartitionState.device)
1310 }
add_device(std::string && value)1311 inline void PartitionState::add_device(std::string&& value) {
1312 _impl_.device_.Add(std::move(value));
1313 // @@protoc_insertion_point(field_add:build.tools.releasetools.PartitionState.device)
1314 }
add_device(const char * value)1315 inline void PartitionState::add_device(const char* value) {
1316 GOOGLE_DCHECK(value != nullptr);
1317 _impl_.device_.Add()->assign(value);
1318 // @@protoc_insertion_point(field_add_char:build.tools.releasetools.PartitionState.device)
1319 }
add_device(const char * value,size_t size)1320 inline void PartitionState::add_device(const char* value, size_t size) {
1321 _impl_.device_.Add()->assign(reinterpret_cast<const char*>(value), size);
1322 // @@protoc_insertion_point(field_add_pointer:build.tools.releasetools.PartitionState.device)
1323 }
1324 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
device()1325 PartitionState::device() const {
1326 // @@protoc_insertion_point(field_list:build.tools.releasetools.PartitionState.device)
1327 return _impl_.device_;
1328 }
1329 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
mutable_device()1330 PartitionState::mutable_device() {
1331 // @@protoc_insertion_point(field_mutable_list:build.tools.releasetools.PartitionState.device)
1332 return &_impl_.device_;
1333 }
1334
1335 // repeated string build = 3;
_internal_build_size()1336 inline int PartitionState::_internal_build_size() const {
1337 return _impl_.build_.size();
1338 }
build_size()1339 inline int PartitionState::build_size() const {
1340 return _internal_build_size();
1341 }
clear_build()1342 inline void PartitionState::clear_build() {
1343 _impl_.build_.Clear();
1344 }
add_build()1345 inline std::string* PartitionState::add_build() {
1346 std::string* _s = _internal_add_build();
1347 // @@protoc_insertion_point(field_add_mutable:build.tools.releasetools.PartitionState.build)
1348 return _s;
1349 }
_internal_build(int index)1350 inline const std::string& PartitionState::_internal_build(int index) const {
1351 return _impl_.build_.Get(index);
1352 }
build(int index)1353 inline const std::string& PartitionState::build(int index) const {
1354 // @@protoc_insertion_point(field_get:build.tools.releasetools.PartitionState.build)
1355 return _internal_build(index);
1356 }
mutable_build(int index)1357 inline std::string* PartitionState::mutable_build(int index) {
1358 // @@protoc_insertion_point(field_mutable:build.tools.releasetools.PartitionState.build)
1359 return _impl_.build_.Mutable(index);
1360 }
set_build(int index,const std::string & value)1361 inline void PartitionState::set_build(int index, const std::string& value) {
1362 _impl_.build_.Mutable(index)->assign(value);
1363 // @@protoc_insertion_point(field_set:build.tools.releasetools.PartitionState.build)
1364 }
set_build(int index,std::string && value)1365 inline void PartitionState::set_build(int index, std::string&& value) {
1366 _impl_.build_.Mutable(index)->assign(std::move(value));
1367 // @@protoc_insertion_point(field_set:build.tools.releasetools.PartitionState.build)
1368 }
set_build(int index,const char * value)1369 inline void PartitionState::set_build(int index, const char* value) {
1370 GOOGLE_DCHECK(value != nullptr);
1371 _impl_.build_.Mutable(index)->assign(value);
1372 // @@protoc_insertion_point(field_set_char:build.tools.releasetools.PartitionState.build)
1373 }
set_build(int index,const char * value,size_t size)1374 inline void PartitionState::set_build(int index, const char* value, size_t size) {
1375 _impl_.build_.Mutable(index)->assign(
1376 reinterpret_cast<const char*>(value), size);
1377 // @@protoc_insertion_point(field_set_pointer:build.tools.releasetools.PartitionState.build)
1378 }
_internal_add_build()1379 inline std::string* PartitionState::_internal_add_build() {
1380 return _impl_.build_.Add();
1381 }
add_build(const std::string & value)1382 inline void PartitionState::add_build(const std::string& value) {
1383 _impl_.build_.Add()->assign(value);
1384 // @@protoc_insertion_point(field_add:build.tools.releasetools.PartitionState.build)
1385 }
add_build(std::string && value)1386 inline void PartitionState::add_build(std::string&& value) {
1387 _impl_.build_.Add(std::move(value));
1388 // @@protoc_insertion_point(field_add:build.tools.releasetools.PartitionState.build)
1389 }
add_build(const char * value)1390 inline void PartitionState::add_build(const char* value) {
1391 GOOGLE_DCHECK(value != nullptr);
1392 _impl_.build_.Add()->assign(value);
1393 // @@protoc_insertion_point(field_add_char:build.tools.releasetools.PartitionState.build)
1394 }
add_build(const char * value,size_t size)1395 inline void PartitionState::add_build(const char* value, size_t size) {
1396 _impl_.build_.Add()->assign(reinterpret_cast<const char*>(value), size);
1397 // @@protoc_insertion_point(field_add_pointer:build.tools.releasetools.PartitionState.build)
1398 }
1399 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
build()1400 PartitionState::build() const {
1401 // @@protoc_insertion_point(field_list:build.tools.releasetools.PartitionState.build)
1402 return _impl_.build_;
1403 }
1404 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
mutable_build()1405 PartitionState::mutable_build() {
1406 // @@protoc_insertion_point(field_mutable_list:build.tools.releasetools.PartitionState.build)
1407 return &_impl_.build_;
1408 }
1409
1410 // string version = 4;
clear_version()1411 inline void PartitionState::clear_version() {
1412 _impl_.version_.ClearToEmpty();
1413 }
version()1414 inline const std::string& PartitionState::version() const {
1415 // @@protoc_insertion_point(field_get:build.tools.releasetools.PartitionState.version)
1416 return _internal_version();
1417 }
1418 template <typename ArgT0, typename... ArgT>
1419 inline PROTOBUF_ALWAYS_INLINE
set_version(ArgT0 && arg0,ArgT...args)1420 void PartitionState::set_version(ArgT0&& arg0, ArgT... args) {
1421
1422 _impl_.version_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
1423 // @@protoc_insertion_point(field_set:build.tools.releasetools.PartitionState.version)
1424 }
mutable_version()1425 inline std::string* PartitionState::mutable_version() {
1426 std::string* _s = _internal_mutable_version();
1427 // @@protoc_insertion_point(field_mutable:build.tools.releasetools.PartitionState.version)
1428 return _s;
1429 }
_internal_version()1430 inline const std::string& PartitionState::_internal_version() const {
1431 return _impl_.version_.Get();
1432 }
_internal_set_version(const std::string & value)1433 inline void PartitionState::_internal_set_version(const std::string& value) {
1434
1435 _impl_.version_.Set(value, GetArenaForAllocation());
1436 }
_internal_mutable_version()1437 inline std::string* PartitionState::_internal_mutable_version() {
1438
1439 return _impl_.version_.Mutable(GetArenaForAllocation());
1440 }
release_version()1441 inline std::string* PartitionState::release_version() {
1442 // @@protoc_insertion_point(field_release:build.tools.releasetools.PartitionState.version)
1443 return _impl_.version_.Release();
1444 }
set_allocated_version(std::string * version)1445 inline void PartitionState::set_allocated_version(std::string* version) {
1446 _impl_.version_.SetAllocated(version, GetArenaForAllocation());
1447 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1448 if (_impl_.version_.IsDefault()) {
1449 _impl_.version_.Set("", GetArenaForAllocation());
1450 }
1451 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1452 // @@protoc_insertion_point(field_set_allocated:build.tools.releasetools.PartitionState.version)
1453 }
1454
1455 // -------------------------------------------------------------------
1456
1457 // DeviceState
1458
1459 // repeated string device = 1;
_internal_device_size()1460 inline int DeviceState::_internal_device_size() const {
1461 return _impl_.device_.size();
1462 }
device_size()1463 inline int DeviceState::device_size() const {
1464 return _internal_device_size();
1465 }
clear_device()1466 inline void DeviceState::clear_device() {
1467 _impl_.device_.Clear();
1468 }
add_device()1469 inline std::string* DeviceState::add_device() {
1470 std::string* _s = _internal_add_device();
1471 // @@protoc_insertion_point(field_add_mutable:build.tools.releasetools.DeviceState.device)
1472 return _s;
1473 }
_internal_device(int index)1474 inline const std::string& DeviceState::_internal_device(int index) const {
1475 return _impl_.device_.Get(index);
1476 }
device(int index)1477 inline const std::string& DeviceState::device(int index) const {
1478 // @@protoc_insertion_point(field_get:build.tools.releasetools.DeviceState.device)
1479 return _internal_device(index);
1480 }
mutable_device(int index)1481 inline std::string* DeviceState::mutable_device(int index) {
1482 // @@protoc_insertion_point(field_mutable:build.tools.releasetools.DeviceState.device)
1483 return _impl_.device_.Mutable(index);
1484 }
set_device(int index,const std::string & value)1485 inline void DeviceState::set_device(int index, const std::string& value) {
1486 _impl_.device_.Mutable(index)->assign(value);
1487 // @@protoc_insertion_point(field_set:build.tools.releasetools.DeviceState.device)
1488 }
set_device(int index,std::string && value)1489 inline void DeviceState::set_device(int index, std::string&& value) {
1490 _impl_.device_.Mutable(index)->assign(std::move(value));
1491 // @@protoc_insertion_point(field_set:build.tools.releasetools.DeviceState.device)
1492 }
set_device(int index,const char * value)1493 inline void DeviceState::set_device(int index, const char* value) {
1494 GOOGLE_DCHECK(value != nullptr);
1495 _impl_.device_.Mutable(index)->assign(value);
1496 // @@protoc_insertion_point(field_set_char:build.tools.releasetools.DeviceState.device)
1497 }
set_device(int index,const char * value,size_t size)1498 inline void DeviceState::set_device(int index, const char* value, size_t size) {
1499 _impl_.device_.Mutable(index)->assign(
1500 reinterpret_cast<const char*>(value), size);
1501 // @@protoc_insertion_point(field_set_pointer:build.tools.releasetools.DeviceState.device)
1502 }
_internal_add_device()1503 inline std::string* DeviceState::_internal_add_device() {
1504 return _impl_.device_.Add();
1505 }
add_device(const std::string & value)1506 inline void DeviceState::add_device(const std::string& value) {
1507 _impl_.device_.Add()->assign(value);
1508 // @@protoc_insertion_point(field_add:build.tools.releasetools.DeviceState.device)
1509 }
add_device(std::string && value)1510 inline void DeviceState::add_device(std::string&& value) {
1511 _impl_.device_.Add(std::move(value));
1512 // @@protoc_insertion_point(field_add:build.tools.releasetools.DeviceState.device)
1513 }
add_device(const char * value)1514 inline void DeviceState::add_device(const char* value) {
1515 GOOGLE_DCHECK(value != nullptr);
1516 _impl_.device_.Add()->assign(value);
1517 // @@protoc_insertion_point(field_add_char:build.tools.releasetools.DeviceState.device)
1518 }
add_device(const char * value,size_t size)1519 inline void DeviceState::add_device(const char* value, size_t size) {
1520 _impl_.device_.Add()->assign(reinterpret_cast<const char*>(value), size);
1521 // @@protoc_insertion_point(field_add_pointer:build.tools.releasetools.DeviceState.device)
1522 }
1523 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
device()1524 DeviceState::device() const {
1525 // @@protoc_insertion_point(field_list:build.tools.releasetools.DeviceState.device)
1526 return _impl_.device_;
1527 }
1528 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
mutable_device()1529 DeviceState::mutable_device() {
1530 // @@protoc_insertion_point(field_mutable_list:build.tools.releasetools.DeviceState.device)
1531 return &_impl_.device_;
1532 }
1533
1534 // repeated string build = 2;
_internal_build_size()1535 inline int DeviceState::_internal_build_size() const {
1536 return _impl_.build_.size();
1537 }
build_size()1538 inline int DeviceState::build_size() const {
1539 return _internal_build_size();
1540 }
clear_build()1541 inline void DeviceState::clear_build() {
1542 _impl_.build_.Clear();
1543 }
add_build()1544 inline std::string* DeviceState::add_build() {
1545 std::string* _s = _internal_add_build();
1546 // @@protoc_insertion_point(field_add_mutable:build.tools.releasetools.DeviceState.build)
1547 return _s;
1548 }
_internal_build(int index)1549 inline const std::string& DeviceState::_internal_build(int index) const {
1550 return _impl_.build_.Get(index);
1551 }
build(int index)1552 inline const std::string& DeviceState::build(int index) const {
1553 // @@protoc_insertion_point(field_get:build.tools.releasetools.DeviceState.build)
1554 return _internal_build(index);
1555 }
mutable_build(int index)1556 inline std::string* DeviceState::mutable_build(int index) {
1557 // @@protoc_insertion_point(field_mutable:build.tools.releasetools.DeviceState.build)
1558 return _impl_.build_.Mutable(index);
1559 }
set_build(int index,const std::string & value)1560 inline void DeviceState::set_build(int index, const std::string& value) {
1561 _impl_.build_.Mutable(index)->assign(value);
1562 // @@protoc_insertion_point(field_set:build.tools.releasetools.DeviceState.build)
1563 }
set_build(int index,std::string && value)1564 inline void DeviceState::set_build(int index, std::string&& value) {
1565 _impl_.build_.Mutable(index)->assign(std::move(value));
1566 // @@protoc_insertion_point(field_set:build.tools.releasetools.DeviceState.build)
1567 }
set_build(int index,const char * value)1568 inline void DeviceState::set_build(int index, const char* value) {
1569 GOOGLE_DCHECK(value != nullptr);
1570 _impl_.build_.Mutable(index)->assign(value);
1571 // @@protoc_insertion_point(field_set_char:build.tools.releasetools.DeviceState.build)
1572 }
set_build(int index,const char * value,size_t size)1573 inline void DeviceState::set_build(int index, const char* value, size_t size) {
1574 _impl_.build_.Mutable(index)->assign(
1575 reinterpret_cast<const char*>(value), size);
1576 // @@protoc_insertion_point(field_set_pointer:build.tools.releasetools.DeviceState.build)
1577 }
_internal_add_build()1578 inline std::string* DeviceState::_internal_add_build() {
1579 return _impl_.build_.Add();
1580 }
add_build(const std::string & value)1581 inline void DeviceState::add_build(const std::string& value) {
1582 _impl_.build_.Add()->assign(value);
1583 // @@protoc_insertion_point(field_add:build.tools.releasetools.DeviceState.build)
1584 }
add_build(std::string && value)1585 inline void DeviceState::add_build(std::string&& value) {
1586 _impl_.build_.Add(std::move(value));
1587 // @@protoc_insertion_point(field_add:build.tools.releasetools.DeviceState.build)
1588 }
add_build(const char * value)1589 inline void DeviceState::add_build(const char* value) {
1590 GOOGLE_DCHECK(value != nullptr);
1591 _impl_.build_.Add()->assign(value);
1592 // @@protoc_insertion_point(field_add_char:build.tools.releasetools.DeviceState.build)
1593 }
add_build(const char * value,size_t size)1594 inline void DeviceState::add_build(const char* value, size_t size) {
1595 _impl_.build_.Add()->assign(reinterpret_cast<const char*>(value), size);
1596 // @@protoc_insertion_point(field_add_pointer:build.tools.releasetools.DeviceState.build)
1597 }
1598 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
build()1599 DeviceState::build() const {
1600 // @@protoc_insertion_point(field_list:build.tools.releasetools.DeviceState.build)
1601 return _impl_.build_;
1602 }
1603 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
mutable_build()1604 DeviceState::mutable_build() {
1605 // @@protoc_insertion_point(field_mutable_list:build.tools.releasetools.DeviceState.build)
1606 return &_impl_.build_;
1607 }
1608
1609 // string build_incremental = 3;
clear_build_incremental()1610 inline void DeviceState::clear_build_incremental() {
1611 _impl_.build_incremental_.ClearToEmpty();
1612 }
build_incremental()1613 inline const std::string& DeviceState::build_incremental() const {
1614 // @@protoc_insertion_point(field_get:build.tools.releasetools.DeviceState.build_incremental)
1615 return _internal_build_incremental();
1616 }
1617 template <typename ArgT0, typename... ArgT>
1618 inline PROTOBUF_ALWAYS_INLINE
set_build_incremental(ArgT0 && arg0,ArgT...args)1619 void DeviceState::set_build_incremental(ArgT0&& arg0, ArgT... args) {
1620
1621 _impl_.build_incremental_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
1622 // @@protoc_insertion_point(field_set:build.tools.releasetools.DeviceState.build_incremental)
1623 }
mutable_build_incremental()1624 inline std::string* DeviceState::mutable_build_incremental() {
1625 std::string* _s = _internal_mutable_build_incremental();
1626 // @@protoc_insertion_point(field_mutable:build.tools.releasetools.DeviceState.build_incremental)
1627 return _s;
1628 }
_internal_build_incremental()1629 inline const std::string& DeviceState::_internal_build_incremental() const {
1630 return _impl_.build_incremental_.Get();
1631 }
_internal_set_build_incremental(const std::string & value)1632 inline void DeviceState::_internal_set_build_incremental(const std::string& value) {
1633
1634 _impl_.build_incremental_.Set(value, GetArenaForAllocation());
1635 }
_internal_mutable_build_incremental()1636 inline std::string* DeviceState::_internal_mutable_build_incremental() {
1637
1638 return _impl_.build_incremental_.Mutable(GetArenaForAllocation());
1639 }
release_build_incremental()1640 inline std::string* DeviceState::release_build_incremental() {
1641 // @@protoc_insertion_point(field_release:build.tools.releasetools.DeviceState.build_incremental)
1642 return _impl_.build_incremental_.Release();
1643 }
set_allocated_build_incremental(std::string * build_incremental)1644 inline void DeviceState::set_allocated_build_incremental(std::string* build_incremental) {
1645 _impl_.build_incremental_.SetAllocated(build_incremental, GetArenaForAllocation());
1646 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1647 if (_impl_.build_incremental_.IsDefault()) {
1648 _impl_.build_incremental_.Set("", GetArenaForAllocation());
1649 }
1650 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1651 // @@protoc_insertion_point(field_set_allocated:build.tools.releasetools.DeviceState.build_incremental)
1652 }
1653
1654 // int64 timestamp = 4;
clear_timestamp()1655 inline void DeviceState::clear_timestamp() {
1656 _impl_.timestamp_ = ::int64_t{0};
1657 }
_internal_timestamp()1658 inline ::int64_t DeviceState::_internal_timestamp() const {
1659 return _impl_.timestamp_;
1660 }
timestamp()1661 inline ::int64_t DeviceState::timestamp() const {
1662 // @@protoc_insertion_point(field_get:build.tools.releasetools.DeviceState.timestamp)
1663 return _internal_timestamp();
1664 }
_internal_set_timestamp(::int64_t value)1665 inline void DeviceState::_internal_set_timestamp(::int64_t value) {
1666
1667 _impl_.timestamp_ = value;
1668 }
set_timestamp(::int64_t value)1669 inline void DeviceState::set_timestamp(::int64_t value) {
1670 _internal_set_timestamp(value);
1671 // @@protoc_insertion_point(field_set:build.tools.releasetools.DeviceState.timestamp)
1672 }
1673
1674 // string sdk_level = 5;
clear_sdk_level()1675 inline void DeviceState::clear_sdk_level() {
1676 _impl_.sdk_level_.ClearToEmpty();
1677 }
sdk_level()1678 inline const std::string& DeviceState::sdk_level() const {
1679 // @@protoc_insertion_point(field_get:build.tools.releasetools.DeviceState.sdk_level)
1680 return _internal_sdk_level();
1681 }
1682 template <typename ArgT0, typename... ArgT>
1683 inline PROTOBUF_ALWAYS_INLINE
set_sdk_level(ArgT0 && arg0,ArgT...args)1684 void DeviceState::set_sdk_level(ArgT0&& arg0, ArgT... args) {
1685
1686 _impl_.sdk_level_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
1687 // @@protoc_insertion_point(field_set:build.tools.releasetools.DeviceState.sdk_level)
1688 }
mutable_sdk_level()1689 inline std::string* DeviceState::mutable_sdk_level() {
1690 std::string* _s = _internal_mutable_sdk_level();
1691 // @@protoc_insertion_point(field_mutable:build.tools.releasetools.DeviceState.sdk_level)
1692 return _s;
1693 }
_internal_sdk_level()1694 inline const std::string& DeviceState::_internal_sdk_level() const {
1695 return _impl_.sdk_level_.Get();
1696 }
_internal_set_sdk_level(const std::string & value)1697 inline void DeviceState::_internal_set_sdk_level(const std::string& value) {
1698
1699 _impl_.sdk_level_.Set(value, GetArenaForAllocation());
1700 }
_internal_mutable_sdk_level()1701 inline std::string* DeviceState::_internal_mutable_sdk_level() {
1702
1703 return _impl_.sdk_level_.Mutable(GetArenaForAllocation());
1704 }
release_sdk_level()1705 inline std::string* DeviceState::release_sdk_level() {
1706 // @@protoc_insertion_point(field_release:build.tools.releasetools.DeviceState.sdk_level)
1707 return _impl_.sdk_level_.Release();
1708 }
set_allocated_sdk_level(std::string * sdk_level)1709 inline void DeviceState::set_allocated_sdk_level(std::string* sdk_level) {
1710 _impl_.sdk_level_.SetAllocated(sdk_level, GetArenaForAllocation());
1711 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1712 if (_impl_.sdk_level_.IsDefault()) {
1713 _impl_.sdk_level_.Set("", GetArenaForAllocation());
1714 }
1715 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1716 // @@protoc_insertion_point(field_set_allocated:build.tools.releasetools.DeviceState.sdk_level)
1717 }
1718
1719 // string security_patch_level = 6;
clear_security_patch_level()1720 inline void DeviceState::clear_security_patch_level() {
1721 _impl_.security_patch_level_.ClearToEmpty();
1722 }
security_patch_level()1723 inline const std::string& DeviceState::security_patch_level() const {
1724 // @@protoc_insertion_point(field_get:build.tools.releasetools.DeviceState.security_patch_level)
1725 return _internal_security_patch_level();
1726 }
1727 template <typename ArgT0, typename... ArgT>
1728 inline PROTOBUF_ALWAYS_INLINE
set_security_patch_level(ArgT0 && arg0,ArgT...args)1729 void DeviceState::set_security_patch_level(ArgT0&& arg0, ArgT... args) {
1730
1731 _impl_.security_patch_level_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
1732 // @@protoc_insertion_point(field_set:build.tools.releasetools.DeviceState.security_patch_level)
1733 }
mutable_security_patch_level()1734 inline std::string* DeviceState::mutable_security_patch_level() {
1735 std::string* _s = _internal_mutable_security_patch_level();
1736 // @@protoc_insertion_point(field_mutable:build.tools.releasetools.DeviceState.security_patch_level)
1737 return _s;
1738 }
_internal_security_patch_level()1739 inline const std::string& DeviceState::_internal_security_patch_level() const {
1740 return _impl_.security_patch_level_.Get();
1741 }
_internal_set_security_patch_level(const std::string & value)1742 inline void DeviceState::_internal_set_security_patch_level(const std::string& value) {
1743
1744 _impl_.security_patch_level_.Set(value, GetArenaForAllocation());
1745 }
_internal_mutable_security_patch_level()1746 inline std::string* DeviceState::_internal_mutable_security_patch_level() {
1747
1748 return _impl_.security_patch_level_.Mutable(GetArenaForAllocation());
1749 }
release_security_patch_level()1750 inline std::string* DeviceState::release_security_patch_level() {
1751 // @@protoc_insertion_point(field_release:build.tools.releasetools.DeviceState.security_patch_level)
1752 return _impl_.security_patch_level_.Release();
1753 }
set_allocated_security_patch_level(std::string * security_patch_level)1754 inline void DeviceState::set_allocated_security_patch_level(std::string* security_patch_level) {
1755 _impl_.security_patch_level_.SetAllocated(security_patch_level, GetArenaForAllocation());
1756 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1757 if (_impl_.security_patch_level_.IsDefault()) {
1758 _impl_.security_patch_level_.Set("", GetArenaForAllocation());
1759 }
1760 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1761 // @@protoc_insertion_point(field_set_allocated:build.tools.releasetools.DeviceState.security_patch_level)
1762 }
1763
1764 // repeated .build.tools.releasetools.PartitionState partition_state = 7;
_internal_partition_state_size()1765 inline int DeviceState::_internal_partition_state_size() const {
1766 return _impl_.partition_state_.size();
1767 }
partition_state_size()1768 inline int DeviceState::partition_state_size() const {
1769 return _internal_partition_state_size();
1770 }
clear_partition_state()1771 inline void DeviceState::clear_partition_state() {
1772 _impl_.partition_state_.Clear();
1773 }
mutable_partition_state(int index)1774 inline ::build::tools::releasetools::PartitionState* DeviceState::mutable_partition_state(int index) {
1775 // @@protoc_insertion_point(field_mutable:build.tools.releasetools.DeviceState.partition_state)
1776 return _impl_.partition_state_.Mutable(index);
1777 }
1778 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::build::tools::releasetools::PartitionState >*
mutable_partition_state()1779 DeviceState::mutable_partition_state() {
1780 // @@protoc_insertion_point(field_mutable_list:build.tools.releasetools.DeviceState.partition_state)
1781 return &_impl_.partition_state_;
1782 }
_internal_partition_state(int index)1783 inline const ::build::tools::releasetools::PartitionState& DeviceState::_internal_partition_state(int index) const {
1784 return _impl_.partition_state_.Get(index);
1785 }
partition_state(int index)1786 inline const ::build::tools::releasetools::PartitionState& DeviceState::partition_state(int index) const {
1787 // @@protoc_insertion_point(field_get:build.tools.releasetools.DeviceState.partition_state)
1788 return _internal_partition_state(index);
1789 }
_internal_add_partition_state()1790 inline ::build::tools::releasetools::PartitionState* DeviceState::_internal_add_partition_state() {
1791 return _impl_.partition_state_.Add();
1792 }
add_partition_state()1793 inline ::build::tools::releasetools::PartitionState* DeviceState::add_partition_state() {
1794 ::build::tools::releasetools::PartitionState* _add = _internal_add_partition_state();
1795 // @@protoc_insertion_point(field_add:build.tools.releasetools.DeviceState.partition_state)
1796 return _add;
1797 }
1798 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::build::tools::releasetools::PartitionState >&
partition_state()1799 DeviceState::partition_state() const {
1800 // @@protoc_insertion_point(field_list:build.tools.releasetools.DeviceState.partition_state)
1801 return _impl_.partition_state_;
1802 }
1803
1804 // -------------------------------------------------------------------
1805
1806 // ApexInfo
1807
1808 // string package_name = 1;
clear_package_name()1809 inline void ApexInfo::clear_package_name() {
1810 _impl_.package_name_.ClearToEmpty();
1811 }
package_name()1812 inline const std::string& ApexInfo::package_name() const {
1813 // @@protoc_insertion_point(field_get:build.tools.releasetools.ApexInfo.package_name)
1814 return _internal_package_name();
1815 }
1816 template <typename ArgT0, typename... ArgT>
1817 inline PROTOBUF_ALWAYS_INLINE
set_package_name(ArgT0 && arg0,ArgT...args)1818 void ApexInfo::set_package_name(ArgT0&& arg0, ArgT... args) {
1819
1820 _impl_.package_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
1821 // @@protoc_insertion_point(field_set:build.tools.releasetools.ApexInfo.package_name)
1822 }
mutable_package_name()1823 inline std::string* ApexInfo::mutable_package_name() {
1824 std::string* _s = _internal_mutable_package_name();
1825 // @@protoc_insertion_point(field_mutable:build.tools.releasetools.ApexInfo.package_name)
1826 return _s;
1827 }
_internal_package_name()1828 inline const std::string& ApexInfo::_internal_package_name() const {
1829 return _impl_.package_name_.Get();
1830 }
_internal_set_package_name(const std::string & value)1831 inline void ApexInfo::_internal_set_package_name(const std::string& value) {
1832
1833 _impl_.package_name_.Set(value, GetArenaForAllocation());
1834 }
_internal_mutable_package_name()1835 inline std::string* ApexInfo::_internal_mutable_package_name() {
1836
1837 return _impl_.package_name_.Mutable(GetArenaForAllocation());
1838 }
release_package_name()1839 inline std::string* ApexInfo::release_package_name() {
1840 // @@protoc_insertion_point(field_release:build.tools.releasetools.ApexInfo.package_name)
1841 return _impl_.package_name_.Release();
1842 }
set_allocated_package_name(std::string * package_name)1843 inline void ApexInfo::set_allocated_package_name(std::string* package_name) {
1844 _impl_.package_name_.SetAllocated(package_name, GetArenaForAllocation());
1845 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1846 if (_impl_.package_name_.IsDefault()) {
1847 _impl_.package_name_.Set("", GetArenaForAllocation());
1848 }
1849 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1850 // @@protoc_insertion_point(field_set_allocated:build.tools.releasetools.ApexInfo.package_name)
1851 }
1852
1853 // int64 version = 2;
clear_version()1854 inline void ApexInfo::clear_version() {
1855 _impl_.version_ = ::int64_t{0};
1856 }
_internal_version()1857 inline ::int64_t ApexInfo::_internal_version() const {
1858 return _impl_.version_;
1859 }
version()1860 inline ::int64_t ApexInfo::version() const {
1861 // @@protoc_insertion_point(field_get:build.tools.releasetools.ApexInfo.version)
1862 return _internal_version();
1863 }
_internal_set_version(::int64_t value)1864 inline void ApexInfo::_internal_set_version(::int64_t value) {
1865
1866 _impl_.version_ = value;
1867 }
set_version(::int64_t value)1868 inline void ApexInfo::set_version(::int64_t value) {
1869 _internal_set_version(value);
1870 // @@protoc_insertion_point(field_set:build.tools.releasetools.ApexInfo.version)
1871 }
1872
1873 // bool is_compressed = 3;
clear_is_compressed()1874 inline void ApexInfo::clear_is_compressed() {
1875 _impl_.is_compressed_ = false;
1876 }
_internal_is_compressed()1877 inline bool ApexInfo::_internal_is_compressed() const {
1878 return _impl_.is_compressed_;
1879 }
is_compressed()1880 inline bool ApexInfo::is_compressed() const {
1881 // @@protoc_insertion_point(field_get:build.tools.releasetools.ApexInfo.is_compressed)
1882 return _internal_is_compressed();
1883 }
_internal_set_is_compressed(bool value)1884 inline void ApexInfo::_internal_set_is_compressed(bool value) {
1885
1886 _impl_.is_compressed_ = value;
1887 }
set_is_compressed(bool value)1888 inline void ApexInfo::set_is_compressed(bool value) {
1889 _internal_set_is_compressed(value);
1890 // @@protoc_insertion_point(field_set:build.tools.releasetools.ApexInfo.is_compressed)
1891 }
1892
1893 // int64 decompressed_size = 4;
clear_decompressed_size()1894 inline void ApexInfo::clear_decompressed_size() {
1895 _impl_.decompressed_size_ = ::int64_t{0};
1896 }
_internal_decompressed_size()1897 inline ::int64_t ApexInfo::_internal_decompressed_size() const {
1898 return _impl_.decompressed_size_;
1899 }
decompressed_size()1900 inline ::int64_t ApexInfo::decompressed_size() const {
1901 // @@protoc_insertion_point(field_get:build.tools.releasetools.ApexInfo.decompressed_size)
1902 return _internal_decompressed_size();
1903 }
_internal_set_decompressed_size(::int64_t value)1904 inline void ApexInfo::_internal_set_decompressed_size(::int64_t value) {
1905
1906 _impl_.decompressed_size_ = value;
1907 }
set_decompressed_size(::int64_t value)1908 inline void ApexInfo::set_decompressed_size(::int64_t value) {
1909 _internal_set_decompressed_size(value);
1910 // @@protoc_insertion_point(field_set:build.tools.releasetools.ApexInfo.decompressed_size)
1911 }
1912
1913 // int64 source_version = 5;
clear_source_version()1914 inline void ApexInfo::clear_source_version() {
1915 _impl_.source_version_ = ::int64_t{0};
1916 }
_internal_source_version()1917 inline ::int64_t ApexInfo::_internal_source_version() const {
1918 return _impl_.source_version_;
1919 }
source_version()1920 inline ::int64_t ApexInfo::source_version() const {
1921 // @@protoc_insertion_point(field_get:build.tools.releasetools.ApexInfo.source_version)
1922 return _internal_source_version();
1923 }
_internal_set_source_version(::int64_t value)1924 inline void ApexInfo::_internal_set_source_version(::int64_t value) {
1925
1926 _impl_.source_version_ = value;
1927 }
set_source_version(::int64_t value)1928 inline void ApexInfo::set_source_version(::int64_t value) {
1929 _internal_set_source_version(value);
1930 // @@protoc_insertion_point(field_set:build.tools.releasetools.ApexInfo.source_version)
1931 }
1932
1933 // -------------------------------------------------------------------
1934
1935 // ApexMetadata
1936
1937 // repeated .build.tools.releasetools.ApexInfo apex_info = 1;
_internal_apex_info_size()1938 inline int ApexMetadata::_internal_apex_info_size() const {
1939 return _impl_.apex_info_.size();
1940 }
apex_info_size()1941 inline int ApexMetadata::apex_info_size() const {
1942 return _internal_apex_info_size();
1943 }
clear_apex_info()1944 inline void ApexMetadata::clear_apex_info() {
1945 _impl_.apex_info_.Clear();
1946 }
mutable_apex_info(int index)1947 inline ::build::tools::releasetools::ApexInfo* ApexMetadata::mutable_apex_info(int index) {
1948 // @@protoc_insertion_point(field_mutable:build.tools.releasetools.ApexMetadata.apex_info)
1949 return _impl_.apex_info_.Mutable(index);
1950 }
1951 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::build::tools::releasetools::ApexInfo >*
mutable_apex_info()1952 ApexMetadata::mutable_apex_info() {
1953 // @@protoc_insertion_point(field_mutable_list:build.tools.releasetools.ApexMetadata.apex_info)
1954 return &_impl_.apex_info_;
1955 }
_internal_apex_info(int index)1956 inline const ::build::tools::releasetools::ApexInfo& ApexMetadata::_internal_apex_info(int index) const {
1957 return _impl_.apex_info_.Get(index);
1958 }
apex_info(int index)1959 inline const ::build::tools::releasetools::ApexInfo& ApexMetadata::apex_info(int index) const {
1960 // @@protoc_insertion_point(field_get:build.tools.releasetools.ApexMetadata.apex_info)
1961 return _internal_apex_info(index);
1962 }
_internal_add_apex_info()1963 inline ::build::tools::releasetools::ApexInfo* ApexMetadata::_internal_add_apex_info() {
1964 return _impl_.apex_info_.Add();
1965 }
add_apex_info()1966 inline ::build::tools::releasetools::ApexInfo* ApexMetadata::add_apex_info() {
1967 ::build::tools::releasetools::ApexInfo* _add = _internal_add_apex_info();
1968 // @@protoc_insertion_point(field_add:build.tools.releasetools.ApexMetadata.apex_info)
1969 return _add;
1970 }
1971 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::build::tools::releasetools::ApexInfo >&
apex_info()1972 ApexMetadata::apex_info() const {
1973 // @@protoc_insertion_point(field_list:build.tools.releasetools.ApexMetadata.apex_info)
1974 return _impl_.apex_info_;
1975 }
1976
1977 // -------------------------------------------------------------------
1978
1979 // -------------------------------------------------------------------
1980
1981 // OtaMetadata
1982
1983 // .build.tools.releasetools.OtaMetadata.OtaType type = 1;
clear_type()1984 inline void OtaMetadata::clear_type() {
1985 _impl_.type_ = 0;
1986 }
_internal_type()1987 inline ::build::tools::releasetools::OtaMetadata_OtaType OtaMetadata::_internal_type() const {
1988 return static_cast< ::build::tools::releasetools::OtaMetadata_OtaType >(_impl_.type_);
1989 }
type()1990 inline ::build::tools::releasetools::OtaMetadata_OtaType OtaMetadata::type() const {
1991 // @@protoc_insertion_point(field_get:build.tools.releasetools.OtaMetadata.type)
1992 return _internal_type();
1993 }
_internal_set_type(::build::tools::releasetools::OtaMetadata_OtaType value)1994 inline void OtaMetadata::_internal_set_type(::build::tools::releasetools::OtaMetadata_OtaType value) {
1995
1996 _impl_.type_ = value;
1997 }
set_type(::build::tools::releasetools::OtaMetadata_OtaType value)1998 inline void OtaMetadata::set_type(::build::tools::releasetools::OtaMetadata_OtaType value) {
1999 _internal_set_type(value);
2000 // @@protoc_insertion_point(field_set:build.tools.releasetools.OtaMetadata.type)
2001 }
2002
2003 // bool wipe = 2;
clear_wipe()2004 inline void OtaMetadata::clear_wipe() {
2005 _impl_.wipe_ = false;
2006 }
_internal_wipe()2007 inline bool OtaMetadata::_internal_wipe() const {
2008 return _impl_.wipe_;
2009 }
wipe()2010 inline bool OtaMetadata::wipe() const {
2011 // @@protoc_insertion_point(field_get:build.tools.releasetools.OtaMetadata.wipe)
2012 return _internal_wipe();
2013 }
_internal_set_wipe(bool value)2014 inline void OtaMetadata::_internal_set_wipe(bool value) {
2015
2016 _impl_.wipe_ = value;
2017 }
set_wipe(bool value)2018 inline void OtaMetadata::set_wipe(bool value) {
2019 _internal_set_wipe(value);
2020 // @@protoc_insertion_point(field_set:build.tools.releasetools.OtaMetadata.wipe)
2021 }
2022
2023 // bool downgrade = 3;
clear_downgrade()2024 inline void OtaMetadata::clear_downgrade() {
2025 _impl_.downgrade_ = false;
2026 }
_internal_downgrade()2027 inline bool OtaMetadata::_internal_downgrade() const {
2028 return _impl_.downgrade_;
2029 }
downgrade()2030 inline bool OtaMetadata::downgrade() const {
2031 // @@protoc_insertion_point(field_get:build.tools.releasetools.OtaMetadata.downgrade)
2032 return _internal_downgrade();
2033 }
_internal_set_downgrade(bool value)2034 inline void OtaMetadata::_internal_set_downgrade(bool value) {
2035
2036 _impl_.downgrade_ = value;
2037 }
set_downgrade(bool value)2038 inline void OtaMetadata::set_downgrade(bool value) {
2039 _internal_set_downgrade(value);
2040 // @@protoc_insertion_point(field_set:build.tools.releasetools.OtaMetadata.downgrade)
2041 }
2042
2043 // map<string, string> property_files = 4;
_internal_property_files_size()2044 inline int OtaMetadata::_internal_property_files_size() const {
2045 return _impl_.property_files_.size();
2046 }
property_files_size()2047 inline int OtaMetadata::property_files_size() const {
2048 return _internal_property_files_size();
2049 }
clear_property_files()2050 inline void OtaMetadata::clear_property_files() {
2051 _impl_.property_files_.Clear();
2052 }
2053 inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >&
_internal_property_files()2054 OtaMetadata::_internal_property_files() const {
2055 return _impl_.property_files_.GetMap();
2056 }
2057 inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >&
property_files()2058 OtaMetadata::property_files() const {
2059 // @@protoc_insertion_point(field_map:build.tools.releasetools.OtaMetadata.property_files)
2060 return _internal_property_files();
2061 }
2062 inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >*
_internal_mutable_property_files()2063 OtaMetadata::_internal_mutable_property_files() {
2064 return _impl_.property_files_.MutableMap();
2065 }
2066 inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >*
mutable_property_files()2067 OtaMetadata::mutable_property_files() {
2068 // @@protoc_insertion_point(field_mutable_map:build.tools.releasetools.OtaMetadata.property_files)
2069 return _internal_mutable_property_files();
2070 }
2071
2072 // .build.tools.releasetools.DeviceState precondition = 5;
_internal_has_precondition()2073 inline bool OtaMetadata::_internal_has_precondition() const {
2074 return this != internal_default_instance() && _impl_.precondition_ != nullptr;
2075 }
has_precondition()2076 inline bool OtaMetadata::has_precondition() const {
2077 return _internal_has_precondition();
2078 }
clear_precondition()2079 inline void OtaMetadata::clear_precondition() {
2080 if (GetArenaForAllocation() == nullptr && _impl_.precondition_ != nullptr) {
2081 delete _impl_.precondition_;
2082 }
2083 _impl_.precondition_ = nullptr;
2084 }
_internal_precondition()2085 inline const ::build::tools::releasetools::DeviceState& OtaMetadata::_internal_precondition() const {
2086 const ::build::tools::releasetools::DeviceState* p = _impl_.precondition_;
2087 return p != nullptr ? *p : reinterpret_cast<const ::build::tools::releasetools::DeviceState&>(
2088 ::build::tools::releasetools::_DeviceState_default_instance_);
2089 }
precondition()2090 inline const ::build::tools::releasetools::DeviceState& OtaMetadata::precondition() const {
2091 // @@protoc_insertion_point(field_get:build.tools.releasetools.OtaMetadata.precondition)
2092 return _internal_precondition();
2093 }
unsafe_arena_set_allocated_precondition(::build::tools::releasetools::DeviceState * precondition)2094 inline void OtaMetadata::unsafe_arena_set_allocated_precondition(
2095 ::build::tools::releasetools::DeviceState* precondition) {
2096 if (GetArenaForAllocation() == nullptr) {
2097 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.precondition_);
2098 }
2099 _impl_.precondition_ = precondition;
2100 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:build.tools.releasetools.OtaMetadata.precondition)
2101 }
release_precondition()2102 inline ::build::tools::releasetools::DeviceState* OtaMetadata::release_precondition() {
2103
2104 ::build::tools::releasetools::DeviceState* temp = _impl_.precondition_;
2105 _impl_.precondition_ = nullptr;
2106 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
2107 auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
2108 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
2109 if (GetArenaForAllocation() == nullptr) { delete old; }
2110 #else // PROTOBUF_FORCE_COPY_IN_RELEASE
2111 if (GetArenaForAllocation() != nullptr) {
2112 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
2113 }
2114 #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
2115 return temp;
2116 }
unsafe_arena_release_precondition()2117 inline ::build::tools::releasetools::DeviceState* OtaMetadata::unsafe_arena_release_precondition() {
2118 // @@protoc_insertion_point(field_release:build.tools.releasetools.OtaMetadata.precondition)
2119
2120 ::build::tools::releasetools::DeviceState* temp = _impl_.precondition_;
2121 _impl_.precondition_ = nullptr;
2122 return temp;
2123 }
_internal_mutable_precondition()2124 inline ::build::tools::releasetools::DeviceState* OtaMetadata::_internal_mutable_precondition() {
2125
2126 if (_impl_.precondition_ == nullptr) {
2127 auto* p = CreateMaybeMessage<::build::tools::releasetools::DeviceState>(GetArenaForAllocation());
2128 _impl_.precondition_ = p;
2129 }
2130 return _impl_.precondition_;
2131 }
mutable_precondition()2132 inline ::build::tools::releasetools::DeviceState* OtaMetadata::mutable_precondition() {
2133 ::build::tools::releasetools::DeviceState* _msg = _internal_mutable_precondition();
2134 // @@protoc_insertion_point(field_mutable:build.tools.releasetools.OtaMetadata.precondition)
2135 return _msg;
2136 }
set_allocated_precondition(::build::tools::releasetools::DeviceState * precondition)2137 inline void OtaMetadata::set_allocated_precondition(::build::tools::releasetools::DeviceState* precondition) {
2138 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
2139 if (message_arena == nullptr) {
2140 delete _impl_.precondition_;
2141 }
2142 if (precondition) {
2143 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
2144 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(precondition);
2145 if (message_arena != submessage_arena) {
2146 precondition = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
2147 message_arena, precondition, submessage_arena);
2148 }
2149
2150 } else {
2151
2152 }
2153 _impl_.precondition_ = precondition;
2154 // @@protoc_insertion_point(field_set_allocated:build.tools.releasetools.OtaMetadata.precondition)
2155 }
2156
2157 // .build.tools.releasetools.DeviceState postcondition = 6;
_internal_has_postcondition()2158 inline bool OtaMetadata::_internal_has_postcondition() const {
2159 return this != internal_default_instance() && _impl_.postcondition_ != nullptr;
2160 }
has_postcondition()2161 inline bool OtaMetadata::has_postcondition() const {
2162 return _internal_has_postcondition();
2163 }
clear_postcondition()2164 inline void OtaMetadata::clear_postcondition() {
2165 if (GetArenaForAllocation() == nullptr && _impl_.postcondition_ != nullptr) {
2166 delete _impl_.postcondition_;
2167 }
2168 _impl_.postcondition_ = nullptr;
2169 }
_internal_postcondition()2170 inline const ::build::tools::releasetools::DeviceState& OtaMetadata::_internal_postcondition() const {
2171 const ::build::tools::releasetools::DeviceState* p = _impl_.postcondition_;
2172 return p != nullptr ? *p : reinterpret_cast<const ::build::tools::releasetools::DeviceState&>(
2173 ::build::tools::releasetools::_DeviceState_default_instance_);
2174 }
postcondition()2175 inline const ::build::tools::releasetools::DeviceState& OtaMetadata::postcondition() const {
2176 // @@protoc_insertion_point(field_get:build.tools.releasetools.OtaMetadata.postcondition)
2177 return _internal_postcondition();
2178 }
unsafe_arena_set_allocated_postcondition(::build::tools::releasetools::DeviceState * postcondition)2179 inline void OtaMetadata::unsafe_arena_set_allocated_postcondition(
2180 ::build::tools::releasetools::DeviceState* postcondition) {
2181 if (GetArenaForAllocation() == nullptr) {
2182 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.postcondition_);
2183 }
2184 _impl_.postcondition_ = postcondition;
2185 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:build.tools.releasetools.OtaMetadata.postcondition)
2186 }
release_postcondition()2187 inline ::build::tools::releasetools::DeviceState* OtaMetadata::release_postcondition() {
2188
2189 ::build::tools::releasetools::DeviceState* temp = _impl_.postcondition_;
2190 _impl_.postcondition_ = nullptr;
2191 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
2192 auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
2193 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
2194 if (GetArenaForAllocation() == nullptr) { delete old; }
2195 #else // PROTOBUF_FORCE_COPY_IN_RELEASE
2196 if (GetArenaForAllocation() != nullptr) {
2197 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
2198 }
2199 #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
2200 return temp;
2201 }
unsafe_arena_release_postcondition()2202 inline ::build::tools::releasetools::DeviceState* OtaMetadata::unsafe_arena_release_postcondition() {
2203 // @@protoc_insertion_point(field_release:build.tools.releasetools.OtaMetadata.postcondition)
2204
2205 ::build::tools::releasetools::DeviceState* temp = _impl_.postcondition_;
2206 _impl_.postcondition_ = nullptr;
2207 return temp;
2208 }
_internal_mutable_postcondition()2209 inline ::build::tools::releasetools::DeviceState* OtaMetadata::_internal_mutable_postcondition() {
2210
2211 if (_impl_.postcondition_ == nullptr) {
2212 auto* p = CreateMaybeMessage<::build::tools::releasetools::DeviceState>(GetArenaForAllocation());
2213 _impl_.postcondition_ = p;
2214 }
2215 return _impl_.postcondition_;
2216 }
mutable_postcondition()2217 inline ::build::tools::releasetools::DeviceState* OtaMetadata::mutable_postcondition() {
2218 ::build::tools::releasetools::DeviceState* _msg = _internal_mutable_postcondition();
2219 // @@protoc_insertion_point(field_mutable:build.tools.releasetools.OtaMetadata.postcondition)
2220 return _msg;
2221 }
set_allocated_postcondition(::build::tools::releasetools::DeviceState * postcondition)2222 inline void OtaMetadata::set_allocated_postcondition(::build::tools::releasetools::DeviceState* postcondition) {
2223 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
2224 if (message_arena == nullptr) {
2225 delete _impl_.postcondition_;
2226 }
2227 if (postcondition) {
2228 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
2229 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(postcondition);
2230 if (message_arena != submessage_arena) {
2231 postcondition = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
2232 message_arena, postcondition, submessage_arena);
2233 }
2234
2235 } else {
2236
2237 }
2238 _impl_.postcondition_ = postcondition;
2239 // @@protoc_insertion_point(field_set_allocated:build.tools.releasetools.OtaMetadata.postcondition)
2240 }
2241
2242 // bool retrofit_dynamic_partitions = 7;
clear_retrofit_dynamic_partitions()2243 inline void OtaMetadata::clear_retrofit_dynamic_partitions() {
2244 _impl_.retrofit_dynamic_partitions_ = false;
2245 }
_internal_retrofit_dynamic_partitions()2246 inline bool OtaMetadata::_internal_retrofit_dynamic_partitions() const {
2247 return _impl_.retrofit_dynamic_partitions_;
2248 }
retrofit_dynamic_partitions()2249 inline bool OtaMetadata::retrofit_dynamic_partitions() const {
2250 // @@protoc_insertion_point(field_get:build.tools.releasetools.OtaMetadata.retrofit_dynamic_partitions)
2251 return _internal_retrofit_dynamic_partitions();
2252 }
_internal_set_retrofit_dynamic_partitions(bool value)2253 inline void OtaMetadata::_internal_set_retrofit_dynamic_partitions(bool value) {
2254
2255 _impl_.retrofit_dynamic_partitions_ = value;
2256 }
set_retrofit_dynamic_partitions(bool value)2257 inline void OtaMetadata::set_retrofit_dynamic_partitions(bool value) {
2258 _internal_set_retrofit_dynamic_partitions(value);
2259 // @@protoc_insertion_point(field_set:build.tools.releasetools.OtaMetadata.retrofit_dynamic_partitions)
2260 }
2261
2262 // int64 required_cache = 8;
clear_required_cache()2263 inline void OtaMetadata::clear_required_cache() {
2264 _impl_.required_cache_ = ::int64_t{0};
2265 }
_internal_required_cache()2266 inline ::int64_t OtaMetadata::_internal_required_cache() const {
2267 return _impl_.required_cache_;
2268 }
required_cache()2269 inline ::int64_t OtaMetadata::required_cache() const {
2270 // @@protoc_insertion_point(field_get:build.tools.releasetools.OtaMetadata.required_cache)
2271 return _internal_required_cache();
2272 }
_internal_set_required_cache(::int64_t value)2273 inline void OtaMetadata::_internal_set_required_cache(::int64_t value) {
2274
2275 _impl_.required_cache_ = value;
2276 }
set_required_cache(::int64_t value)2277 inline void OtaMetadata::set_required_cache(::int64_t value) {
2278 _internal_set_required_cache(value);
2279 // @@protoc_insertion_point(field_set:build.tools.releasetools.OtaMetadata.required_cache)
2280 }
2281
2282 // bool spl_downgrade = 9;
clear_spl_downgrade()2283 inline void OtaMetadata::clear_spl_downgrade() {
2284 _impl_.spl_downgrade_ = false;
2285 }
_internal_spl_downgrade()2286 inline bool OtaMetadata::_internal_spl_downgrade() const {
2287 return _impl_.spl_downgrade_;
2288 }
spl_downgrade()2289 inline bool OtaMetadata::spl_downgrade() const {
2290 // @@protoc_insertion_point(field_get:build.tools.releasetools.OtaMetadata.spl_downgrade)
2291 return _internal_spl_downgrade();
2292 }
_internal_set_spl_downgrade(bool value)2293 inline void OtaMetadata::_internal_set_spl_downgrade(bool value) {
2294
2295 _impl_.spl_downgrade_ = value;
2296 }
set_spl_downgrade(bool value)2297 inline void OtaMetadata::set_spl_downgrade(bool value) {
2298 _internal_set_spl_downgrade(value);
2299 // @@protoc_insertion_point(field_set:build.tools.releasetools.OtaMetadata.spl_downgrade)
2300 }
2301
2302 #ifdef __GNUC__
2303 #pragma GCC diagnostic pop
2304 #endif // __GNUC__
2305 // -------------------------------------------------------------------
2306
2307 // -------------------------------------------------------------------
2308
2309 // -------------------------------------------------------------------
2310
2311 // -------------------------------------------------------------------
2312
2313 // -------------------------------------------------------------------
2314
2315
2316 // @@protoc_insertion_point(namespace_scope)
2317
2318 } // namespace releasetools
2319 } // namespace tools
2320 } // namespace build
2321
2322 PROTOBUF_NAMESPACE_OPEN
2323
2324 template <> struct is_proto_enum< ::build::tools::releasetools::OtaMetadata_OtaType> : ::std::true_type {};
2325
2326 PROTOBUF_NAMESPACE_CLOSE
2327
2328 // @@protoc_insertion_point(global_scope)
2329
2330 #include <google/protobuf/port_undef.inc>
2331 #endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_ota_5fmetadata_2eproto
2332