1 // Generated by the protocol buffer compiler. DO NOT EDIT!
2 // source: packages/modules/ConfigInfrastructure/aconfigd/proto/aconfigd.proto
3
4 #ifndef GOOGLE_PROTOBUF_INCLUDED_packages_2fmodules_2fConfigInfrastructure_2faconfigd_2fproto_2faconfigd_2eproto
5 #define GOOGLE_PROTOBUF_INCLUDED_packages_2fmodules_2fConfigInfrastructure_2faconfigd_2fproto_2faconfigd_2eproto
6
7 #include <cstdint>
8 #include <limits>
9 #include <string>
10
11 #include <google/protobuf/port_def.inc>
12 #if PROTOBUF_VERSION < 3021000
13 #error This file was generated by a newer version of protoc which is
14 #error incompatible with your Protocol Buffer headers. Please update
15 #error your headers.
16 #endif
17 #if 3021012 < PROTOBUF_MIN_PROTOC_VERSION
18 #error This file was generated by an older version of protoc which is
19 #error incompatible with your Protocol Buffer headers. Please
20 #error regenerate this file with a newer version of protoc.
21 #endif
22
23 #include <google/protobuf/port_undef.inc>
24 #include <google/protobuf/io/coded_stream.h>
25 #include <google/protobuf/arena.h>
26 #include <google/protobuf/arenastring.h>
27 #include <google/protobuf/generated_message_util.h>
28 #include <google/protobuf/metadata_lite.h>
29 #include <google/protobuf/message_lite.h>
30 #include <google/protobuf/repeated_field.h> // IWYU pragma: export
31 #include <google/protobuf/extension_set.h> // IWYU pragma: export
32 #include <google/protobuf/generated_enum_util.h>
33 // @@protoc_insertion_point(includes)
34 #include <google/protobuf/port_def.inc>
35 #define PROTOBUF_INTERNAL_EXPORT_packages_2fmodules_2fConfigInfrastructure_2faconfigd_2fproto_2faconfigd_2eproto
36 PROTOBUF_NAMESPACE_OPEN
37 namespace internal {
38 class AnyMetadata;
39 } // namespace internal
40 PROTOBUF_NAMESPACE_CLOSE
41
42 // Internal implementation detail -- do not use these members.
43 struct TableStruct_packages_2fmodules_2fConfigInfrastructure_2faconfigd_2fproto_2faconfigd_2eproto {
44 static const ::uint32_t offsets[];
45 };
46 namespace android {
47 namespace aconfigd {
48 class FlagOverride;
49 struct FlagOverrideDefaultTypeInternal;
50 extern FlagOverrideDefaultTypeInternal _FlagOverride_default_instance_;
51 class LocalFlagOverrides;
52 struct LocalFlagOverridesDefaultTypeInternal;
53 extern LocalFlagOverridesDefaultTypeInternal _LocalFlagOverrides_default_instance_;
54 class PersistStorageRecord;
55 struct PersistStorageRecordDefaultTypeInternal;
56 extern PersistStorageRecordDefaultTypeInternal _PersistStorageRecord_default_instance_;
57 class PersistStorageRecords;
58 struct PersistStorageRecordsDefaultTypeInternal;
59 extern PersistStorageRecordsDefaultTypeInternal _PersistStorageRecords_default_instance_;
60 class StorageRequestMessage;
61 struct StorageRequestMessageDefaultTypeInternal;
62 extern StorageRequestMessageDefaultTypeInternal _StorageRequestMessage_default_instance_;
63 class StorageRequestMessage_FlagOverrideMessage;
64 struct StorageRequestMessage_FlagOverrideMessageDefaultTypeInternal;
65 extern StorageRequestMessage_FlagOverrideMessageDefaultTypeInternal _StorageRequestMessage_FlagOverrideMessage_default_instance_;
66 class StorageRequestMessage_FlagQueryMessage;
67 struct StorageRequestMessage_FlagQueryMessageDefaultTypeInternal;
68 extern StorageRequestMessage_FlagQueryMessageDefaultTypeInternal _StorageRequestMessage_FlagQueryMessage_default_instance_;
69 class StorageRequestMessage_ListStorageMessage;
70 struct StorageRequestMessage_ListStorageMessageDefaultTypeInternal;
71 extern StorageRequestMessage_ListStorageMessageDefaultTypeInternal _StorageRequestMessage_ListStorageMessage_default_instance_;
72 class StorageRequestMessage_NewStorageMessage;
73 struct StorageRequestMessage_NewStorageMessageDefaultTypeInternal;
74 extern StorageRequestMessage_NewStorageMessageDefaultTypeInternal _StorageRequestMessage_NewStorageMessage_default_instance_;
75 class StorageRequestMessage_OTAFlagStagingMessage;
76 struct StorageRequestMessage_OTAFlagStagingMessageDefaultTypeInternal;
77 extern StorageRequestMessage_OTAFlagStagingMessageDefaultTypeInternal _StorageRequestMessage_OTAFlagStagingMessage_default_instance_;
78 class StorageRequestMessage_RemoveLocalOverrideMessage;
79 struct StorageRequestMessage_RemoveLocalOverrideMessageDefaultTypeInternal;
80 extern StorageRequestMessage_RemoveLocalOverrideMessageDefaultTypeInternal _StorageRequestMessage_RemoveLocalOverrideMessage_default_instance_;
81 class StorageRequestMessage_ResetStorageMessage;
82 struct StorageRequestMessage_ResetStorageMessageDefaultTypeInternal;
83 extern StorageRequestMessage_ResetStorageMessageDefaultTypeInternal _StorageRequestMessage_ResetStorageMessage_default_instance_;
84 class StorageRequestMessages;
85 struct StorageRequestMessagesDefaultTypeInternal;
86 extern StorageRequestMessagesDefaultTypeInternal _StorageRequestMessages_default_instance_;
87 class StorageReturnMessage;
88 struct StorageReturnMessageDefaultTypeInternal;
89 extern StorageReturnMessageDefaultTypeInternal _StorageReturnMessage_default_instance_;
90 class StorageReturnMessage_FlagOverrideReturnMessage;
91 struct StorageReturnMessage_FlagOverrideReturnMessageDefaultTypeInternal;
92 extern StorageReturnMessage_FlagOverrideReturnMessageDefaultTypeInternal _StorageReturnMessage_FlagOverrideReturnMessage_default_instance_;
93 class StorageReturnMessage_FlagQueryReturnMessage;
94 struct StorageReturnMessage_FlagQueryReturnMessageDefaultTypeInternal;
95 extern StorageReturnMessage_FlagQueryReturnMessageDefaultTypeInternal _StorageReturnMessage_FlagQueryReturnMessage_default_instance_;
96 class StorageReturnMessage_ListStorageReturnMessage;
97 struct StorageReturnMessage_ListStorageReturnMessageDefaultTypeInternal;
98 extern StorageReturnMessage_ListStorageReturnMessageDefaultTypeInternal _StorageReturnMessage_ListStorageReturnMessage_default_instance_;
99 class StorageReturnMessage_NewStorageReturnMessage;
100 struct StorageReturnMessage_NewStorageReturnMessageDefaultTypeInternal;
101 extern StorageReturnMessage_NewStorageReturnMessageDefaultTypeInternal _StorageReturnMessage_NewStorageReturnMessage_default_instance_;
102 class StorageReturnMessage_OTAFlagStagingReturnMessage;
103 struct StorageReturnMessage_OTAFlagStagingReturnMessageDefaultTypeInternal;
104 extern StorageReturnMessage_OTAFlagStagingReturnMessageDefaultTypeInternal _StorageReturnMessage_OTAFlagStagingReturnMessage_default_instance_;
105 class StorageReturnMessage_RemoveLocalOverrideReturnMessage;
106 struct StorageReturnMessage_RemoveLocalOverrideReturnMessageDefaultTypeInternal;
107 extern StorageReturnMessage_RemoveLocalOverrideReturnMessageDefaultTypeInternal _StorageReturnMessage_RemoveLocalOverrideReturnMessage_default_instance_;
108 class StorageReturnMessage_ResetStorageReturnMessage;
109 struct StorageReturnMessage_ResetStorageReturnMessageDefaultTypeInternal;
110 extern StorageReturnMessage_ResetStorageReturnMessageDefaultTypeInternal _StorageReturnMessage_ResetStorageReturnMessage_default_instance_;
111 class StorageReturnMessages;
112 struct StorageReturnMessagesDefaultTypeInternal;
113 extern StorageReturnMessagesDefaultTypeInternal _StorageReturnMessages_default_instance_;
114 } // namespace aconfigd
115 } // namespace android
116 PROTOBUF_NAMESPACE_OPEN
117 template<> ::android::aconfigd::FlagOverride* Arena::CreateMaybeMessage<::android::aconfigd::FlagOverride>(Arena*);
118 template<> ::android::aconfigd::LocalFlagOverrides* Arena::CreateMaybeMessage<::android::aconfigd::LocalFlagOverrides>(Arena*);
119 template<> ::android::aconfigd::PersistStorageRecord* Arena::CreateMaybeMessage<::android::aconfigd::PersistStorageRecord>(Arena*);
120 template<> ::android::aconfigd::PersistStorageRecords* Arena::CreateMaybeMessage<::android::aconfigd::PersistStorageRecords>(Arena*);
121 template<> ::android::aconfigd::StorageRequestMessage* Arena::CreateMaybeMessage<::android::aconfigd::StorageRequestMessage>(Arena*);
122 template<> ::android::aconfigd::StorageRequestMessage_FlagOverrideMessage* Arena::CreateMaybeMessage<::android::aconfigd::StorageRequestMessage_FlagOverrideMessage>(Arena*);
123 template<> ::android::aconfigd::StorageRequestMessage_FlagQueryMessage* Arena::CreateMaybeMessage<::android::aconfigd::StorageRequestMessage_FlagQueryMessage>(Arena*);
124 template<> ::android::aconfigd::StorageRequestMessage_ListStorageMessage* Arena::CreateMaybeMessage<::android::aconfigd::StorageRequestMessage_ListStorageMessage>(Arena*);
125 template<> ::android::aconfigd::StorageRequestMessage_NewStorageMessage* Arena::CreateMaybeMessage<::android::aconfigd::StorageRequestMessage_NewStorageMessage>(Arena*);
126 template<> ::android::aconfigd::StorageRequestMessage_OTAFlagStagingMessage* Arena::CreateMaybeMessage<::android::aconfigd::StorageRequestMessage_OTAFlagStagingMessage>(Arena*);
127 template<> ::android::aconfigd::StorageRequestMessage_RemoveLocalOverrideMessage* Arena::CreateMaybeMessage<::android::aconfigd::StorageRequestMessage_RemoveLocalOverrideMessage>(Arena*);
128 template<> ::android::aconfigd::StorageRequestMessage_ResetStorageMessage* Arena::CreateMaybeMessage<::android::aconfigd::StorageRequestMessage_ResetStorageMessage>(Arena*);
129 template<> ::android::aconfigd::StorageRequestMessages* Arena::CreateMaybeMessage<::android::aconfigd::StorageRequestMessages>(Arena*);
130 template<> ::android::aconfigd::StorageReturnMessage* Arena::CreateMaybeMessage<::android::aconfigd::StorageReturnMessage>(Arena*);
131 template<> ::android::aconfigd::StorageReturnMessage_FlagOverrideReturnMessage* Arena::CreateMaybeMessage<::android::aconfigd::StorageReturnMessage_FlagOverrideReturnMessage>(Arena*);
132 template<> ::android::aconfigd::StorageReturnMessage_FlagQueryReturnMessage* Arena::CreateMaybeMessage<::android::aconfigd::StorageReturnMessage_FlagQueryReturnMessage>(Arena*);
133 template<> ::android::aconfigd::StorageReturnMessage_ListStorageReturnMessage* Arena::CreateMaybeMessage<::android::aconfigd::StorageReturnMessage_ListStorageReturnMessage>(Arena*);
134 template<> ::android::aconfigd::StorageReturnMessage_NewStorageReturnMessage* Arena::CreateMaybeMessage<::android::aconfigd::StorageReturnMessage_NewStorageReturnMessage>(Arena*);
135 template<> ::android::aconfigd::StorageReturnMessage_OTAFlagStagingReturnMessage* Arena::CreateMaybeMessage<::android::aconfigd::StorageReturnMessage_OTAFlagStagingReturnMessage>(Arena*);
136 template<> ::android::aconfigd::StorageReturnMessage_RemoveLocalOverrideReturnMessage* Arena::CreateMaybeMessage<::android::aconfigd::StorageReturnMessage_RemoveLocalOverrideReturnMessage>(Arena*);
137 template<> ::android::aconfigd::StorageReturnMessage_ResetStorageReturnMessage* Arena::CreateMaybeMessage<::android::aconfigd::StorageReturnMessage_ResetStorageReturnMessage>(Arena*);
138 template<> ::android::aconfigd::StorageReturnMessages* Arena::CreateMaybeMessage<::android::aconfigd::StorageReturnMessages>(Arena*);
139 PROTOBUF_NAMESPACE_CLOSE
140 namespace android {
141 namespace aconfigd {
142
143 enum StorageRequestMessage_FlagOverrideType : int {
144 StorageRequestMessage_FlagOverrideType_LOCAL_IMMEDIATE = 1,
145 StorageRequestMessage_FlagOverrideType_LOCAL_ON_REBOOT = 2,
146 StorageRequestMessage_FlagOverrideType_SERVER_ON_REBOOT = 3
147 };
148 bool StorageRequestMessage_FlagOverrideType_IsValid(int value);
149 constexpr StorageRequestMessage_FlagOverrideType StorageRequestMessage_FlagOverrideType_FlagOverrideType_MIN = StorageRequestMessage_FlagOverrideType_LOCAL_IMMEDIATE;
150 constexpr StorageRequestMessage_FlagOverrideType StorageRequestMessage_FlagOverrideType_FlagOverrideType_MAX = StorageRequestMessage_FlagOverrideType_SERVER_ON_REBOOT;
151 constexpr int StorageRequestMessage_FlagOverrideType_FlagOverrideType_ARRAYSIZE = StorageRequestMessage_FlagOverrideType_FlagOverrideType_MAX + 1;
152
153 const std::string& StorageRequestMessage_FlagOverrideType_Name(StorageRequestMessage_FlagOverrideType value);
154 template<typename T>
StorageRequestMessage_FlagOverrideType_Name(T enum_t_value)155 inline const std::string& StorageRequestMessage_FlagOverrideType_Name(T enum_t_value) {
156 static_assert(::std::is_same<T, StorageRequestMessage_FlagOverrideType>::value ||
157 ::std::is_integral<T>::value,
158 "Incorrect type passed to function StorageRequestMessage_FlagOverrideType_Name.");
159 return StorageRequestMessage_FlagOverrideType_Name(static_cast<StorageRequestMessage_FlagOverrideType>(enum_t_value));
160 }
161 bool StorageRequestMessage_FlagOverrideType_Parse(
162 ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, StorageRequestMessage_FlagOverrideType* value);
163 enum StorageRequestMessage_RemoveOverrideType : int {
164 StorageRequestMessage_RemoveOverrideType_REMOVE_LOCAL_IMMEDIATE = 1,
165 StorageRequestMessage_RemoveOverrideType_REMOVE_LOCAL_ON_REBOOT = 2
166 };
167 bool StorageRequestMessage_RemoveOverrideType_IsValid(int value);
168 constexpr StorageRequestMessage_RemoveOverrideType StorageRequestMessage_RemoveOverrideType_RemoveOverrideType_MIN = StorageRequestMessage_RemoveOverrideType_REMOVE_LOCAL_IMMEDIATE;
169 constexpr StorageRequestMessage_RemoveOverrideType StorageRequestMessage_RemoveOverrideType_RemoveOverrideType_MAX = StorageRequestMessage_RemoveOverrideType_REMOVE_LOCAL_ON_REBOOT;
170 constexpr int StorageRequestMessage_RemoveOverrideType_RemoveOverrideType_ARRAYSIZE = StorageRequestMessage_RemoveOverrideType_RemoveOverrideType_MAX + 1;
171
172 const std::string& StorageRequestMessage_RemoveOverrideType_Name(StorageRequestMessage_RemoveOverrideType value);
173 template<typename T>
StorageRequestMessage_RemoveOverrideType_Name(T enum_t_value)174 inline const std::string& StorageRequestMessage_RemoveOverrideType_Name(T enum_t_value) {
175 static_assert(::std::is_same<T, StorageRequestMessage_RemoveOverrideType>::value ||
176 ::std::is_integral<T>::value,
177 "Incorrect type passed to function StorageRequestMessage_RemoveOverrideType_Name.");
178 return StorageRequestMessage_RemoveOverrideType_Name(static_cast<StorageRequestMessage_RemoveOverrideType>(enum_t_value));
179 }
180 bool StorageRequestMessage_RemoveOverrideType_Parse(
181 ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, StorageRequestMessage_RemoveOverrideType* value);
182 // ===================================================================
183
184 class PersistStorageRecord final :
185 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:android.aconfigd.PersistStorageRecord) */ {
186 public:
PersistStorageRecord()187 inline PersistStorageRecord() : PersistStorageRecord(nullptr) {}
188 ~PersistStorageRecord() override;
189 explicit PROTOBUF_CONSTEXPR PersistStorageRecord(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
190
191 PersistStorageRecord(const PersistStorageRecord& from);
PersistStorageRecord(PersistStorageRecord && from)192 PersistStorageRecord(PersistStorageRecord&& from) noexcept
193 : PersistStorageRecord() {
194 *this = ::std::move(from);
195 }
196
197 inline PersistStorageRecord& operator=(const PersistStorageRecord& from) {
198 if (this == &from) return *this;
199 CopyFrom(from);
200 return *this;
201 }
202 inline PersistStorageRecord& operator=(PersistStorageRecord&& from) noexcept {
203 if (this == &from) return *this;
204 if (GetOwningArena() == from.GetOwningArena()
205 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
206 && GetOwningArena() != nullptr
207 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
208 ) {
209 InternalSwap(&from);
210 } else {
211 CopyFrom(from);
212 }
213 return *this;
214 }
215
unknown_fields()216 inline const std::string& unknown_fields() const {
217 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
218 }
mutable_unknown_fields()219 inline std::string* mutable_unknown_fields() {
220 return _internal_metadata_.mutable_unknown_fields<std::string>();
221 }
222
default_instance()223 static const PersistStorageRecord& default_instance() {
224 return *internal_default_instance();
225 }
internal_default_instance()226 static inline const PersistStorageRecord* internal_default_instance() {
227 return reinterpret_cast<const PersistStorageRecord*>(
228 &_PersistStorageRecord_default_instance_);
229 }
230 static constexpr int kIndexInFileMessages =
231 0;
232
swap(PersistStorageRecord & a,PersistStorageRecord & b)233 friend void swap(PersistStorageRecord& a, PersistStorageRecord& b) {
234 a.Swap(&b);
235 }
Swap(PersistStorageRecord * other)236 inline void Swap(PersistStorageRecord* other) {
237 if (other == this) return;
238 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
239 if (GetOwningArena() != nullptr &&
240 GetOwningArena() == other->GetOwningArena()) {
241 #else // PROTOBUF_FORCE_COPY_IN_SWAP
242 if (GetOwningArena() == other->GetOwningArena()) {
243 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
244 InternalSwap(other);
245 } else {
246 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
247 }
248 }
249 void UnsafeArenaSwap(PersistStorageRecord* other) {
250 if (other == this) return;
251 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
252 InternalSwap(other);
253 }
254
255 // implements Message ----------------------------------------------
256
257 PersistStorageRecord* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
258 return CreateMaybeMessage<PersistStorageRecord>(arena);
259 }
260 PersistStorageRecord* New() const {
261 return New(nullptr);
262 }
263 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
264 void CopyFrom(const PersistStorageRecord& from);
265 void MergeFrom(const PersistStorageRecord& from);
266 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
267 bool IsInitialized() const final;
268
269 size_t ByteSizeLong() const final;
270 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
271 ::uint8_t* _InternalSerialize(
272 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
273 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
274
275 private:
276 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
277 void SharedDtor();
278 void SetCachedSize(int size) const;
279 void InternalSwap(PersistStorageRecord* other);
280
281 private:
282 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
283 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
284 return "android.aconfigd.PersistStorageRecord";
285 }
286 protected:
287 explicit PersistStorageRecord(::PROTOBUF_NAMESPACE_ID::Arena* arena,
288 bool is_message_owned = false);
289 public:
290
291 std::string GetTypeName() const final;
292
293 // nested types ----------------------------------------------------
294
295 // accessors -------------------------------------------------------
296
297 enum : int {
298 kContainerFieldNumber = 2,
299 kPackageMapFieldNumber = 3,
300 kFlagMapFieldNumber = 4,
301 kFlagValFieldNumber = 5,
302 kDigestFieldNumber = 6,
303 kFlagInfoFieldNumber = 7,
304 kVersionFieldNumber = 1,
305 };
306 // optional string container = 2;
307 bool has_container() const;
308 private:
309 bool _internal_has_container() const;
310 public:
311 void clear_container();
312 const std::string& container() const;
313 template <typename ArgT0 = const std::string&, typename... ArgT>
314 void set_container(ArgT0&& arg0, ArgT... args);
315 std::string* mutable_container();
316 PROTOBUF_NODISCARD std::string* release_container();
317 void set_allocated_container(std::string* container);
318 private:
319 const std::string& _internal_container() const;
320 inline PROTOBUF_ALWAYS_INLINE void _internal_set_container(const std::string& value);
321 std::string* _internal_mutable_container();
322 public:
323
324 // optional string package_map = 3;
325 bool has_package_map() const;
326 private:
327 bool _internal_has_package_map() const;
328 public:
329 void clear_package_map();
330 const std::string& package_map() const;
331 template <typename ArgT0 = const std::string&, typename... ArgT>
332 void set_package_map(ArgT0&& arg0, ArgT... args);
333 std::string* mutable_package_map();
334 PROTOBUF_NODISCARD std::string* release_package_map();
335 void set_allocated_package_map(std::string* package_map);
336 private:
337 const std::string& _internal_package_map() const;
338 inline PROTOBUF_ALWAYS_INLINE void _internal_set_package_map(const std::string& value);
339 std::string* _internal_mutable_package_map();
340 public:
341
342 // optional string flag_map = 4;
343 bool has_flag_map() const;
344 private:
345 bool _internal_has_flag_map() const;
346 public:
347 void clear_flag_map();
348 const std::string& flag_map() const;
349 template <typename ArgT0 = const std::string&, typename... ArgT>
350 void set_flag_map(ArgT0&& arg0, ArgT... args);
351 std::string* mutable_flag_map();
352 PROTOBUF_NODISCARD std::string* release_flag_map();
353 void set_allocated_flag_map(std::string* flag_map);
354 private:
355 const std::string& _internal_flag_map() const;
356 inline PROTOBUF_ALWAYS_INLINE void _internal_set_flag_map(const std::string& value);
357 std::string* _internal_mutable_flag_map();
358 public:
359
360 // optional string flag_val = 5;
361 bool has_flag_val() const;
362 private:
363 bool _internal_has_flag_val() const;
364 public:
365 void clear_flag_val();
366 const std::string& flag_val() const;
367 template <typename ArgT0 = const std::string&, typename... ArgT>
368 void set_flag_val(ArgT0&& arg0, ArgT... args);
369 std::string* mutable_flag_val();
370 PROTOBUF_NODISCARD std::string* release_flag_val();
371 void set_allocated_flag_val(std::string* flag_val);
372 private:
373 const std::string& _internal_flag_val() const;
374 inline PROTOBUF_ALWAYS_INLINE void _internal_set_flag_val(const std::string& value);
375 std::string* _internal_mutable_flag_val();
376 public:
377
378 // optional string digest = 6;
379 bool has_digest() const;
380 private:
381 bool _internal_has_digest() const;
382 public:
383 void clear_digest();
384 const std::string& digest() const;
385 template <typename ArgT0 = const std::string&, typename... ArgT>
386 void set_digest(ArgT0&& arg0, ArgT... args);
387 std::string* mutable_digest();
388 PROTOBUF_NODISCARD std::string* release_digest();
389 void set_allocated_digest(std::string* digest);
390 private:
391 const std::string& _internal_digest() const;
392 inline PROTOBUF_ALWAYS_INLINE void _internal_set_digest(const std::string& value);
393 std::string* _internal_mutable_digest();
394 public:
395
396 // optional string flag_info = 7;
397 bool has_flag_info() const;
398 private:
399 bool _internal_has_flag_info() const;
400 public:
401 void clear_flag_info();
402 const std::string& flag_info() const;
403 template <typename ArgT0 = const std::string&, typename... ArgT>
404 void set_flag_info(ArgT0&& arg0, ArgT... args);
405 std::string* mutable_flag_info();
406 PROTOBUF_NODISCARD std::string* release_flag_info();
407 void set_allocated_flag_info(std::string* flag_info);
408 private:
409 const std::string& _internal_flag_info() const;
410 inline PROTOBUF_ALWAYS_INLINE void _internal_set_flag_info(const std::string& value);
411 std::string* _internal_mutable_flag_info();
412 public:
413
414 // optional uint32 version = 1;
415 bool has_version() const;
416 private:
417 bool _internal_has_version() const;
418 public:
419 void clear_version();
420 ::uint32_t version() const;
421 void set_version(::uint32_t value);
422 private:
423 ::uint32_t _internal_version() const;
424 void _internal_set_version(::uint32_t value);
425 public:
426
427 // @@protoc_insertion_point(class_scope:android.aconfigd.PersistStorageRecord)
428 private:
429 class _Internal;
430
431 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
432 typedef void InternalArenaConstructable_;
433 typedef void DestructorSkippable_;
434 struct Impl_ {
435 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
436 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
437 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr container_;
438 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr package_map_;
439 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr flag_map_;
440 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr flag_val_;
441 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr digest_;
442 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr flag_info_;
443 ::uint32_t version_;
444 };
445 union { Impl_ _impl_; };
446 friend struct ::TableStruct_packages_2fmodules_2fConfigInfrastructure_2faconfigd_2fproto_2faconfigd_2eproto;
447 };
448 // -------------------------------------------------------------------
449
450 class PersistStorageRecords final :
451 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:android.aconfigd.PersistStorageRecords) */ {
452 public:
PersistStorageRecords()453 inline PersistStorageRecords() : PersistStorageRecords(nullptr) {}
454 ~PersistStorageRecords() override;
455 explicit PROTOBUF_CONSTEXPR PersistStorageRecords(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
456
457 PersistStorageRecords(const PersistStorageRecords& from);
PersistStorageRecords(PersistStorageRecords && from)458 PersistStorageRecords(PersistStorageRecords&& from) noexcept
459 : PersistStorageRecords() {
460 *this = ::std::move(from);
461 }
462
463 inline PersistStorageRecords& operator=(const PersistStorageRecords& from) {
464 if (this == &from) return *this;
465 CopyFrom(from);
466 return *this;
467 }
468 inline PersistStorageRecords& operator=(PersistStorageRecords&& from) noexcept {
469 if (this == &from) return *this;
470 if (GetOwningArena() == from.GetOwningArena()
471 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
472 && GetOwningArena() != nullptr
473 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
474 ) {
475 InternalSwap(&from);
476 } else {
477 CopyFrom(from);
478 }
479 return *this;
480 }
481
unknown_fields()482 inline const std::string& unknown_fields() const {
483 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
484 }
mutable_unknown_fields()485 inline std::string* mutable_unknown_fields() {
486 return _internal_metadata_.mutable_unknown_fields<std::string>();
487 }
488
default_instance()489 static const PersistStorageRecords& default_instance() {
490 return *internal_default_instance();
491 }
internal_default_instance()492 static inline const PersistStorageRecords* internal_default_instance() {
493 return reinterpret_cast<const PersistStorageRecords*>(
494 &_PersistStorageRecords_default_instance_);
495 }
496 static constexpr int kIndexInFileMessages =
497 1;
498
swap(PersistStorageRecords & a,PersistStorageRecords & b)499 friend void swap(PersistStorageRecords& a, PersistStorageRecords& b) {
500 a.Swap(&b);
501 }
Swap(PersistStorageRecords * other)502 inline void Swap(PersistStorageRecords* other) {
503 if (other == this) return;
504 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
505 if (GetOwningArena() != nullptr &&
506 GetOwningArena() == other->GetOwningArena()) {
507 #else // PROTOBUF_FORCE_COPY_IN_SWAP
508 if (GetOwningArena() == other->GetOwningArena()) {
509 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
510 InternalSwap(other);
511 } else {
512 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
513 }
514 }
515 void UnsafeArenaSwap(PersistStorageRecords* other) {
516 if (other == this) return;
517 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
518 InternalSwap(other);
519 }
520
521 // implements Message ----------------------------------------------
522
523 PersistStorageRecords* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
524 return CreateMaybeMessage<PersistStorageRecords>(arena);
525 }
526 PersistStorageRecords* New() const {
527 return New(nullptr);
528 }
529 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
530 void CopyFrom(const PersistStorageRecords& from);
531 void MergeFrom(const PersistStorageRecords& from);
532 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
533 bool IsInitialized() const final;
534
535 size_t ByteSizeLong() const final;
536 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
537 ::uint8_t* _InternalSerialize(
538 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
539 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
540
541 private:
542 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
543 void SharedDtor();
544 void SetCachedSize(int size) const;
545 void InternalSwap(PersistStorageRecords* other);
546
547 private:
548 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
549 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
550 return "android.aconfigd.PersistStorageRecords";
551 }
552 protected:
553 explicit PersistStorageRecords(::PROTOBUF_NAMESPACE_ID::Arena* arena,
554 bool is_message_owned = false);
555 public:
556
557 std::string GetTypeName() const final;
558
559 // nested types ----------------------------------------------------
560
561 // accessors -------------------------------------------------------
562
563 enum : int {
564 kRecordsFieldNumber = 1,
565 };
566 // repeated .android.aconfigd.PersistStorageRecord records = 1;
567 int records_size() const;
568 private:
569 int _internal_records_size() const;
570 public:
571 void clear_records();
572 ::android::aconfigd::PersistStorageRecord* mutable_records(int index);
573 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::android::aconfigd::PersistStorageRecord >*
574 mutable_records();
575 private:
576 const ::android::aconfigd::PersistStorageRecord& _internal_records(int index) const;
577 ::android::aconfigd::PersistStorageRecord* _internal_add_records();
578 public:
579 const ::android::aconfigd::PersistStorageRecord& records(int index) const;
580 ::android::aconfigd::PersistStorageRecord* add_records();
581 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::android::aconfigd::PersistStorageRecord >&
582 records() const;
583
584 // @@protoc_insertion_point(class_scope:android.aconfigd.PersistStorageRecords)
585 private:
586 class _Internal;
587
588 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
589 typedef void InternalArenaConstructable_;
590 typedef void DestructorSkippable_;
591 struct Impl_ {
592 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::android::aconfigd::PersistStorageRecord > records_;
593 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
594 };
595 union { Impl_ _impl_; };
596 friend struct ::TableStruct_packages_2fmodules_2fConfigInfrastructure_2faconfigd_2fproto_2faconfigd_2eproto;
597 };
598 // -------------------------------------------------------------------
599
600 class FlagOverride final :
601 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:android.aconfigd.FlagOverride) */ {
602 public:
FlagOverride()603 inline FlagOverride() : FlagOverride(nullptr) {}
604 ~FlagOverride() override;
605 explicit PROTOBUF_CONSTEXPR FlagOverride(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
606
607 FlagOverride(const FlagOverride& from);
FlagOverride(FlagOverride && from)608 FlagOverride(FlagOverride&& from) noexcept
609 : FlagOverride() {
610 *this = ::std::move(from);
611 }
612
613 inline FlagOverride& operator=(const FlagOverride& from) {
614 if (this == &from) return *this;
615 CopyFrom(from);
616 return *this;
617 }
618 inline FlagOverride& operator=(FlagOverride&& from) noexcept {
619 if (this == &from) return *this;
620 if (GetOwningArena() == from.GetOwningArena()
621 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
622 && GetOwningArena() != nullptr
623 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
624 ) {
625 InternalSwap(&from);
626 } else {
627 CopyFrom(from);
628 }
629 return *this;
630 }
631
unknown_fields()632 inline const std::string& unknown_fields() const {
633 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
634 }
mutable_unknown_fields()635 inline std::string* mutable_unknown_fields() {
636 return _internal_metadata_.mutable_unknown_fields<std::string>();
637 }
638
default_instance()639 static const FlagOverride& default_instance() {
640 return *internal_default_instance();
641 }
internal_default_instance()642 static inline const FlagOverride* internal_default_instance() {
643 return reinterpret_cast<const FlagOverride*>(
644 &_FlagOverride_default_instance_);
645 }
646 static constexpr int kIndexInFileMessages =
647 2;
648
swap(FlagOverride & a,FlagOverride & b)649 friend void swap(FlagOverride& a, FlagOverride& b) {
650 a.Swap(&b);
651 }
Swap(FlagOverride * other)652 inline void Swap(FlagOverride* other) {
653 if (other == this) return;
654 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
655 if (GetOwningArena() != nullptr &&
656 GetOwningArena() == other->GetOwningArena()) {
657 #else // PROTOBUF_FORCE_COPY_IN_SWAP
658 if (GetOwningArena() == other->GetOwningArena()) {
659 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
660 InternalSwap(other);
661 } else {
662 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
663 }
664 }
665 void UnsafeArenaSwap(FlagOverride* other) {
666 if (other == this) return;
667 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
668 InternalSwap(other);
669 }
670
671 // implements Message ----------------------------------------------
672
673 FlagOverride* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
674 return CreateMaybeMessage<FlagOverride>(arena);
675 }
676 FlagOverride* New() const {
677 return New(nullptr);
678 }
679 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
680 void CopyFrom(const FlagOverride& from);
681 void MergeFrom(const FlagOverride& from);
682 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
683 bool IsInitialized() const final;
684
685 size_t ByteSizeLong() const final;
686 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
687 ::uint8_t* _InternalSerialize(
688 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
689 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
690
691 private:
692 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
693 void SharedDtor();
694 void SetCachedSize(int size) const;
695 void InternalSwap(FlagOverride* other);
696
697 private:
698 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
699 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
700 return "android.aconfigd.FlagOverride";
701 }
702 protected:
703 explicit FlagOverride(::PROTOBUF_NAMESPACE_ID::Arena* arena,
704 bool is_message_owned = false);
705 public:
706
707 std::string GetTypeName() const final;
708
709 // nested types ----------------------------------------------------
710
711 // accessors -------------------------------------------------------
712
713 enum : int {
714 kPackageNameFieldNumber = 1,
715 kFlagNameFieldNumber = 2,
716 kFlagValueFieldNumber = 3,
717 };
718 // optional string package_name = 1;
719 bool has_package_name() const;
720 private:
721 bool _internal_has_package_name() const;
722 public:
723 void clear_package_name();
724 const std::string& package_name() const;
725 template <typename ArgT0 = const std::string&, typename... ArgT>
726 void set_package_name(ArgT0&& arg0, ArgT... args);
727 std::string* mutable_package_name();
728 PROTOBUF_NODISCARD std::string* release_package_name();
729 void set_allocated_package_name(std::string* package_name);
730 private:
731 const std::string& _internal_package_name() const;
732 inline PROTOBUF_ALWAYS_INLINE void _internal_set_package_name(const std::string& value);
733 std::string* _internal_mutable_package_name();
734 public:
735
736 // optional string flag_name = 2;
737 bool has_flag_name() const;
738 private:
739 bool _internal_has_flag_name() const;
740 public:
741 void clear_flag_name();
742 const std::string& flag_name() const;
743 template <typename ArgT0 = const std::string&, typename... ArgT>
744 void set_flag_name(ArgT0&& arg0, ArgT... args);
745 std::string* mutable_flag_name();
746 PROTOBUF_NODISCARD std::string* release_flag_name();
747 void set_allocated_flag_name(std::string* flag_name);
748 private:
749 const std::string& _internal_flag_name() const;
750 inline PROTOBUF_ALWAYS_INLINE void _internal_set_flag_name(const std::string& value);
751 std::string* _internal_mutable_flag_name();
752 public:
753
754 // optional string flag_value = 3;
755 bool has_flag_value() const;
756 private:
757 bool _internal_has_flag_value() const;
758 public:
759 void clear_flag_value();
760 const std::string& flag_value() const;
761 template <typename ArgT0 = const std::string&, typename... ArgT>
762 void set_flag_value(ArgT0&& arg0, ArgT... args);
763 std::string* mutable_flag_value();
764 PROTOBUF_NODISCARD std::string* release_flag_value();
765 void set_allocated_flag_value(std::string* flag_value);
766 private:
767 const std::string& _internal_flag_value() const;
768 inline PROTOBUF_ALWAYS_INLINE void _internal_set_flag_value(const std::string& value);
769 std::string* _internal_mutable_flag_value();
770 public:
771
772 // @@protoc_insertion_point(class_scope:android.aconfigd.FlagOverride)
773 private:
774 class _Internal;
775
776 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
777 typedef void InternalArenaConstructable_;
778 typedef void DestructorSkippable_;
779 struct Impl_ {
780 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
781 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
782 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr package_name_;
783 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr flag_name_;
784 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr flag_value_;
785 };
786 union { Impl_ _impl_; };
787 friend struct ::TableStruct_packages_2fmodules_2fConfigInfrastructure_2faconfigd_2fproto_2faconfigd_2eproto;
788 };
789 // -------------------------------------------------------------------
790
791 class LocalFlagOverrides final :
792 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:android.aconfigd.LocalFlagOverrides) */ {
793 public:
LocalFlagOverrides()794 inline LocalFlagOverrides() : LocalFlagOverrides(nullptr) {}
795 ~LocalFlagOverrides() override;
796 explicit PROTOBUF_CONSTEXPR LocalFlagOverrides(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
797
798 LocalFlagOverrides(const LocalFlagOverrides& from);
LocalFlagOverrides(LocalFlagOverrides && from)799 LocalFlagOverrides(LocalFlagOverrides&& from) noexcept
800 : LocalFlagOverrides() {
801 *this = ::std::move(from);
802 }
803
804 inline LocalFlagOverrides& operator=(const LocalFlagOverrides& from) {
805 if (this == &from) return *this;
806 CopyFrom(from);
807 return *this;
808 }
809 inline LocalFlagOverrides& operator=(LocalFlagOverrides&& from) noexcept {
810 if (this == &from) return *this;
811 if (GetOwningArena() == from.GetOwningArena()
812 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
813 && GetOwningArena() != nullptr
814 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
815 ) {
816 InternalSwap(&from);
817 } else {
818 CopyFrom(from);
819 }
820 return *this;
821 }
822
unknown_fields()823 inline const std::string& unknown_fields() const {
824 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
825 }
mutable_unknown_fields()826 inline std::string* mutable_unknown_fields() {
827 return _internal_metadata_.mutable_unknown_fields<std::string>();
828 }
829
default_instance()830 static const LocalFlagOverrides& default_instance() {
831 return *internal_default_instance();
832 }
internal_default_instance()833 static inline const LocalFlagOverrides* internal_default_instance() {
834 return reinterpret_cast<const LocalFlagOverrides*>(
835 &_LocalFlagOverrides_default_instance_);
836 }
837 static constexpr int kIndexInFileMessages =
838 3;
839
swap(LocalFlagOverrides & a,LocalFlagOverrides & b)840 friend void swap(LocalFlagOverrides& a, LocalFlagOverrides& b) {
841 a.Swap(&b);
842 }
Swap(LocalFlagOverrides * other)843 inline void Swap(LocalFlagOverrides* other) {
844 if (other == this) return;
845 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
846 if (GetOwningArena() != nullptr &&
847 GetOwningArena() == other->GetOwningArena()) {
848 #else // PROTOBUF_FORCE_COPY_IN_SWAP
849 if (GetOwningArena() == other->GetOwningArena()) {
850 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
851 InternalSwap(other);
852 } else {
853 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
854 }
855 }
856 void UnsafeArenaSwap(LocalFlagOverrides* other) {
857 if (other == this) return;
858 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
859 InternalSwap(other);
860 }
861
862 // implements Message ----------------------------------------------
863
864 LocalFlagOverrides* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
865 return CreateMaybeMessage<LocalFlagOverrides>(arena);
866 }
867 LocalFlagOverrides* New() const {
868 return New(nullptr);
869 }
870 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
871 void CopyFrom(const LocalFlagOverrides& from);
872 void MergeFrom(const LocalFlagOverrides& from);
873 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
874 bool IsInitialized() const final;
875
876 size_t ByteSizeLong() const final;
877 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
878 ::uint8_t* _InternalSerialize(
879 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
880 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
881
882 private:
883 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
884 void SharedDtor();
885 void SetCachedSize(int size) const;
886 void InternalSwap(LocalFlagOverrides* other);
887
888 private:
889 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
890 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
891 return "android.aconfigd.LocalFlagOverrides";
892 }
893 protected:
894 explicit LocalFlagOverrides(::PROTOBUF_NAMESPACE_ID::Arena* arena,
895 bool is_message_owned = false);
896 public:
897
898 std::string GetTypeName() const final;
899
900 // nested types ----------------------------------------------------
901
902 // accessors -------------------------------------------------------
903
904 enum : int {
905 kOverridesFieldNumber = 1,
906 };
907 // repeated .android.aconfigd.FlagOverride overrides = 1;
908 int overrides_size() const;
909 private:
910 int _internal_overrides_size() const;
911 public:
912 void clear_overrides();
913 ::android::aconfigd::FlagOverride* mutable_overrides(int index);
914 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::android::aconfigd::FlagOverride >*
915 mutable_overrides();
916 private:
917 const ::android::aconfigd::FlagOverride& _internal_overrides(int index) const;
918 ::android::aconfigd::FlagOverride* _internal_add_overrides();
919 public:
920 const ::android::aconfigd::FlagOverride& overrides(int index) const;
921 ::android::aconfigd::FlagOverride* add_overrides();
922 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::android::aconfigd::FlagOverride >&
923 overrides() const;
924
925 // @@protoc_insertion_point(class_scope:android.aconfigd.LocalFlagOverrides)
926 private:
927 class _Internal;
928
929 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
930 typedef void InternalArenaConstructable_;
931 typedef void DestructorSkippable_;
932 struct Impl_ {
933 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::android::aconfigd::FlagOverride > overrides_;
934 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
935 };
936 union { Impl_ _impl_; };
937 friend struct ::TableStruct_packages_2fmodules_2fConfigInfrastructure_2faconfigd_2fproto_2faconfigd_2eproto;
938 };
939 // -------------------------------------------------------------------
940
941 class StorageRequestMessage_NewStorageMessage final :
942 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:android.aconfigd.StorageRequestMessage.NewStorageMessage) */ {
943 public:
StorageRequestMessage_NewStorageMessage()944 inline StorageRequestMessage_NewStorageMessage() : StorageRequestMessage_NewStorageMessage(nullptr) {}
945 ~StorageRequestMessage_NewStorageMessage() override;
946 explicit PROTOBUF_CONSTEXPR StorageRequestMessage_NewStorageMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
947
948 StorageRequestMessage_NewStorageMessage(const StorageRequestMessage_NewStorageMessage& from);
StorageRequestMessage_NewStorageMessage(StorageRequestMessage_NewStorageMessage && from)949 StorageRequestMessage_NewStorageMessage(StorageRequestMessage_NewStorageMessage&& from) noexcept
950 : StorageRequestMessage_NewStorageMessage() {
951 *this = ::std::move(from);
952 }
953
954 inline StorageRequestMessage_NewStorageMessage& operator=(const StorageRequestMessage_NewStorageMessage& from) {
955 if (this == &from) return *this;
956 CopyFrom(from);
957 return *this;
958 }
959 inline StorageRequestMessage_NewStorageMessage& operator=(StorageRequestMessage_NewStorageMessage&& from) noexcept {
960 if (this == &from) return *this;
961 if (GetOwningArena() == from.GetOwningArena()
962 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
963 && GetOwningArena() != nullptr
964 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
965 ) {
966 InternalSwap(&from);
967 } else {
968 CopyFrom(from);
969 }
970 return *this;
971 }
972
unknown_fields()973 inline const std::string& unknown_fields() const {
974 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
975 }
mutable_unknown_fields()976 inline std::string* mutable_unknown_fields() {
977 return _internal_metadata_.mutable_unknown_fields<std::string>();
978 }
979
default_instance()980 static const StorageRequestMessage_NewStorageMessage& default_instance() {
981 return *internal_default_instance();
982 }
internal_default_instance()983 static inline const StorageRequestMessage_NewStorageMessage* internal_default_instance() {
984 return reinterpret_cast<const StorageRequestMessage_NewStorageMessage*>(
985 &_StorageRequestMessage_NewStorageMessage_default_instance_);
986 }
987 static constexpr int kIndexInFileMessages =
988 4;
989
swap(StorageRequestMessage_NewStorageMessage & a,StorageRequestMessage_NewStorageMessage & b)990 friend void swap(StorageRequestMessage_NewStorageMessage& a, StorageRequestMessage_NewStorageMessage& b) {
991 a.Swap(&b);
992 }
Swap(StorageRequestMessage_NewStorageMessage * other)993 inline void Swap(StorageRequestMessage_NewStorageMessage* other) {
994 if (other == this) return;
995 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
996 if (GetOwningArena() != nullptr &&
997 GetOwningArena() == other->GetOwningArena()) {
998 #else // PROTOBUF_FORCE_COPY_IN_SWAP
999 if (GetOwningArena() == other->GetOwningArena()) {
1000 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
1001 InternalSwap(other);
1002 } else {
1003 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1004 }
1005 }
1006 void UnsafeArenaSwap(StorageRequestMessage_NewStorageMessage* other) {
1007 if (other == this) return;
1008 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1009 InternalSwap(other);
1010 }
1011
1012 // implements Message ----------------------------------------------
1013
1014 StorageRequestMessage_NewStorageMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1015 return CreateMaybeMessage<StorageRequestMessage_NewStorageMessage>(arena);
1016 }
1017 StorageRequestMessage_NewStorageMessage* New() const {
1018 return New(nullptr);
1019 }
1020 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
1021 void CopyFrom(const StorageRequestMessage_NewStorageMessage& from);
1022 void MergeFrom(const StorageRequestMessage_NewStorageMessage& from);
1023 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1024 bool IsInitialized() const final;
1025
1026 size_t ByteSizeLong() const final;
1027 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1028 ::uint8_t* _InternalSerialize(
1029 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1030 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1031
1032 private:
1033 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1034 void SharedDtor();
1035 void SetCachedSize(int size) const;
1036 void InternalSwap(StorageRequestMessage_NewStorageMessage* other);
1037
1038 private:
1039 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1040 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1041 return "android.aconfigd.StorageRequestMessage.NewStorageMessage";
1042 }
1043 protected:
1044 explicit StorageRequestMessage_NewStorageMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1045 bool is_message_owned = false);
1046 public:
1047
1048 std::string GetTypeName() const final;
1049
1050 // nested types ----------------------------------------------------
1051
1052 // accessors -------------------------------------------------------
1053
1054 enum : int {
1055 kContainerFieldNumber = 1,
1056 kPackageMapFieldNumber = 2,
1057 kFlagMapFieldNumber = 3,
1058 kFlagValueFieldNumber = 4,
1059 kFlagInfoFieldNumber = 5,
1060 };
1061 // optional string container = 1;
1062 bool has_container() const;
1063 private:
1064 bool _internal_has_container() const;
1065 public:
1066 void clear_container();
1067 const std::string& container() const;
1068 template <typename ArgT0 = const std::string&, typename... ArgT>
1069 void set_container(ArgT0&& arg0, ArgT... args);
1070 std::string* mutable_container();
1071 PROTOBUF_NODISCARD std::string* release_container();
1072 void set_allocated_container(std::string* container);
1073 private:
1074 const std::string& _internal_container() const;
1075 inline PROTOBUF_ALWAYS_INLINE void _internal_set_container(const std::string& value);
1076 std::string* _internal_mutable_container();
1077 public:
1078
1079 // optional string package_map = 2;
1080 bool has_package_map() const;
1081 private:
1082 bool _internal_has_package_map() const;
1083 public:
1084 void clear_package_map();
1085 const std::string& package_map() const;
1086 template <typename ArgT0 = const std::string&, typename... ArgT>
1087 void set_package_map(ArgT0&& arg0, ArgT... args);
1088 std::string* mutable_package_map();
1089 PROTOBUF_NODISCARD std::string* release_package_map();
1090 void set_allocated_package_map(std::string* package_map);
1091 private:
1092 const std::string& _internal_package_map() const;
1093 inline PROTOBUF_ALWAYS_INLINE void _internal_set_package_map(const std::string& value);
1094 std::string* _internal_mutable_package_map();
1095 public:
1096
1097 // optional string flag_map = 3;
1098 bool has_flag_map() const;
1099 private:
1100 bool _internal_has_flag_map() const;
1101 public:
1102 void clear_flag_map();
1103 const std::string& flag_map() const;
1104 template <typename ArgT0 = const std::string&, typename... ArgT>
1105 void set_flag_map(ArgT0&& arg0, ArgT... args);
1106 std::string* mutable_flag_map();
1107 PROTOBUF_NODISCARD std::string* release_flag_map();
1108 void set_allocated_flag_map(std::string* flag_map);
1109 private:
1110 const std::string& _internal_flag_map() const;
1111 inline PROTOBUF_ALWAYS_INLINE void _internal_set_flag_map(const std::string& value);
1112 std::string* _internal_mutable_flag_map();
1113 public:
1114
1115 // optional string flag_value = 4;
1116 bool has_flag_value() const;
1117 private:
1118 bool _internal_has_flag_value() const;
1119 public:
1120 void clear_flag_value();
1121 const std::string& flag_value() const;
1122 template <typename ArgT0 = const std::string&, typename... ArgT>
1123 void set_flag_value(ArgT0&& arg0, ArgT... args);
1124 std::string* mutable_flag_value();
1125 PROTOBUF_NODISCARD std::string* release_flag_value();
1126 void set_allocated_flag_value(std::string* flag_value);
1127 private:
1128 const std::string& _internal_flag_value() const;
1129 inline PROTOBUF_ALWAYS_INLINE void _internal_set_flag_value(const std::string& value);
1130 std::string* _internal_mutable_flag_value();
1131 public:
1132
1133 // optional string flag_info = 5;
1134 bool has_flag_info() const;
1135 private:
1136 bool _internal_has_flag_info() const;
1137 public:
1138 void clear_flag_info();
1139 const std::string& flag_info() const;
1140 template <typename ArgT0 = const std::string&, typename... ArgT>
1141 void set_flag_info(ArgT0&& arg0, ArgT... args);
1142 std::string* mutable_flag_info();
1143 PROTOBUF_NODISCARD std::string* release_flag_info();
1144 void set_allocated_flag_info(std::string* flag_info);
1145 private:
1146 const std::string& _internal_flag_info() const;
1147 inline PROTOBUF_ALWAYS_INLINE void _internal_set_flag_info(const std::string& value);
1148 std::string* _internal_mutable_flag_info();
1149 public:
1150
1151 // @@protoc_insertion_point(class_scope:android.aconfigd.StorageRequestMessage.NewStorageMessage)
1152 private:
1153 class _Internal;
1154
1155 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1156 typedef void InternalArenaConstructable_;
1157 typedef void DestructorSkippable_;
1158 struct Impl_ {
1159 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
1160 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1161 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr container_;
1162 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr package_map_;
1163 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr flag_map_;
1164 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr flag_value_;
1165 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr flag_info_;
1166 };
1167 union { Impl_ _impl_; };
1168 friend struct ::TableStruct_packages_2fmodules_2fConfigInfrastructure_2faconfigd_2fproto_2faconfigd_2eproto;
1169 };
1170 // -------------------------------------------------------------------
1171
1172 class StorageRequestMessage_FlagOverrideMessage final :
1173 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:android.aconfigd.StorageRequestMessage.FlagOverrideMessage) */ {
1174 public:
StorageRequestMessage_FlagOverrideMessage()1175 inline StorageRequestMessage_FlagOverrideMessage() : StorageRequestMessage_FlagOverrideMessage(nullptr) {}
1176 ~StorageRequestMessage_FlagOverrideMessage() override;
1177 explicit PROTOBUF_CONSTEXPR StorageRequestMessage_FlagOverrideMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1178
1179 StorageRequestMessage_FlagOverrideMessage(const StorageRequestMessage_FlagOverrideMessage& from);
StorageRequestMessage_FlagOverrideMessage(StorageRequestMessage_FlagOverrideMessage && from)1180 StorageRequestMessage_FlagOverrideMessage(StorageRequestMessage_FlagOverrideMessage&& from) noexcept
1181 : StorageRequestMessage_FlagOverrideMessage() {
1182 *this = ::std::move(from);
1183 }
1184
1185 inline StorageRequestMessage_FlagOverrideMessage& operator=(const StorageRequestMessage_FlagOverrideMessage& from) {
1186 if (this == &from) return *this;
1187 CopyFrom(from);
1188 return *this;
1189 }
1190 inline StorageRequestMessage_FlagOverrideMessage& operator=(StorageRequestMessage_FlagOverrideMessage&& from) noexcept {
1191 if (this == &from) return *this;
1192 if (GetOwningArena() == from.GetOwningArena()
1193 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1194 && GetOwningArena() != nullptr
1195 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
1196 ) {
1197 InternalSwap(&from);
1198 } else {
1199 CopyFrom(from);
1200 }
1201 return *this;
1202 }
1203
unknown_fields()1204 inline const std::string& unknown_fields() const {
1205 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
1206 }
mutable_unknown_fields()1207 inline std::string* mutable_unknown_fields() {
1208 return _internal_metadata_.mutable_unknown_fields<std::string>();
1209 }
1210
default_instance()1211 static const StorageRequestMessage_FlagOverrideMessage& default_instance() {
1212 return *internal_default_instance();
1213 }
internal_default_instance()1214 static inline const StorageRequestMessage_FlagOverrideMessage* internal_default_instance() {
1215 return reinterpret_cast<const StorageRequestMessage_FlagOverrideMessage*>(
1216 &_StorageRequestMessage_FlagOverrideMessage_default_instance_);
1217 }
1218 static constexpr int kIndexInFileMessages =
1219 5;
1220
swap(StorageRequestMessage_FlagOverrideMessage & a,StorageRequestMessage_FlagOverrideMessage & b)1221 friend void swap(StorageRequestMessage_FlagOverrideMessage& a, StorageRequestMessage_FlagOverrideMessage& b) {
1222 a.Swap(&b);
1223 }
Swap(StorageRequestMessage_FlagOverrideMessage * other)1224 inline void Swap(StorageRequestMessage_FlagOverrideMessage* other) {
1225 if (other == this) return;
1226 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1227 if (GetOwningArena() != nullptr &&
1228 GetOwningArena() == other->GetOwningArena()) {
1229 #else // PROTOBUF_FORCE_COPY_IN_SWAP
1230 if (GetOwningArena() == other->GetOwningArena()) {
1231 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
1232 InternalSwap(other);
1233 } else {
1234 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1235 }
1236 }
1237 void UnsafeArenaSwap(StorageRequestMessage_FlagOverrideMessage* other) {
1238 if (other == this) return;
1239 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1240 InternalSwap(other);
1241 }
1242
1243 // implements Message ----------------------------------------------
1244
1245 StorageRequestMessage_FlagOverrideMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1246 return CreateMaybeMessage<StorageRequestMessage_FlagOverrideMessage>(arena);
1247 }
1248 StorageRequestMessage_FlagOverrideMessage* New() const {
1249 return New(nullptr);
1250 }
1251 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
1252 void CopyFrom(const StorageRequestMessage_FlagOverrideMessage& from);
1253 void MergeFrom(const StorageRequestMessage_FlagOverrideMessage& from);
1254 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1255 bool IsInitialized() const final;
1256
1257 size_t ByteSizeLong() const final;
1258 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1259 ::uint8_t* _InternalSerialize(
1260 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1261 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1262
1263 private:
1264 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1265 void SharedDtor();
1266 void SetCachedSize(int size) const;
1267 void InternalSwap(StorageRequestMessage_FlagOverrideMessage* other);
1268
1269 private:
1270 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1271 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1272 return "android.aconfigd.StorageRequestMessage.FlagOverrideMessage";
1273 }
1274 protected:
1275 explicit StorageRequestMessage_FlagOverrideMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1276 bool is_message_owned = false);
1277 public:
1278
1279 std::string GetTypeName() const final;
1280
1281 // nested types ----------------------------------------------------
1282
1283 // accessors -------------------------------------------------------
1284
1285 enum : int {
1286 kPackageNameFieldNumber = 1,
1287 kFlagNameFieldNumber = 2,
1288 kFlagValueFieldNumber = 3,
1289 kOverrideTypeFieldNumber = 4,
1290 };
1291 // optional string package_name = 1;
1292 bool has_package_name() const;
1293 private:
1294 bool _internal_has_package_name() const;
1295 public:
1296 void clear_package_name();
1297 const std::string& package_name() const;
1298 template <typename ArgT0 = const std::string&, typename... ArgT>
1299 void set_package_name(ArgT0&& arg0, ArgT... args);
1300 std::string* mutable_package_name();
1301 PROTOBUF_NODISCARD std::string* release_package_name();
1302 void set_allocated_package_name(std::string* package_name);
1303 private:
1304 const std::string& _internal_package_name() const;
1305 inline PROTOBUF_ALWAYS_INLINE void _internal_set_package_name(const std::string& value);
1306 std::string* _internal_mutable_package_name();
1307 public:
1308
1309 // optional string flag_name = 2;
1310 bool has_flag_name() const;
1311 private:
1312 bool _internal_has_flag_name() const;
1313 public:
1314 void clear_flag_name();
1315 const std::string& flag_name() const;
1316 template <typename ArgT0 = const std::string&, typename... ArgT>
1317 void set_flag_name(ArgT0&& arg0, ArgT... args);
1318 std::string* mutable_flag_name();
1319 PROTOBUF_NODISCARD std::string* release_flag_name();
1320 void set_allocated_flag_name(std::string* flag_name);
1321 private:
1322 const std::string& _internal_flag_name() const;
1323 inline PROTOBUF_ALWAYS_INLINE void _internal_set_flag_name(const std::string& value);
1324 std::string* _internal_mutable_flag_name();
1325 public:
1326
1327 // optional string flag_value = 3;
1328 bool has_flag_value() const;
1329 private:
1330 bool _internal_has_flag_value() const;
1331 public:
1332 void clear_flag_value();
1333 const std::string& flag_value() const;
1334 template <typename ArgT0 = const std::string&, typename... ArgT>
1335 void set_flag_value(ArgT0&& arg0, ArgT... args);
1336 std::string* mutable_flag_value();
1337 PROTOBUF_NODISCARD std::string* release_flag_value();
1338 void set_allocated_flag_value(std::string* flag_value);
1339 private:
1340 const std::string& _internal_flag_value() const;
1341 inline PROTOBUF_ALWAYS_INLINE void _internal_set_flag_value(const std::string& value);
1342 std::string* _internal_mutable_flag_value();
1343 public:
1344
1345 // optional .android.aconfigd.StorageRequestMessage.FlagOverrideType override_type = 4;
1346 bool has_override_type() const;
1347 private:
1348 bool _internal_has_override_type() const;
1349 public:
1350 void clear_override_type();
1351 ::android::aconfigd::StorageRequestMessage_FlagOverrideType override_type() const;
1352 void set_override_type(::android::aconfigd::StorageRequestMessage_FlagOverrideType value);
1353 private:
1354 ::android::aconfigd::StorageRequestMessage_FlagOverrideType _internal_override_type() const;
1355 void _internal_set_override_type(::android::aconfigd::StorageRequestMessage_FlagOverrideType value);
1356 public:
1357
1358 // @@protoc_insertion_point(class_scope:android.aconfigd.StorageRequestMessage.FlagOverrideMessage)
1359 private:
1360 class _Internal;
1361
1362 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1363 typedef void InternalArenaConstructable_;
1364 typedef void DestructorSkippable_;
1365 struct Impl_ {
1366 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
1367 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1368 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr package_name_;
1369 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr flag_name_;
1370 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr flag_value_;
1371 int override_type_;
1372 };
1373 union { Impl_ _impl_; };
1374 friend struct ::TableStruct_packages_2fmodules_2fConfigInfrastructure_2faconfigd_2fproto_2faconfigd_2eproto;
1375 };
1376 // -------------------------------------------------------------------
1377
1378 class StorageRequestMessage_OTAFlagStagingMessage final :
1379 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:android.aconfigd.StorageRequestMessage.OTAFlagStagingMessage) */ {
1380 public:
StorageRequestMessage_OTAFlagStagingMessage()1381 inline StorageRequestMessage_OTAFlagStagingMessage() : StorageRequestMessage_OTAFlagStagingMessage(nullptr) {}
1382 ~StorageRequestMessage_OTAFlagStagingMessage() override;
1383 explicit PROTOBUF_CONSTEXPR StorageRequestMessage_OTAFlagStagingMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1384
1385 StorageRequestMessage_OTAFlagStagingMessage(const StorageRequestMessage_OTAFlagStagingMessage& from);
StorageRequestMessage_OTAFlagStagingMessage(StorageRequestMessage_OTAFlagStagingMessage && from)1386 StorageRequestMessage_OTAFlagStagingMessage(StorageRequestMessage_OTAFlagStagingMessage&& from) noexcept
1387 : StorageRequestMessage_OTAFlagStagingMessage() {
1388 *this = ::std::move(from);
1389 }
1390
1391 inline StorageRequestMessage_OTAFlagStagingMessage& operator=(const StorageRequestMessage_OTAFlagStagingMessage& from) {
1392 if (this == &from) return *this;
1393 CopyFrom(from);
1394 return *this;
1395 }
1396 inline StorageRequestMessage_OTAFlagStagingMessage& operator=(StorageRequestMessage_OTAFlagStagingMessage&& from) noexcept {
1397 if (this == &from) return *this;
1398 if (GetOwningArena() == from.GetOwningArena()
1399 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1400 && GetOwningArena() != nullptr
1401 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
1402 ) {
1403 InternalSwap(&from);
1404 } else {
1405 CopyFrom(from);
1406 }
1407 return *this;
1408 }
1409
unknown_fields()1410 inline const std::string& unknown_fields() const {
1411 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
1412 }
mutable_unknown_fields()1413 inline std::string* mutable_unknown_fields() {
1414 return _internal_metadata_.mutable_unknown_fields<std::string>();
1415 }
1416
default_instance()1417 static const StorageRequestMessage_OTAFlagStagingMessage& default_instance() {
1418 return *internal_default_instance();
1419 }
internal_default_instance()1420 static inline const StorageRequestMessage_OTAFlagStagingMessage* internal_default_instance() {
1421 return reinterpret_cast<const StorageRequestMessage_OTAFlagStagingMessage*>(
1422 &_StorageRequestMessage_OTAFlagStagingMessage_default_instance_);
1423 }
1424 static constexpr int kIndexInFileMessages =
1425 6;
1426
swap(StorageRequestMessage_OTAFlagStagingMessage & a,StorageRequestMessage_OTAFlagStagingMessage & b)1427 friend void swap(StorageRequestMessage_OTAFlagStagingMessage& a, StorageRequestMessage_OTAFlagStagingMessage& b) {
1428 a.Swap(&b);
1429 }
Swap(StorageRequestMessage_OTAFlagStagingMessage * other)1430 inline void Swap(StorageRequestMessage_OTAFlagStagingMessage* other) {
1431 if (other == this) return;
1432 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1433 if (GetOwningArena() != nullptr &&
1434 GetOwningArena() == other->GetOwningArena()) {
1435 #else // PROTOBUF_FORCE_COPY_IN_SWAP
1436 if (GetOwningArena() == other->GetOwningArena()) {
1437 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
1438 InternalSwap(other);
1439 } else {
1440 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1441 }
1442 }
1443 void UnsafeArenaSwap(StorageRequestMessage_OTAFlagStagingMessage* other) {
1444 if (other == this) return;
1445 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1446 InternalSwap(other);
1447 }
1448
1449 // implements Message ----------------------------------------------
1450
1451 StorageRequestMessage_OTAFlagStagingMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1452 return CreateMaybeMessage<StorageRequestMessage_OTAFlagStagingMessage>(arena);
1453 }
1454 StorageRequestMessage_OTAFlagStagingMessage* New() const {
1455 return New(nullptr);
1456 }
1457 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
1458 void CopyFrom(const StorageRequestMessage_OTAFlagStagingMessage& from);
1459 void MergeFrom(const StorageRequestMessage_OTAFlagStagingMessage& from);
1460 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1461 bool IsInitialized() const final;
1462
1463 size_t ByteSizeLong() const final;
1464 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1465 ::uint8_t* _InternalSerialize(
1466 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1467 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1468
1469 private:
1470 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1471 void SharedDtor();
1472 void SetCachedSize(int size) const;
1473 void InternalSwap(StorageRequestMessage_OTAFlagStagingMessage* other);
1474
1475 private:
1476 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1477 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1478 return "android.aconfigd.StorageRequestMessage.OTAFlagStagingMessage";
1479 }
1480 protected:
1481 explicit StorageRequestMessage_OTAFlagStagingMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1482 bool is_message_owned = false);
1483 public:
1484
1485 std::string GetTypeName() const final;
1486
1487 // nested types ----------------------------------------------------
1488
1489 // accessors -------------------------------------------------------
1490
1491 enum : int {
1492 kOverridesFieldNumber = 2,
1493 kBuildIdFieldNumber = 1,
1494 };
1495 // repeated .android.aconfigd.FlagOverride overrides = 2;
1496 int overrides_size() const;
1497 private:
1498 int _internal_overrides_size() const;
1499 public:
1500 void clear_overrides();
1501 ::android::aconfigd::FlagOverride* mutable_overrides(int index);
1502 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::android::aconfigd::FlagOverride >*
1503 mutable_overrides();
1504 private:
1505 const ::android::aconfigd::FlagOverride& _internal_overrides(int index) const;
1506 ::android::aconfigd::FlagOverride* _internal_add_overrides();
1507 public:
1508 const ::android::aconfigd::FlagOverride& overrides(int index) const;
1509 ::android::aconfigd::FlagOverride* add_overrides();
1510 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::android::aconfigd::FlagOverride >&
1511 overrides() const;
1512
1513 // optional string build_id = 1;
1514 bool has_build_id() const;
1515 private:
1516 bool _internal_has_build_id() const;
1517 public:
1518 void clear_build_id();
1519 const std::string& build_id() const;
1520 template <typename ArgT0 = const std::string&, typename... ArgT>
1521 void set_build_id(ArgT0&& arg0, ArgT... args);
1522 std::string* mutable_build_id();
1523 PROTOBUF_NODISCARD std::string* release_build_id();
1524 void set_allocated_build_id(std::string* build_id);
1525 private:
1526 const std::string& _internal_build_id() const;
1527 inline PROTOBUF_ALWAYS_INLINE void _internal_set_build_id(const std::string& value);
1528 std::string* _internal_mutable_build_id();
1529 public:
1530
1531 // @@protoc_insertion_point(class_scope:android.aconfigd.StorageRequestMessage.OTAFlagStagingMessage)
1532 private:
1533 class _Internal;
1534
1535 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1536 typedef void InternalArenaConstructable_;
1537 typedef void DestructorSkippable_;
1538 struct Impl_ {
1539 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
1540 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1541 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::android::aconfigd::FlagOverride > overrides_;
1542 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr build_id_;
1543 };
1544 union { Impl_ _impl_; };
1545 friend struct ::TableStruct_packages_2fmodules_2fConfigInfrastructure_2faconfigd_2fproto_2faconfigd_2eproto;
1546 };
1547 // -------------------------------------------------------------------
1548
1549 class StorageRequestMessage_RemoveLocalOverrideMessage final :
1550 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:android.aconfigd.StorageRequestMessage.RemoveLocalOverrideMessage) */ {
1551 public:
StorageRequestMessage_RemoveLocalOverrideMessage()1552 inline StorageRequestMessage_RemoveLocalOverrideMessage() : StorageRequestMessage_RemoveLocalOverrideMessage(nullptr) {}
1553 ~StorageRequestMessage_RemoveLocalOverrideMessage() override;
1554 explicit PROTOBUF_CONSTEXPR StorageRequestMessage_RemoveLocalOverrideMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1555
1556 StorageRequestMessage_RemoveLocalOverrideMessage(const StorageRequestMessage_RemoveLocalOverrideMessage& from);
StorageRequestMessage_RemoveLocalOverrideMessage(StorageRequestMessage_RemoveLocalOverrideMessage && from)1557 StorageRequestMessage_RemoveLocalOverrideMessage(StorageRequestMessage_RemoveLocalOverrideMessage&& from) noexcept
1558 : StorageRequestMessage_RemoveLocalOverrideMessage() {
1559 *this = ::std::move(from);
1560 }
1561
1562 inline StorageRequestMessage_RemoveLocalOverrideMessage& operator=(const StorageRequestMessage_RemoveLocalOverrideMessage& from) {
1563 if (this == &from) return *this;
1564 CopyFrom(from);
1565 return *this;
1566 }
1567 inline StorageRequestMessage_RemoveLocalOverrideMessage& operator=(StorageRequestMessage_RemoveLocalOverrideMessage&& from) noexcept {
1568 if (this == &from) return *this;
1569 if (GetOwningArena() == from.GetOwningArena()
1570 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1571 && GetOwningArena() != nullptr
1572 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
1573 ) {
1574 InternalSwap(&from);
1575 } else {
1576 CopyFrom(from);
1577 }
1578 return *this;
1579 }
1580
unknown_fields()1581 inline const std::string& unknown_fields() const {
1582 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
1583 }
mutable_unknown_fields()1584 inline std::string* mutable_unknown_fields() {
1585 return _internal_metadata_.mutable_unknown_fields<std::string>();
1586 }
1587
default_instance()1588 static const StorageRequestMessage_RemoveLocalOverrideMessage& default_instance() {
1589 return *internal_default_instance();
1590 }
internal_default_instance()1591 static inline const StorageRequestMessage_RemoveLocalOverrideMessage* internal_default_instance() {
1592 return reinterpret_cast<const StorageRequestMessage_RemoveLocalOverrideMessage*>(
1593 &_StorageRequestMessage_RemoveLocalOverrideMessage_default_instance_);
1594 }
1595 static constexpr int kIndexInFileMessages =
1596 7;
1597
swap(StorageRequestMessage_RemoveLocalOverrideMessage & a,StorageRequestMessage_RemoveLocalOverrideMessage & b)1598 friend void swap(StorageRequestMessage_RemoveLocalOverrideMessage& a, StorageRequestMessage_RemoveLocalOverrideMessage& b) {
1599 a.Swap(&b);
1600 }
Swap(StorageRequestMessage_RemoveLocalOverrideMessage * other)1601 inline void Swap(StorageRequestMessage_RemoveLocalOverrideMessage* other) {
1602 if (other == this) return;
1603 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1604 if (GetOwningArena() != nullptr &&
1605 GetOwningArena() == other->GetOwningArena()) {
1606 #else // PROTOBUF_FORCE_COPY_IN_SWAP
1607 if (GetOwningArena() == other->GetOwningArena()) {
1608 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
1609 InternalSwap(other);
1610 } else {
1611 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1612 }
1613 }
1614 void UnsafeArenaSwap(StorageRequestMessage_RemoveLocalOverrideMessage* other) {
1615 if (other == this) return;
1616 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1617 InternalSwap(other);
1618 }
1619
1620 // implements Message ----------------------------------------------
1621
1622 StorageRequestMessage_RemoveLocalOverrideMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1623 return CreateMaybeMessage<StorageRequestMessage_RemoveLocalOverrideMessage>(arena);
1624 }
1625 StorageRequestMessage_RemoveLocalOverrideMessage* New() const {
1626 return New(nullptr);
1627 }
1628 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
1629 void CopyFrom(const StorageRequestMessage_RemoveLocalOverrideMessage& from);
1630 void MergeFrom(const StorageRequestMessage_RemoveLocalOverrideMessage& from);
1631 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1632 bool IsInitialized() const final;
1633
1634 size_t ByteSizeLong() const final;
1635 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1636 ::uint8_t* _InternalSerialize(
1637 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1638 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1639
1640 private:
1641 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1642 void SharedDtor();
1643 void SetCachedSize(int size) const;
1644 void InternalSwap(StorageRequestMessage_RemoveLocalOverrideMessage* other);
1645
1646 private:
1647 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1648 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1649 return "android.aconfigd.StorageRequestMessage.RemoveLocalOverrideMessage";
1650 }
1651 protected:
1652 explicit StorageRequestMessage_RemoveLocalOverrideMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1653 bool is_message_owned = false);
1654 public:
1655
1656 std::string GetTypeName() const final;
1657
1658 // nested types ----------------------------------------------------
1659
1660 // accessors -------------------------------------------------------
1661
1662 enum : int {
1663 kPackageNameFieldNumber = 2,
1664 kFlagNameFieldNumber = 3,
1665 kRemoveAllFieldNumber = 1,
1666 kRemoveOverrideTypeFieldNumber = 4,
1667 };
1668 // optional string package_name = 2;
1669 bool has_package_name() const;
1670 private:
1671 bool _internal_has_package_name() const;
1672 public:
1673 void clear_package_name();
1674 const std::string& package_name() const;
1675 template <typename ArgT0 = const std::string&, typename... ArgT>
1676 void set_package_name(ArgT0&& arg0, ArgT... args);
1677 std::string* mutable_package_name();
1678 PROTOBUF_NODISCARD std::string* release_package_name();
1679 void set_allocated_package_name(std::string* package_name);
1680 private:
1681 const std::string& _internal_package_name() const;
1682 inline PROTOBUF_ALWAYS_INLINE void _internal_set_package_name(const std::string& value);
1683 std::string* _internal_mutable_package_name();
1684 public:
1685
1686 // optional string flag_name = 3;
1687 bool has_flag_name() const;
1688 private:
1689 bool _internal_has_flag_name() const;
1690 public:
1691 void clear_flag_name();
1692 const std::string& flag_name() const;
1693 template <typename ArgT0 = const std::string&, typename... ArgT>
1694 void set_flag_name(ArgT0&& arg0, ArgT... args);
1695 std::string* mutable_flag_name();
1696 PROTOBUF_NODISCARD std::string* release_flag_name();
1697 void set_allocated_flag_name(std::string* flag_name);
1698 private:
1699 const std::string& _internal_flag_name() const;
1700 inline PROTOBUF_ALWAYS_INLINE void _internal_set_flag_name(const std::string& value);
1701 std::string* _internal_mutable_flag_name();
1702 public:
1703
1704 // optional bool remove_all = 1;
1705 bool has_remove_all() const;
1706 private:
1707 bool _internal_has_remove_all() const;
1708 public:
1709 void clear_remove_all();
1710 bool remove_all() const;
1711 void set_remove_all(bool value);
1712 private:
1713 bool _internal_remove_all() const;
1714 void _internal_set_remove_all(bool value);
1715 public:
1716
1717 // optional .android.aconfigd.StorageRequestMessage.RemoveOverrideType remove_override_type = 4;
1718 bool has_remove_override_type() const;
1719 private:
1720 bool _internal_has_remove_override_type() const;
1721 public:
1722 void clear_remove_override_type();
1723 ::android::aconfigd::StorageRequestMessage_RemoveOverrideType remove_override_type() const;
1724 void set_remove_override_type(::android::aconfigd::StorageRequestMessage_RemoveOverrideType value);
1725 private:
1726 ::android::aconfigd::StorageRequestMessage_RemoveOverrideType _internal_remove_override_type() const;
1727 void _internal_set_remove_override_type(::android::aconfigd::StorageRequestMessage_RemoveOverrideType value);
1728 public:
1729
1730 // @@protoc_insertion_point(class_scope:android.aconfigd.StorageRequestMessage.RemoveLocalOverrideMessage)
1731 private:
1732 class _Internal;
1733
1734 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1735 typedef void InternalArenaConstructable_;
1736 typedef void DestructorSkippable_;
1737 struct Impl_ {
1738 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
1739 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1740 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr package_name_;
1741 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr flag_name_;
1742 bool remove_all_;
1743 int remove_override_type_;
1744 };
1745 union { Impl_ _impl_; };
1746 friend struct ::TableStruct_packages_2fmodules_2fConfigInfrastructure_2faconfigd_2fproto_2faconfigd_2eproto;
1747 };
1748 // -------------------------------------------------------------------
1749
1750 class StorageRequestMessage_FlagQueryMessage final :
1751 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:android.aconfigd.StorageRequestMessage.FlagQueryMessage) */ {
1752 public:
StorageRequestMessage_FlagQueryMessage()1753 inline StorageRequestMessage_FlagQueryMessage() : StorageRequestMessage_FlagQueryMessage(nullptr) {}
1754 ~StorageRequestMessage_FlagQueryMessage() override;
1755 explicit PROTOBUF_CONSTEXPR StorageRequestMessage_FlagQueryMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1756
1757 StorageRequestMessage_FlagQueryMessage(const StorageRequestMessage_FlagQueryMessage& from);
StorageRequestMessage_FlagQueryMessage(StorageRequestMessage_FlagQueryMessage && from)1758 StorageRequestMessage_FlagQueryMessage(StorageRequestMessage_FlagQueryMessage&& from) noexcept
1759 : StorageRequestMessage_FlagQueryMessage() {
1760 *this = ::std::move(from);
1761 }
1762
1763 inline StorageRequestMessage_FlagQueryMessage& operator=(const StorageRequestMessage_FlagQueryMessage& from) {
1764 if (this == &from) return *this;
1765 CopyFrom(from);
1766 return *this;
1767 }
1768 inline StorageRequestMessage_FlagQueryMessage& operator=(StorageRequestMessage_FlagQueryMessage&& from) noexcept {
1769 if (this == &from) return *this;
1770 if (GetOwningArena() == from.GetOwningArena()
1771 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1772 && GetOwningArena() != nullptr
1773 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
1774 ) {
1775 InternalSwap(&from);
1776 } else {
1777 CopyFrom(from);
1778 }
1779 return *this;
1780 }
1781
unknown_fields()1782 inline const std::string& unknown_fields() const {
1783 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
1784 }
mutable_unknown_fields()1785 inline std::string* mutable_unknown_fields() {
1786 return _internal_metadata_.mutable_unknown_fields<std::string>();
1787 }
1788
default_instance()1789 static const StorageRequestMessage_FlagQueryMessage& default_instance() {
1790 return *internal_default_instance();
1791 }
internal_default_instance()1792 static inline const StorageRequestMessage_FlagQueryMessage* internal_default_instance() {
1793 return reinterpret_cast<const StorageRequestMessage_FlagQueryMessage*>(
1794 &_StorageRequestMessage_FlagQueryMessage_default_instance_);
1795 }
1796 static constexpr int kIndexInFileMessages =
1797 8;
1798
swap(StorageRequestMessage_FlagQueryMessage & a,StorageRequestMessage_FlagQueryMessage & b)1799 friend void swap(StorageRequestMessage_FlagQueryMessage& a, StorageRequestMessage_FlagQueryMessage& b) {
1800 a.Swap(&b);
1801 }
Swap(StorageRequestMessage_FlagQueryMessage * other)1802 inline void Swap(StorageRequestMessage_FlagQueryMessage* other) {
1803 if (other == this) return;
1804 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1805 if (GetOwningArena() != nullptr &&
1806 GetOwningArena() == other->GetOwningArena()) {
1807 #else // PROTOBUF_FORCE_COPY_IN_SWAP
1808 if (GetOwningArena() == other->GetOwningArena()) {
1809 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
1810 InternalSwap(other);
1811 } else {
1812 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1813 }
1814 }
1815 void UnsafeArenaSwap(StorageRequestMessage_FlagQueryMessage* other) {
1816 if (other == this) return;
1817 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1818 InternalSwap(other);
1819 }
1820
1821 // implements Message ----------------------------------------------
1822
1823 StorageRequestMessage_FlagQueryMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1824 return CreateMaybeMessage<StorageRequestMessage_FlagQueryMessage>(arena);
1825 }
1826 StorageRequestMessage_FlagQueryMessage* New() const {
1827 return New(nullptr);
1828 }
1829 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
1830 void CopyFrom(const StorageRequestMessage_FlagQueryMessage& from);
1831 void MergeFrom(const StorageRequestMessage_FlagQueryMessage& from);
1832 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1833 bool IsInitialized() const final;
1834
1835 size_t ByteSizeLong() const final;
1836 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1837 ::uint8_t* _InternalSerialize(
1838 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1839 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1840
1841 private:
1842 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1843 void SharedDtor();
1844 void SetCachedSize(int size) const;
1845 void InternalSwap(StorageRequestMessage_FlagQueryMessage* other);
1846
1847 private:
1848 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1849 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1850 return "android.aconfigd.StorageRequestMessage.FlagQueryMessage";
1851 }
1852 protected:
1853 explicit StorageRequestMessage_FlagQueryMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1854 bool is_message_owned = false);
1855 public:
1856
1857 std::string GetTypeName() const final;
1858
1859 // nested types ----------------------------------------------------
1860
1861 // accessors -------------------------------------------------------
1862
1863 enum : int {
1864 kPackageNameFieldNumber = 1,
1865 kFlagNameFieldNumber = 2,
1866 };
1867 // optional string package_name = 1;
1868 bool has_package_name() const;
1869 private:
1870 bool _internal_has_package_name() const;
1871 public:
1872 void clear_package_name();
1873 const std::string& package_name() const;
1874 template <typename ArgT0 = const std::string&, typename... ArgT>
1875 void set_package_name(ArgT0&& arg0, ArgT... args);
1876 std::string* mutable_package_name();
1877 PROTOBUF_NODISCARD std::string* release_package_name();
1878 void set_allocated_package_name(std::string* package_name);
1879 private:
1880 const std::string& _internal_package_name() const;
1881 inline PROTOBUF_ALWAYS_INLINE void _internal_set_package_name(const std::string& value);
1882 std::string* _internal_mutable_package_name();
1883 public:
1884
1885 // optional string flag_name = 2;
1886 bool has_flag_name() const;
1887 private:
1888 bool _internal_has_flag_name() const;
1889 public:
1890 void clear_flag_name();
1891 const std::string& flag_name() const;
1892 template <typename ArgT0 = const std::string&, typename... ArgT>
1893 void set_flag_name(ArgT0&& arg0, ArgT... args);
1894 std::string* mutable_flag_name();
1895 PROTOBUF_NODISCARD std::string* release_flag_name();
1896 void set_allocated_flag_name(std::string* flag_name);
1897 private:
1898 const std::string& _internal_flag_name() const;
1899 inline PROTOBUF_ALWAYS_INLINE void _internal_set_flag_name(const std::string& value);
1900 std::string* _internal_mutable_flag_name();
1901 public:
1902
1903 // @@protoc_insertion_point(class_scope:android.aconfigd.StorageRequestMessage.FlagQueryMessage)
1904 private:
1905 class _Internal;
1906
1907 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1908 typedef void InternalArenaConstructable_;
1909 typedef void DestructorSkippable_;
1910 struct Impl_ {
1911 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
1912 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1913 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr package_name_;
1914 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr flag_name_;
1915 };
1916 union { Impl_ _impl_; };
1917 friend struct ::TableStruct_packages_2fmodules_2fConfigInfrastructure_2faconfigd_2fproto_2faconfigd_2eproto;
1918 };
1919 // -------------------------------------------------------------------
1920
1921 class StorageRequestMessage_ResetStorageMessage final :
1922 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:android.aconfigd.StorageRequestMessage.ResetStorageMessage) */ {
1923 public:
StorageRequestMessage_ResetStorageMessage()1924 inline StorageRequestMessage_ResetStorageMessage() : StorageRequestMessage_ResetStorageMessage(nullptr) {}
1925 ~StorageRequestMessage_ResetStorageMessage() override;
1926 explicit PROTOBUF_CONSTEXPR StorageRequestMessage_ResetStorageMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1927
1928 StorageRequestMessage_ResetStorageMessage(const StorageRequestMessage_ResetStorageMessage& from);
StorageRequestMessage_ResetStorageMessage(StorageRequestMessage_ResetStorageMessage && from)1929 StorageRequestMessage_ResetStorageMessage(StorageRequestMessage_ResetStorageMessage&& from) noexcept
1930 : StorageRequestMessage_ResetStorageMessage() {
1931 *this = ::std::move(from);
1932 }
1933
1934 inline StorageRequestMessage_ResetStorageMessage& operator=(const StorageRequestMessage_ResetStorageMessage& from) {
1935 if (this == &from) return *this;
1936 CopyFrom(from);
1937 return *this;
1938 }
1939 inline StorageRequestMessage_ResetStorageMessage& operator=(StorageRequestMessage_ResetStorageMessage&& from) noexcept {
1940 if (this == &from) return *this;
1941 if (GetOwningArena() == from.GetOwningArena()
1942 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1943 && GetOwningArena() != nullptr
1944 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
1945 ) {
1946 InternalSwap(&from);
1947 } else {
1948 CopyFrom(from);
1949 }
1950 return *this;
1951 }
1952
unknown_fields()1953 inline const std::string& unknown_fields() const {
1954 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
1955 }
mutable_unknown_fields()1956 inline std::string* mutable_unknown_fields() {
1957 return _internal_metadata_.mutable_unknown_fields<std::string>();
1958 }
1959
default_instance()1960 static const StorageRequestMessage_ResetStorageMessage& default_instance() {
1961 return *internal_default_instance();
1962 }
1963 enum MsgCase {
1964 kAll = 1,
1965 kContainer = 2,
1966 MSG_NOT_SET = 0,
1967 };
1968
internal_default_instance()1969 static inline const StorageRequestMessage_ResetStorageMessage* internal_default_instance() {
1970 return reinterpret_cast<const StorageRequestMessage_ResetStorageMessage*>(
1971 &_StorageRequestMessage_ResetStorageMessage_default_instance_);
1972 }
1973 static constexpr int kIndexInFileMessages =
1974 9;
1975
swap(StorageRequestMessage_ResetStorageMessage & a,StorageRequestMessage_ResetStorageMessage & b)1976 friend void swap(StorageRequestMessage_ResetStorageMessage& a, StorageRequestMessage_ResetStorageMessage& b) {
1977 a.Swap(&b);
1978 }
Swap(StorageRequestMessage_ResetStorageMessage * other)1979 inline void Swap(StorageRequestMessage_ResetStorageMessage* other) {
1980 if (other == this) return;
1981 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1982 if (GetOwningArena() != nullptr &&
1983 GetOwningArena() == other->GetOwningArena()) {
1984 #else // PROTOBUF_FORCE_COPY_IN_SWAP
1985 if (GetOwningArena() == other->GetOwningArena()) {
1986 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
1987 InternalSwap(other);
1988 } else {
1989 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1990 }
1991 }
1992 void UnsafeArenaSwap(StorageRequestMessage_ResetStorageMessage* other) {
1993 if (other == this) return;
1994 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1995 InternalSwap(other);
1996 }
1997
1998 // implements Message ----------------------------------------------
1999
2000 StorageRequestMessage_ResetStorageMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
2001 return CreateMaybeMessage<StorageRequestMessage_ResetStorageMessage>(arena);
2002 }
2003 StorageRequestMessage_ResetStorageMessage* New() const {
2004 return New(nullptr);
2005 }
2006 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
2007 void CopyFrom(const StorageRequestMessage_ResetStorageMessage& from);
2008 void MergeFrom(const StorageRequestMessage_ResetStorageMessage& from);
2009 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
2010 bool IsInitialized() const final;
2011
2012 size_t ByteSizeLong() const final;
2013 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
2014 ::uint8_t* _InternalSerialize(
2015 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
2016 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
2017
2018 private:
2019 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
2020 void SharedDtor();
2021 void SetCachedSize(int size) const;
2022 void InternalSwap(StorageRequestMessage_ResetStorageMessage* other);
2023
2024 private:
2025 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
2026 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
2027 return "android.aconfigd.StorageRequestMessage.ResetStorageMessage";
2028 }
2029 protected:
2030 explicit StorageRequestMessage_ResetStorageMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2031 bool is_message_owned = false);
2032 public:
2033
2034 std::string GetTypeName() const final;
2035
2036 // nested types ----------------------------------------------------
2037
2038 // accessors -------------------------------------------------------
2039
2040 enum : int {
2041 kAllFieldNumber = 1,
2042 kContainerFieldNumber = 2,
2043 };
2044 // bool all = 1;
2045 bool has_all() const;
2046 private:
2047 bool _internal_has_all() const;
2048 public:
2049 void clear_all();
2050 bool all() const;
2051 void set_all(bool value);
2052 private:
2053 bool _internal_all() const;
2054 void _internal_set_all(bool value);
2055 public:
2056
2057 // string container = 2;
2058 bool has_container() const;
2059 private:
2060 bool _internal_has_container() const;
2061 public:
2062 void clear_container();
2063 const std::string& container() const;
2064 template <typename ArgT0 = const std::string&, typename... ArgT>
2065 void set_container(ArgT0&& arg0, ArgT... args);
2066 std::string* mutable_container();
2067 PROTOBUF_NODISCARD std::string* release_container();
2068 void set_allocated_container(std::string* container);
2069 private:
2070 const std::string& _internal_container() const;
2071 inline PROTOBUF_ALWAYS_INLINE void _internal_set_container(const std::string& value);
2072 std::string* _internal_mutable_container();
2073 public:
2074
2075 void clear_msg();
2076 MsgCase msg_case() const;
2077 // @@protoc_insertion_point(class_scope:android.aconfigd.StorageRequestMessage.ResetStorageMessage)
2078 private:
2079 class _Internal;
2080 void set_has_all();
2081 void set_has_container();
2082
2083 inline bool has_msg() const;
2084 inline void clear_has_msg();
2085
2086 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
2087 typedef void InternalArenaConstructable_;
2088 typedef void DestructorSkippable_;
2089 struct Impl_ {
2090 union MsgUnion {
2091 constexpr MsgUnion() : _constinit_{} {}
2092 ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
2093 bool all_;
2094 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr container_;
2095 } msg_;
2096 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2097 ::uint32_t _oneof_case_[1];
2098
2099 };
2100 union { Impl_ _impl_; };
2101 friend struct ::TableStruct_packages_2fmodules_2fConfigInfrastructure_2faconfigd_2fproto_2faconfigd_2eproto;
2102 };
2103 // -------------------------------------------------------------------
2104
2105 class StorageRequestMessage_ListStorageMessage final :
2106 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:android.aconfigd.StorageRequestMessage.ListStorageMessage) */ {
2107 public:
StorageRequestMessage_ListStorageMessage()2108 inline StorageRequestMessage_ListStorageMessage() : StorageRequestMessage_ListStorageMessage(nullptr) {}
2109 ~StorageRequestMessage_ListStorageMessage() override;
2110 explicit PROTOBUF_CONSTEXPR StorageRequestMessage_ListStorageMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
2111
2112 StorageRequestMessage_ListStorageMessage(const StorageRequestMessage_ListStorageMessage& from);
StorageRequestMessage_ListStorageMessage(StorageRequestMessage_ListStorageMessage && from)2113 StorageRequestMessage_ListStorageMessage(StorageRequestMessage_ListStorageMessage&& from) noexcept
2114 : StorageRequestMessage_ListStorageMessage() {
2115 *this = ::std::move(from);
2116 }
2117
2118 inline StorageRequestMessage_ListStorageMessage& operator=(const StorageRequestMessage_ListStorageMessage& from) {
2119 if (this == &from) return *this;
2120 CopyFrom(from);
2121 return *this;
2122 }
2123 inline StorageRequestMessage_ListStorageMessage& operator=(StorageRequestMessage_ListStorageMessage&& from) noexcept {
2124 if (this == &from) return *this;
2125 if (GetOwningArena() == from.GetOwningArena()
2126 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
2127 && GetOwningArena() != nullptr
2128 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
2129 ) {
2130 InternalSwap(&from);
2131 } else {
2132 CopyFrom(from);
2133 }
2134 return *this;
2135 }
2136
unknown_fields()2137 inline const std::string& unknown_fields() const {
2138 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
2139 }
mutable_unknown_fields()2140 inline std::string* mutable_unknown_fields() {
2141 return _internal_metadata_.mutable_unknown_fields<std::string>();
2142 }
2143
default_instance()2144 static const StorageRequestMessage_ListStorageMessage& default_instance() {
2145 return *internal_default_instance();
2146 }
2147 enum MsgCase {
2148 kAll = 1,
2149 kContainer = 2,
2150 kPackageName = 3,
2151 MSG_NOT_SET = 0,
2152 };
2153
internal_default_instance()2154 static inline const StorageRequestMessage_ListStorageMessage* internal_default_instance() {
2155 return reinterpret_cast<const StorageRequestMessage_ListStorageMessage*>(
2156 &_StorageRequestMessage_ListStorageMessage_default_instance_);
2157 }
2158 static constexpr int kIndexInFileMessages =
2159 10;
2160
swap(StorageRequestMessage_ListStorageMessage & a,StorageRequestMessage_ListStorageMessage & b)2161 friend void swap(StorageRequestMessage_ListStorageMessage& a, StorageRequestMessage_ListStorageMessage& b) {
2162 a.Swap(&b);
2163 }
Swap(StorageRequestMessage_ListStorageMessage * other)2164 inline void Swap(StorageRequestMessage_ListStorageMessage* other) {
2165 if (other == this) return;
2166 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
2167 if (GetOwningArena() != nullptr &&
2168 GetOwningArena() == other->GetOwningArena()) {
2169 #else // PROTOBUF_FORCE_COPY_IN_SWAP
2170 if (GetOwningArena() == other->GetOwningArena()) {
2171 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
2172 InternalSwap(other);
2173 } else {
2174 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
2175 }
2176 }
2177 void UnsafeArenaSwap(StorageRequestMessage_ListStorageMessage* other) {
2178 if (other == this) return;
2179 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
2180 InternalSwap(other);
2181 }
2182
2183 // implements Message ----------------------------------------------
2184
2185 StorageRequestMessage_ListStorageMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
2186 return CreateMaybeMessage<StorageRequestMessage_ListStorageMessage>(arena);
2187 }
2188 StorageRequestMessage_ListStorageMessage* New() const {
2189 return New(nullptr);
2190 }
2191 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
2192 void CopyFrom(const StorageRequestMessage_ListStorageMessage& from);
2193 void MergeFrom(const StorageRequestMessage_ListStorageMessage& from);
2194 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
2195 bool IsInitialized() const final;
2196
2197 size_t ByteSizeLong() const final;
2198 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
2199 ::uint8_t* _InternalSerialize(
2200 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
2201 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
2202
2203 private:
2204 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
2205 void SharedDtor();
2206 void SetCachedSize(int size) const;
2207 void InternalSwap(StorageRequestMessage_ListStorageMessage* other);
2208
2209 private:
2210 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
2211 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
2212 return "android.aconfigd.StorageRequestMessage.ListStorageMessage";
2213 }
2214 protected:
2215 explicit StorageRequestMessage_ListStorageMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2216 bool is_message_owned = false);
2217 public:
2218
2219 std::string GetTypeName() const final;
2220
2221 // nested types ----------------------------------------------------
2222
2223 // accessors -------------------------------------------------------
2224
2225 enum : int {
2226 kAllFieldNumber = 1,
2227 kContainerFieldNumber = 2,
2228 kPackageNameFieldNumber = 3,
2229 };
2230 // bool all = 1;
2231 bool has_all() const;
2232 private:
2233 bool _internal_has_all() const;
2234 public:
2235 void clear_all();
2236 bool all() const;
2237 void set_all(bool value);
2238 private:
2239 bool _internal_all() const;
2240 void _internal_set_all(bool value);
2241 public:
2242
2243 // string container = 2;
2244 bool has_container() const;
2245 private:
2246 bool _internal_has_container() const;
2247 public:
2248 void clear_container();
2249 const std::string& container() const;
2250 template <typename ArgT0 = const std::string&, typename... ArgT>
2251 void set_container(ArgT0&& arg0, ArgT... args);
2252 std::string* mutable_container();
2253 PROTOBUF_NODISCARD std::string* release_container();
2254 void set_allocated_container(std::string* container);
2255 private:
2256 const std::string& _internal_container() const;
2257 inline PROTOBUF_ALWAYS_INLINE void _internal_set_container(const std::string& value);
2258 std::string* _internal_mutable_container();
2259 public:
2260
2261 // string package_name = 3;
2262 bool has_package_name() const;
2263 private:
2264 bool _internal_has_package_name() const;
2265 public:
2266 void clear_package_name();
2267 const std::string& package_name() const;
2268 template <typename ArgT0 = const std::string&, typename... ArgT>
2269 void set_package_name(ArgT0&& arg0, ArgT... args);
2270 std::string* mutable_package_name();
2271 PROTOBUF_NODISCARD std::string* release_package_name();
2272 void set_allocated_package_name(std::string* package_name);
2273 private:
2274 const std::string& _internal_package_name() const;
2275 inline PROTOBUF_ALWAYS_INLINE void _internal_set_package_name(const std::string& value);
2276 std::string* _internal_mutable_package_name();
2277 public:
2278
2279 void clear_msg();
2280 MsgCase msg_case() const;
2281 // @@protoc_insertion_point(class_scope:android.aconfigd.StorageRequestMessage.ListStorageMessage)
2282 private:
2283 class _Internal;
2284 void set_has_all();
2285 void set_has_container();
2286 void set_has_package_name();
2287
2288 inline bool has_msg() const;
2289 inline void clear_has_msg();
2290
2291 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
2292 typedef void InternalArenaConstructable_;
2293 typedef void DestructorSkippable_;
2294 struct Impl_ {
2295 union MsgUnion {
2296 constexpr MsgUnion() : _constinit_{} {}
2297 ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
2298 bool all_;
2299 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr container_;
2300 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr package_name_;
2301 } msg_;
2302 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2303 ::uint32_t _oneof_case_[1];
2304
2305 };
2306 union { Impl_ _impl_; };
2307 friend struct ::TableStruct_packages_2fmodules_2fConfigInfrastructure_2faconfigd_2fproto_2faconfigd_2eproto;
2308 };
2309 // -------------------------------------------------------------------
2310
2311 class StorageRequestMessage final :
2312 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:android.aconfigd.StorageRequestMessage) */ {
2313 public:
StorageRequestMessage()2314 inline StorageRequestMessage() : StorageRequestMessage(nullptr) {}
2315 ~StorageRequestMessage() override;
2316 explicit PROTOBUF_CONSTEXPR StorageRequestMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
2317
2318 StorageRequestMessage(const StorageRequestMessage& from);
StorageRequestMessage(StorageRequestMessage && from)2319 StorageRequestMessage(StorageRequestMessage&& from) noexcept
2320 : StorageRequestMessage() {
2321 *this = ::std::move(from);
2322 }
2323
2324 inline StorageRequestMessage& operator=(const StorageRequestMessage& from) {
2325 if (this == &from) return *this;
2326 CopyFrom(from);
2327 return *this;
2328 }
2329 inline StorageRequestMessage& operator=(StorageRequestMessage&& from) noexcept {
2330 if (this == &from) return *this;
2331 if (GetOwningArena() == from.GetOwningArena()
2332 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
2333 && GetOwningArena() != nullptr
2334 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
2335 ) {
2336 InternalSwap(&from);
2337 } else {
2338 CopyFrom(from);
2339 }
2340 return *this;
2341 }
2342
unknown_fields()2343 inline const std::string& unknown_fields() const {
2344 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
2345 }
mutable_unknown_fields()2346 inline std::string* mutable_unknown_fields() {
2347 return _internal_metadata_.mutable_unknown_fields<std::string>();
2348 }
2349
default_instance()2350 static const StorageRequestMessage& default_instance() {
2351 return *internal_default_instance();
2352 }
2353 enum MsgCase {
2354 kNewStorageMessage = 1,
2355 kFlagOverrideMessage = 2,
2356 kOtaStagingMessage = 3,
2357 kFlagQueryMessage = 4,
2358 kRemoveLocalOverrideMessage = 5,
2359 kResetStorageMessage = 6,
2360 kListStorageMessage = 7,
2361 MSG_NOT_SET = 0,
2362 };
2363
internal_default_instance()2364 static inline const StorageRequestMessage* internal_default_instance() {
2365 return reinterpret_cast<const StorageRequestMessage*>(
2366 &_StorageRequestMessage_default_instance_);
2367 }
2368 static constexpr int kIndexInFileMessages =
2369 11;
2370
swap(StorageRequestMessage & a,StorageRequestMessage & b)2371 friend void swap(StorageRequestMessage& a, StorageRequestMessage& b) {
2372 a.Swap(&b);
2373 }
Swap(StorageRequestMessage * other)2374 inline void Swap(StorageRequestMessage* other) {
2375 if (other == this) return;
2376 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
2377 if (GetOwningArena() != nullptr &&
2378 GetOwningArena() == other->GetOwningArena()) {
2379 #else // PROTOBUF_FORCE_COPY_IN_SWAP
2380 if (GetOwningArena() == other->GetOwningArena()) {
2381 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
2382 InternalSwap(other);
2383 } else {
2384 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
2385 }
2386 }
2387 void UnsafeArenaSwap(StorageRequestMessage* other) {
2388 if (other == this) return;
2389 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
2390 InternalSwap(other);
2391 }
2392
2393 // implements Message ----------------------------------------------
2394
2395 StorageRequestMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
2396 return CreateMaybeMessage<StorageRequestMessage>(arena);
2397 }
2398 StorageRequestMessage* New() const {
2399 return New(nullptr);
2400 }
2401 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
2402 void CopyFrom(const StorageRequestMessage& from);
2403 void MergeFrom(const StorageRequestMessage& from);
2404 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
2405 bool IsInitialized() const final;
2406
2407 size_t ByteSizeLong() const final;
2408 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
2409 ::uint8_t* _InternalSerialize(
2410 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
2411 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
2412
2413 private:
2414 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
2415 void SharedDtor();
2416 void SetCachedSize(int size) const;
2417 void InternalSwap(StorageRequestMessage* other);
2418
2419 private:
2420 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
2421 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
2422 return "android.aconfigd.StorageRequestMessage";
2423 }
2424 protected:
2425 explicit StorageRequestMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2426 bool is_message_owned = false);
2427 public:
2428
2429 std::string GetTypeName() const final;
2430
2431 // nested types ----------------------------------------------------
2432
2433 typedef StorageRequestMessage_NewStorageMessage NewStorageMessage;
2434 typedef StorageRequestMessage_FlagOverrideMessage FlagOverrideMessage;
2435 typedef StorageRequestMessage_OTAFlagStagingMessage OTAFlagStagingMessage;
2436 typedef StorageRequestMessage_RemoveLocalOverrideMessage RemoveLocalOverrideMessage;
2437 typedef StorageRequestMessage_FlagQueryMessage FlagQueryMessage;
2438 typedef StorageRequestMessage_ResetStorageMessage ResetStorageMessage;
2439 typedef StorageRequestMessage_ListStorageMessage ListStorageMessage;
2440
2441 typedef StorageRequestMessage_FlagOverrideType FlagOverrideType;
2442 static constexpr FlagOverrideType LOCAL_IMMEDIATE =
2443 StorageRequestMessage_FlagOverrideType_LOCAL_IMMEDIATE;
2444 static constexpr FlagOverrideType LOCAL_ON_REBOOT =
2445 StorageRequestMessage_FlagOverrideType_LOCAL_ON_REBOOT;
2446 static constexpr FlagOverrideType SERVER_ON_REBOOT =
2447 StorageRequestMessage_FlagOverrideType_SERVER_ON_REBOOT;
2448 static inline bool FlagOverrideType_IsValid(int value) {
2449 return StorageRequestMessage_FlagOverrideType_IsValid(value);
2450 }
2451 static constexpr FlagOverrideType FlagOverrideType_MIN =
2452 StorageRequestMessage_FlagOverrideType_FlagOverrideType_MIN;
2453 static constexpr FlagOverrideType FlagOverrideType_MAX =
2454 StorageRequestMessage_FlagOverrideType_FlagOverrideType_MAX;
2455 static constexpr int FlagOverrideType_ARRAYSIZE =
2456 StorageRequestMessage_FlagOverrideType_FlagOverrideType_ARRAYSIZE;
2457 template<typename T>
2458 static inline const std::string& FlagOverrideType_Name(T enum_t_value) {
2459 static_assert(::std::is_same<T, FlagOverrideType>::value ||
2460 ::std::is_integral<T>::value,
2461 "Incorrect type passed to function FlagOverrideType_Name.");
2462 return StorageRequestMessage_FlagOverrideType_Name(enum_t_value);
2463 }
2464 static inline bool FlagOverrideType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
2465 FlagOverrideType* value) {
2466 return StorageRequestMessage_FlagOverrideType_Parse(name, value);
2467 }
2468
2469 typedef StorageRequestMessage_RemoveOverrideType RemoveOverrideType;
2470 static constexpr RemoveOverrideType REMOVE_LOCAL_IMMEDIATE =
2471 StorageRequestMessage_RemoveOverrideType_REMOVE_LOCAL_IMMEDIATE;
2472 static constexpr RemoveOverrideType REMOVE_LOCAL_ON_REBOOT =
2473 StorageRequestMessage_RemoveOverrideType_REMOVE_LOCAL_ON_REBOOT;
2474 static inline bool RemoveOverrideType_IsValid(int value) {
2475 return StorageRequestMessage_RemoveOverrideType_IsValid(value);
2476 }
2477 static constexpr RemoveOverrideType RemoveOverrideType_MIN =
2478 StorageRequestMessage_RemoveOverrideType_RemoveOverrideType_MIN;
2479 static constexpr RemoveOverrideType RemoveOverrideType_MAX =
2480 StorageRequestMessage_RemoveOverrideType_RemoveOverrideType_MAX;
2481 static constexpr int RemoveOverrideType_ARRAYSIZE =
2482 StorageRequestMessage_RemoveOverrideType_RemoveOverrideType_ARRAYSIZE;
2483 template<typename T>
2484 static inline const std::string& RemoveOverrideType_Name(T enum_t_value) {
2485 static_assert(::std::is_same<T, RemoveOverrideType>::value ||
2486 ::std::is_integral<T>::value,
2487 "Incorrect type passed to function RemoveOverrideType_Name.");
2488 return StorageRequestMessage_RemoveOverrideType_Name(enum_t_value);
2489 }
2490 static inline bool RemoveOverrideType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
2491 RemoveOverrideType* value) {
2492 return StorageRequestMessage_RemoveOverrideType_Parse(name, value);
2493 }
2494
2495 // accessors -------------------------------------------------------
2496
2497 enum : int {
2498 kNewStorageMessageFieldNumber = 1,
2499 kFlagOverrideMessageFieldNumber = 2,
2500 kOtaStagingMessageFieldNumber = 3,
2501 kFlagQueryMessageFieldNumber = 4,
2502 kRemoveLocalOverrideMessageFieldNumber = 5,
2503 kResetStorageMessageFieldNumber = 6,
2504 kListStorageMessageFieldNumber = 7,
2505 };
2506 // .android.aconfigd.StorageRequestMessage.NewStorageMessage new_storage_message = 1;
2507 bool has_new_storage_message() const;
2508 private:
2509 bool _internal_has_new_storage_message() const;
2510 public:
2511 void clear_new_storage_message();
2512 const ::android::aconfigd::StorageRequestMessage_NewStorageMessage& new_storage_message() const;
2513 PROTOBUF_NODISCARD ::android::aconfigd::StorageRequestMessage_NewStorageMessage* release_new_storage_message();
2514 ::android::aconfigd::StorageRequestMessage_NewStorageMessage* mutable_new_storage_message();
2515 void set_allocated_new_storage_message(::android::aconfigd::StorageRequestMessage_NewStorageMessage* new_storage_message);
2516 private:
2517 const ::android::aconfigd::StorageRequestMessage_NewStorageMessage& _internal_new_storage_message() const;
2518 ::android::aconfigd::StorageRequestMessage_NewStorageMessage* _internal_mutable_new_storage_message();
2519 public:
2520 void unsafe_arena_set_allocated_new_storage_message(
2521 ::android::aconfigd::StorageRequestMessage_NewStorageMessage* new_storage_message);
2522 ::android::aconfigd::StorageRequestMessage_NewStorageMessage* unsafe_arena_release_new_storage_message();
2523
2524 // .android.aconfigd.StorageRequestMessage.FlagOverrideMessage flag_override_message = 2;
2525 bool has_flag_override_message() const;
2526 private:
2527 bool _internal_has_flag_override_message() const;
2528 public:
2529 void clear_flag_override_message();
2530 const ::android::aconfigd::StorageRequestMessage_FlagOverrideMessage& flag_override_message() const;
2531 PROTOBUF_NODISCARD ::android::aconfigd::StorageRequestMessage_FlagOverrideMessage* release_flag_override_message();
2532 ::android::aconfigd::StorageRequestMessage_FlagOverrideMessage* mutable_flag_override_message();
2533 void set_allocated_flag_override_message(::android::aconfigd::StorageRequestMessage_FlagOverrideMessage* flag_override_message);
2534 private:
2535 const ::android::aconfigd::StorageRequestMessage_FlagOverrideMessage& _internal_flag_override_message() const;
2536 ::android::aconfigd::StorageRequestMessage_FlagOverrideMessage* _internal_mutable_flag_override_message();
2537 public:
2538 void unsafe_arena_set_allocated_flag_override_message(
2539 ::android::aconfigd::StorageRequestMessage_FlagOverrideMessage* flag_override_message);
2540 ::android::aconfigd::StorageRequestMessage_FlagOverrideMessage* unsafe_arena_release_flag_override_message();
2541
2542 // .android.aconfigd.StorageRequestMessage.OTAFlagStagingMessage ota_staging_message = 3;
2543 bool has_ota_staging_message() const;
2544 private:
2545 bool _internal_has_ota_staging_message() const;
2546 public:
2547 void clear_ota_staging_message();
2548 const ::android::aconfigd::StorageRequestMessage_OTAFlagStagingMessage& ota_staging_message() const;
2549 PROTOBUF_NODISCARD ::android::aconfigd::StorageRequestMessage_OTAFlagStagingMessage* release_ota_staging_message();
2550 ::android::aconfigd::StorageRequestMessage_OTAFlagStagingMessage* mutable_ota_staging_message();
2551 void set_allocated_ota_staging_message(::android::aconfigd::StorageRequestMessage_OTAFlagStagingMessage* ota_staging_message);
2552 private:
2553 const ::android::aconfigd::StorageRequestMessage_OTAFlagStagingMessage& _internal_ota_staging_message() const;
2554 ::android::aconfigd::StorageRequestMessage_OTAFlagStagingMessage* _internal_mutable_ota_staging_message();
2555 public:
2556 void unsafe_arena_set_allocated_ota_staging_message(
2557 ::android::aconfigd::StorageRequestMessage_OTAFlagStagingMessage* ota_staging_message);
2558 ::android::aconfigd::StorageRequestMessage_OTAFlagStagingMessage* unsafe_arena_release_ota_staging_message();
2559
2560 // .android.aconfigd.StorageRequestMessage.FlagQueryMessage flag_query_message = 4;
2561 bool has_flag_query_message() const;
2562 private:
2563 bool _internal_has_flag_query_message() const;
2564 public:
2565 void clear_flag_query_message();
2566 const ::android::aconfigd::StorageRequestMessage_FlagQueryMessage& flag_query_message() const;
2567 PROTOBUF_NODISCARD ::android::aconfigd::StorageRequestMessage_FlagQueryMessage* release_flag_query_message();
2568 ::android::aconfigd::StorageRequestMessage_FlagQueryMessage* mutable_flag_query_message();
2569 void set_allocated_flag_query_message(::android::aconfigd::StorageRequestMessage_FlagQueryMessage* flag_query_message);
2570 private:
2571 const ::android::aconfigd::StorageRequestMessage_FlagQueryMessage& _internal_flag_query_message() const;
2572 ::android::aconfigd::StorageRequestMessage_FlagQueryMessage* _internal_mutable_flag_query_message();
2573 public:
2574 void unsafe_arena_set_allocated_flag_query_message(
2575 ::android::aconfigd::StorageRequestMessage_FlagQueryMessage* flag_query_message);
2576 ::android::aconfigd::StorageRequestMessage_FlagQueryMessage* unsafe_arena_release_flag_query_message();
2577
2578 // .android.aconfigd.StorageRequestMessage.RemoveLocalOverrideMessage remove_local_override_message = 5;
2579 bool has_remove_local_override_message() const;
2580 private:
2581 bool _internal_has_remove_local_override_message() const;
2582 public:
2583 void clear_remove_local_override_message();
2584 const ::android::aconfigd::StorageRequestMessage_RemoveLocalOverrideMessage& remove_local_override_message() const;
2585 PROTOBUF_NODISCARD ::android::aconfigd::StorageRequestMessage_RemoveLocalOverrideMessage* release_remove_local_override_message();
2586 ::android::aconfigd::StorageRequestMessage_RemoveLocalOverrideMessage* mutable_remove_local_override_message();
2587 void set_allocated_remove_local_override_message(::android::aconfigd::StorageRequestMessage_RemoveLocalOverrideMessage* remove_local_override_message);
2588 private:
2589 const ::android::aconfigd::StorageRequestMessage_RemoveLocalOverrideMessage& _internal_remove_local_override_message() const;
2590 ::android::aconfigd::StorageRequestMessage_RemoveLocalOverrideMessage* _internal_mutable_remove_local_override_message();
2591 public:
2592 void unsafe_arena_set_allocated_remove_local_override_message(
2593 ::android::aconfigd::StorageRequestMessage_RemoveLocalOverrideMessage* remove_local_override_message);
2594 ::android::aconfigd::StorageRequestMessage_RemoveLocalOverrideMessage* unsafe_arena_release_remove_local_override_message();
2595
2596 // .android.aconfigd.StorageRequestMessage.ResetStorageMessage reset_storage_message = 6;
2597 bool has_reset_storage_message() const;
2598 private:
2599 bool _internal_has_reset_storage_message() const;
2600 public:
2601 void clear_reset_storage_message();
2602 const ::android::aconfigd::StorageRequestMessage_ResetStorageMessage& reset_storage_message() const;
2603 PROTOBUF_NODISCARD ::android::aconfigd::StorageRequestMessage_ResetStorageMessage* release_reset_storage_message();
2604 ::android::aconfigd::StorageRequestMessage_ResetStorageMessage* mutable_reset_storage_message();
2605 void set_allocated_reset_storage_message(::android::aconfigd::StorageRequestMessage_ResetStorageMessage* reset_storage_message);
2606 private:
2607 const ::android::aconfigd::StorageRequestMessage_ResetStorageMessage& _internal_reset_storage_message() const;
2608 ::android::aconfigd::StorageRequestMessage_ResetStorageMessage* _internal_mutable_reset_storage_message();
2609 public:
2610 void unsafe_arena_set_allocated_reset_storage_message(
2611 ::android::aconfigd::StorageRequestMessage_ResetStorageMessage* reset_storage_message);
2612 ::android::aconfigd::StorageRequestMessage_ResetStorageMessage* unsafe_arena_release_reset_storage_message();
2613
2614 // .android.aconfigd.StorageRequestMessage.ListStorageMessage list_storage_message = 7;
2615 bool has_list_storage_message() const;
2616 private:
2617 bool _internal_has_list_storage_message() const;
2618 public:
2619 void clear_list_storage_message();
2620 const ::android::aconfigd::StorageRequestMessage_ListStorageMessage& list_storage_message() const;
2621 PROTOBUF_NODISCARD ::android::aconfigd::StorageRequestMessage_ListStorageMessage* release_list_storage_message();
2622 ::android::aconfigd::StorageRequestMessage_ListStorageMessage* mutable_list_storage_message();
2623 void set_allocated_list_storage_message(::android::aconfigd::StorageRequestMessage_ListStorageMessage* list_storage_message);
2624 private:
2625 const ::android::aconfigd::StorageRequestMessage_ListStorageMessage& _internal_list_storage_message() const;
2626 ::android::aconfigd::StorageRequestMessage_ListStorageMessage* _internal_mutable_list_storage_message();
2627 public:
2628 void unsafe_arena_set_allocated_list_storage_message(
2629 ::android::aconfigd::StorageRequestMessage_ListStorageMessage* list_storage_message);
2630 ::android::aconfigd::StorageRequestMessage_ListStorageMessage* unsafe_arena_release_list_storage_message();
2631
2632 void clear_msg();
2633 MsgCase msg_case() const;
2634 // @@protoc_insertion_point(class_scope:android.aconfigd.StorageRequestMessage)
2635 private:
2636 class _Internal;
2637 void set_has_new_storage_message();
2638 void set_has_flag_override_message();
2639 void set_has_ota_staging_message();
2640 void set_has_flag_query_message();
2641 void set_has_remove_local_override_message();
2642 void set_has_reset_storage_message();
2643 void set_has_list_storage_message();
2644
2645 inline bool has_msg() const;
2646 inline void clear_has_msg();
2647
2648 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
2649 typedef void InternalArenaConstructable_;
2650 typedef void DestructorSkippable_;
2651 struct Impl_ {
2652 union MsgUnion {
2653 constexpr MsgUnion() : _constinit_{} {}
2654 ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
2655 ::android::aconfigd::StorageRequestMessage_NewStorageMessage* new_storage_message_;
2656 ::android::aconfigd::StorageRequestMessage_FlagOverrideMessage* flag_override_message_;
2657 ::android::aconfigd::StorageRequestMessage_OTAFlagStagingMessage* ota_staging_message_;
2658 ::android::aconfigd::StorageRequestMessage_FlagQueryMessage* flag_query_message_;
2659 ::android::aconfigd::StorageRequestMessage_RemoveLocalOverrideMessage* remove_local_override_message_;
2660 ::android::aconfigd::StorageRequestMessage_ResetStorageMessage* reset_storage_message_;
2661 ::android::aconfigd::StorageRequestMessage_ListStorageMessage* list_storage_message_;
2662 } msg_;
2663 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2664 ::uint32_t _oneof_case_[1];
2665
2666 };
2667 union { Impl_ _impl_; };
2668 friend struct ::TableStruct_packages_2fmodules_2fConfigInfrastructure_2faconfigd_2fproto_2faconfigd_2eproto;
2669 };
2670 // -------------------------------------------------------------------
2671
2672 class StorageRequestMessages final :
2673 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:android.aconfigd.StorageRequestMessages) */ {
2674 public:
StorageRequestMessages()2675 inline StorageRequestMessages() : StorageRequestMessages(nullptr) {}
2676 ~StorageRequestMessages() override;
2677 explicit PROTOBUF_CONSTEXPR StorageRequestMessages(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
2678
2679 StorageRequestMessages(const StorageRequestMessages& from);
StorageRequestMessages(StorageRequestMessages && from)2680 StorageRequestMessages(StorageRequestMessages&& from) noexcept
2681 : StorageRequestMessages() {
2682 *this = ::std::move(from);
2683 }
2684
2685 inline StorageRequestMessages& operator=(const StorageRequestMessages& from) {
2686 if (this == &from) return *this;
2687 CopyFrom(from);
2688 return *this;
2689 }
2690 inline StorageRequestMessages& operator=(StorageRequestMessages&& from) noexcept {
2691 if (this == &from) return *this;
2692 if (GetOwningArena() == from.GetOwningArena()
2693 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
2694 && GetOwningArena() != nullptr
2695 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
2696 ) {
2697 InternalSwap(&from);
2698 } else {
2699 CopyFrom(from);
2700 }
2701 return *this;
2702 }
2703
unknown_fields()2704 inline const std::string& unknown_fields() const {
2705 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
2706 }
mutable_unknown_fields()2707 inline std::string* mutable_unknown_fields() {
2708 return _internal_metadata_.mutable_unknown_fields<std::string>();
2709 }
2710
default_instance()2711 static const StorageRequestMessages& default_instance() {
2712 return *internal_default_instance();
2713 }
internal_default_instance()2714 static inline const StorageRequestMessages* internal_default_instance() {
2715 return reinterpret_cast<const StorageRequestMessages*>(
2716 &_StorageRequestMessages_default_instance_);
2717 }
2718 static constexpr int kIndexInFileMessages =
2719 12;
2720
swap(StorageRequestMessages & a,StorageRequestMessages & b)2721 friend void swap(StorageRequestMessages& a, StorageRequestMessages& b) {
2722 a.Swap(&b);
2723 }
Swap(StorageRequestMessages * other)2724 inline void Swap(StorageRequestMessages* other) {
2725 if (other == this) return;
2726 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
2727 if (GetOwningArena() != nullptr &&
2728 GetOwningArena() == other->GetOwningArena()) {
2729 #else // PROTOBUF_FORCE_COPY_IN_SWAP
2730 if (GetOwningArena() == other->GetOwningArena()) {
2731 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
2732 InternalSwap(other);
2733 } else {
2734 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
2735 }
2736 }
2737 void UnsafeArenaSwap(StorageRequestMessages* other) {
2738 if (other == this) return;
2739 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
2740 InternalSwap(other);
2741 }
2742
2743 // implements Message ----------------------------------------------
2744
2745 StorageRequestMessages* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
2746 return CreateMaybeMessage<StorageRequestMessages>(arena);
2747 }
2748 StorageRequestMessages* New() const {
2749 return New(nullptr);
2750 }
2751 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
2752 void CopyFrom(const StorageRequestMessages& from);
2753 void MergeFrom(const StorageRequestMessages& from);
2754 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
2755 bool IsInitialized() const final;
2756
2757 size_t ByteSizeLong() const final;
2758 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
2759 ::uint8_t* _InternalSerialize(
2760 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
2761 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
2762
2763 private:
2764 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
2765 void SharedDtor();
2766 void SetCachedSize(int size) const;
2767 void InternalSwap(StorageRequestMessages* other);
2768
2769 private:
2770 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
2771 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
2772 return "android.aconfigd.StorageRequestMessages";
2773 }
2774 protected:
2775 explicit StorageRequestMessages(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2776 bool is_message_owned = false);
2777 public:
2778
2779 std::string GetTypeName() const final;
2780
2781 // nested types ----------------------------------------------------
2782
2783 // accessors -------------------------------------------------------
2784
2785 enum : int {
2786 kMsgsFieldNumber = 1,
2787 };
2788 // repeated .android.aconfigd.StorageRequestMessage msgs = 1;
2789 int msgs_size() const;
2790 private:
2791 int _internal_msgs_size() const;
2792 public:
2793 void clear_msgs();
2794 ::android::aconfigd::StorageRequestMessage* mutable_msgs(int index);
2795 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::android::aconfigd::StorageRequestMessage >*
2796 mutable_msgs();
2797 private:
2798 const ::android::aconfigd::StorageRequestMessage& _internal_msgs(int index) const;
2799 ::android::aconfigd::StorageRequestMessage* _internal_add_msgs();
2800 public:
2801 const ::android::aconfigd::StorageRequestMessage& msgs(int index) const;
2802 ::android::aconfigd::StorageRequestMessage* add_msgs();
2803 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::android::aconfigd::StorageRequestMessage >&
2804 msgs() const;
2805
2806 // @@protoc_insertion_point(class_scope:android.aconfigd.StorageRequestMessages)
2807 private:
2808 class _Internal;
2809
2810 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
2811 typedef void InternalArenaConstructable_;
2812 typedef void DestructorSkippable_;
2813 struct Impl_ {
2814 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::android::aconfigd::StorageRequestMessage > msgs_;
2815 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2816 };
2817 union { Impl_ _impl_; };
2818 friend struct ::TableStruct_packages_2fmodules_2fConfigInfrastructure_2faconfigd_2fproto_2faconfigd_2eproto;
2819 };
2820 // -------------------------------------------------------------------
2821
2822 class StorageReturnMessage_NewStorageReturnMessage final :
2823 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:android.aconfigd.StorageReturnMessage.NewStorageReturnMessage) */ {
2824 public:
StorageReturnMessage_NewStorageReturnMessage()2825 inline StorageReturnMessage_NewStorageReturnMessage() : StorageReturnMessage_NewStorageReturnMessage(nullptr) {}
2826 ~StorageReturnMessage_NewStorageReturnMessage() override;
2827 explicit PROTOBUF_CONSTEXPR StorageReturnMessage_NewStorageReturnMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
2828
2829 StorageReturnMessage_NewStorageReturnMessage(const StorageReturnMessage_NewStorageReturnMessage& from);
StorageReturnMessage_NewStorageReturnMessage(StorageReturnMessage_NewStorageReturnMessage && from)2830 StorageReturnMessage_NewStorageReturnMessage(StorageReturnMessage_NewStorageReturnMessage&& from) noexcept
2831 : StorageReturnMessage_NewStorageReturnMessage() {
2832 *this = ::std::move(from);
2833 }
2834
2835 inline StorageReturnMessage_NewStorageReturnMessage& operator=(const StorageReturnMessage_NewStorageReturnMessage& from) {
2836 if (this == &from) return *this;
2837 CopyFrom(from);
2838 return *this;
2839 }
2840 inline StorageReturnMessage_NewStorageReturnMessage& operator=(StorageReturnMessage_NewStorageReturnMessage&& from) noexcept {
2841 if (this == &from) return *this;
2842 if (GetOwningArena() == from.GetOwningArena()
2843 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
2844 && GetOwningArena() != nullptr
2845 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
2846 ) {
2847 InternalSwap(&from);
2848 } else {
2849 CopyFrom(from);
2850 }
2851 return *this;
2852 }
2853
unknown_fields()2854 inline const std::string& unknown_fields() const {
2855 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
2856 }
mutable_unknown_fields()2857 inline std::string* mutable_unknown_fields() {
2858 return _internal_metadata_.mutable_unknown_fields<std::string>();
2859 }
2860
default_instance()2861 static const StorageReturnMessage_NewStorageReturnMessage& default_instance() {
2862 return *internal_default_instance();
2863 }
internal_default_instance()2864 static inline const StorageReturnMessage_NewStorageReturnMessage* internal_default_instance() {
2865 return reinterpret_cast<const StorageReturnMessage_NewStorageReturnMessage*>(
2866 &_StorageReturnMessage_NewStorageReturnMessage_default_instance_);
2867 }
2868 static constexpr int kIndexInFileMessages =
2869 13;
2870
swap(StorageReturnMessage_NewStorageReturnMessage & a,StorageReturnMessage_NewStorageReturnMessage & b)2871 friend void swap(StorageReturnMessage_NewStorageReturnMessage& a, StorageReturnMessage_NewStorageReturnMessage& b) {
2872 a.Swap(&b);
2873 }
Swap(StorageReturnMessage_NewStorageReturnMessage * other)2874 inline void Swap(StorageReturnMessage_NewStorageReturnMessage* other) {
2875 if (other == this) return;
2876 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
2877 if (GetOwningArena() != nullptr &&
2878 GetOwningArena() == other->GetOwningArena()) {
2879 #else // PROTOBUF_FORCE_COPY_IN_SWAP
2880 if (GetOwningArena() == other->GetOwningArena()) {
2881 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
2882 InternalSwap(other);
2883 } else {
2884 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
2885 }
2886 }
2887 void UnsafeArenaSwap(StorageReturnMessage_NewStorageReturnMessage* other) {
2888 if (other == this) return;
2889 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
2890 InternalSwap(other);
2891 }
2892
2893 // implements Message ----------------------------------------------
2894
2895 StorageReturnMessage_NewStorageReturnMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
2896 return CreateMaybeMessage<StorageReturnMessage_NewStorageReturnMessage>(arena);
2897 }
2898 StorageReturnMessage_NewStorageReturnMessage* New() const {
2899 return New(nullptr);
2900 }
2901 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
2902 void CopyFrom(const StorageReturnMessage_NewStorageReturnMessage& from);
2903 void MergeFrom(const StorageReturnMessage_NewStorageReturnMessage& from);
2904 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
2905 bool IsInitialized() const final;
2906
2907 size_t ByteSizeLong() const final;
2908 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
2909 ::uint8_t* _InternalSerialize(
2910 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
2911 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
2912
2913 private:
2914 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
2915 void SharedDtor();
2916 void SetCachedSize(int size) const;
2917 void InternalSwap(StorageReturnMessage_NewStorageReturnMessage* other);
2918
2919 private:
2920 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
2921 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
2922 return "android.aconfigd.StorageReturnMessage.NewStorageReturnMessage";
2923 }
2924 protected:
2925 explicit StorageReturnMessage_NewStorageReturnMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2926 bool is_message_owned = false);
2927 public:
2928
2929 std::string GetTypeName() const final;
2930
2931 // nested types ----------------------------------------------------
2932
2933 // accessors -------------------------------------------------------
2934
2935 enum : int {
2936 kStorageUpdatedFieldNumber = 1,
2937 };
2938 // optional bool storage_updated = 1;
2939 bool has_storage_updated() const;
2940 private:
2941 bool _internal_has_storage_updated() const;
2942 public:
2943 void clear_storage_updated();
2944 bool storage_updated() const;
2945 void set_storage_updated(bool value);
2946 private:
2947 bool _internal_storage_updated() const;
2948 void _internal_set_storage_updated(bool value);
2949 public:
2950
2951 // @@protoc_insertion_point(class_scope:android.aconfigd.StorageReturnMessage.NewStorageReturnMessage)
2952 private:
2953 class _Internal;
2954
2955 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
2956 typedef void InternalArenaConstructable_;
2957 typedef void DestructorSkippable_;
2958 struct Impl_ {
2959 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
2960 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2961 bool storage_updated_;
2962 };
2963 union { Impl_ _impl_; };
2964 friend struct ::TableStruct_packages_2fmodules_2fConfigInfrastructure_2faconfigd_2fproto_2faconfigd_2eproto;
2965 };
2966 // -------------------------------------------------------------------
2967
2968 class StorageReturnMessage_FlagOverrideReturnMessage final :
2969 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:android.aconfigd.StorageReturnMessage.FlagOverrideReturnMessage) */ {
2970 public:
StorageReturnMessage_FlagOverrideReturnMessage()2971 inline StorageReturnMessage_FlagOverrideReturnMessage() : StorageReturnMessage_FlagOverrideReturnMessage(nullptr) {}
2972 ~StorageReturnMessage_FlagOverrideReturnMessage() override;
2973 explicit PROTOBUF_CONSTEXPR StorageReturnMessage_FlagOverrideReturnMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
2974
2975 StorageReturnMessage_FlagOverrideReturnMessage(const StorageReturnMessage_FlagOverrideReturnMessage& from);
StorageReturnMessage_FlagOverrideReturnMessage(StorageReturnMessage_FlagOverrideReturnMessage && from)2976 StorageReturnMessage_FlagOverrideReturnMessage(StorageReturnMessage_FlagOverrideReturnMessage&& from) noexcept
2977 : StorageReturnMessage_FlagOverrideReturnMessage() {
2978 *this = ::std::move(from);
2979 }
2980
2981 inline StorageReturnMessage_FlagOverrideReturnMessage& operator=(const StorageReturnMessage_FlagOverrideReturnMessage& from) {
2982 if (this == &from) return *this;
2983 CopyFrom(from);
2984 return *this;
2985 }
2986 inline StorageReturnMessage_FlagOverrideReturnMessage& operator=(StorageReturnMessage_FlagOverrideReturnMessage&& from) noexcept {
2987 if (this == &from) return *this;
2988 if (GetOwningArena() == from.GetOwningArena()
2989 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
2990 && GetOwningArena() != nullptr
2991 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
2992 ) {
2993 InternalSwap(&from);
2994 } else {
2995 CopyFrom(from);
2996 }
2997 return *this;
2998 }
2999
unknown_fields()3000 inline const std::string& unknown_fields() const {
3001 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
3002 }
mutable_unknown_fields()3003 inline std::string* mutable_unknown_fields() {
3004 return _internal_metadata_.mutable_unknown_fields<std::string>();
3005 }
3006
default_instance()3007 static const StorageReturnMessage_FlagOverrideReturnMessage& default_instance() {
3008 return *internal_default_instance();
3009 }
internal_default_instance()3010 static inline const StorageReturnMessage_FlagOverrideReturnMessage* internal_default_instance() {
3011 return reinterpret_cast<const StorageReturnMessage_FlagOverrideReturnMessage*>(
3012 &_StorageReturnMessage_FlagOverrideReturnMessage_default_instance_);
3013 }
3014 static constexpr int kIndexInFileMessages =
3015 14;
3016
swap(StorageReturnMessage_FlagOverrideReturnMessage & a,StorageReturnMessage_FlagOverrideReturnMessage & b)3017 friend void swap(StorageReturnMessage_FlagOverrideReturnMessage& a, StorageReturnMessage_FlagOverrideReturnMessage& b) {
3018 a.Swap(&b);
3019 }
Swap(StorageReturnMessage_FlagOverrideReturnMessage * other)3020 inline void Swap(StorageReturnMessage_FlagOverrideReturnMessage* other) {
3021 if (other == this) return;
3022 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
3023 if (GetOwningArena() != nullptr &&
3024 GetOwningArena() == other->GetOwningArena()) {
3025 #else // PROTOBUF_FORCE_COPY_IN_SWAP
3026 if (GetOwningArena() == other->GetOwningArena()) {
3027 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
3028 InternalSwap(other);
3029 } else {
3030 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
3031 }
3032 }
3033 void UnsafeArenaSwap(StorageReturnMessage_FlagOverrideReturnMessage* other) {
3034 if (other == this) return;
3035 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
3036 InternalSwap(other);
3037 }
3038
3039 // implements Message ----------------------------------------------
3040
3041 StorageReturnMessage_FlagOverrideReturnMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
3042 return CreateMaybeMessage<StorageReturnMessage_FlagOverrideReturnMessage>(arena);
3043 }
3044 StorageReturnMessage_FlagOverrideReturnMessage* New() const {
3045 return New(nullptr);
3046 }
3047 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
3048 void CopyFrom(const StorageReturnMessage_FlagOverrideReturnMessage& from);
3049 void MergeFrom(const StorageReturnMessage_FlagOverrideReturnMessage& from);
3050 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
3051 bool IsInitialized() const final;
3052
3053 size_t ByteSizeLong() const final;
3054 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
3055 ::uint8_t* _InternalSerialize(
3056 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
3057 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
3058
3059 private:
3060 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
3061 void SharedDtor();
3062 void SetCachedSize(int size) const;
3063 void InternalSwap(StorageReturnMessage_FlagOverrideReturnMessage* other);
3064
3065 private:
3066 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
3067 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
3068 return "android.aconfigd.StorageReturnMessage.FlagOverrideReturnMessage";
3069 }
3070 protected:
3071 explicit StorageReturnMessage_FlagOverrideReturnMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
3072 bool is_message_owned = false);
3073 public:
3074
3075 std::string GetTypeName() const final;
3076
3077 // nested types ----------------------------------------------------
3078
3079 // accessors -------------------------------------------------------
3080
3081 // @@protoc_insertion_point(class_scope:android.aconfigd.StorageReturnMessage.FlagOverrideReturnMessage)
3082 private:
3083 class _Internal;
3084
3085 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
3086 typedef void InternalArenaConstructable_;
3087 typedef void DestructorSkippable_;
3088 struct Impl_ {
3089 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
3090 };
3091 union { Impl_ _impl_; };
3092 friend struct ::TableStruct_packages_2fmodules_2fConfigInfrastructure_2faconfigd_2fproto_2faconfigd_2eproto;
3093 };
3094 // -------------------------------------------------------------------
3095
3096 class StorageReturnMessage_OTAFlagStagingReturnMessage final :
3097 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:android.aconfigd.StorageReturnMessage.OTAFlagStagingReturnMessage) */ {
3098 public:
StorageReturnMessage_OTAFlagStagingReturnMessage()3099 inline StorageReturnMessage_OTAFlagStagingReturnMessage() : StorageReturnMessage_OTAFlagStagingReturnMessage(nullptr) {}
3100 ~StorageReturnMessage_OTAFlagStagingReturnMessage() override;
3101 explicit PROTOBUF_CONSTEXPR StorageReturnMessage_OTAFlagStagingReturnMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
3102
3103 StorageReturnMessage_OTAFlagStagingReturnMessage(const StorageReturnMessage_OTAFlagStagingReturnMessage& from);
StorageReturnMessage_OTAFlagStagingReturnMessage(StorageReturnMessage_OTAFlagStagingReturnMessage && from)3104 StorageReturnMessage_OTAFlagStagingReturnMessage(StorageReturnMessage_OTAFlagStagingReturnMessage&& from) noexcept
3105 : StorageReturnMessage_OTAFlagStagingReturnMessage() {
3106 *this = ::std::move(from);
3107 }
3108
3109 inline StorageReturnMessage_OTAFlagStagingReturnMessage& operator=(const StorageReturnMessage_OTAFlagStagingReturnMessage& from) {
3110 if (this == &from) return *this;
3111 CopyFrom(from);
3112 return *this;
3113 }
3114 inline StorageReturnMessage_OTAFlagStagingReturnMessage& operator=(StorageReturnMessage_OTAFlagStagingReturnMessage&& from) noexcept {
3115 if (this == &from) return *this;
3116 if (GetOwningArena() == from.GetOwningArena()
3117 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
3118 && GetOwningArena() != nullptr
3119 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
3120 ) {
3121 InternalSwap(&from);
3122 } else {
3123 CopyFrom(from);
3124 }
3125 return *this;
3126 }
3127
unknown_fields()3128 inline const std::string& unknown_fields() const {
3129 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
3130 }
mutable_unknown_fields()3131 inline std::string* mutable_unknown_fields() {
3132 return _internal_metadata_.mutable_unknown_fields<std::string>();
3133 }
3134
default_instance()3135 static const StorageReturnMessage_OTAFlagStagingReturnMessage& default_instance() {
3136 return *internal_default_instance();
3137 }
internal_default_instance()3138 static inline const StorageReturnMessage_OTAFlagStagingReturnMessage* internal_default_instance() {
3139 return reinterpret_cast<const StorageReturnMessage_OTAFlagStagingReturnMessage*>(
3140 &_StorageReturnMessage_OTAFlagStagingReturnMessage_default_instance_);
3141 }
3142 static constexpr int kIndexInFileMessages =
3143 15;
3144
swap(StorageReturnMessage_OTAFlagStagingReturnMessage & a,StorageReturnMessage_OTAFlagStagingReturnMessage & b)3145 friend void swap(StorageReturnMessage_OTAFlagStagingReturnMessage& a, StorageReturnMessage_OTAFlagStagingReturnMessage& b) {
3146 a.Swap(&b);
3147 }
Swap(StorageReturnMessage_OTAFlagStagingReturnMessage * other)3148 inline void Swap(StorageReturnMessage_OTAFlagStagingReturnMessage* other) {
3149 if (other == this) return;
3150 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
3151 if (GetOwningArena() != nullptr &&
3152 GetOwningArena() == other->GetOwningArena()) {
3153 #else // PROTOBUF_FORCE_COPY_IN_SWAP
3154 if (GetOwningArena() == other->GetOwningArena()) {
3155 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
3156 InternalSwap(other);
3157 } else {
3158 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
3159 }
3160 }
3161 void UnsafeArenaSwap(StorageReturnMessage_OTAFlagStagingReturnMessage* other) {
3162 if (other == this) return;
3163 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
3164 InternalSwap(other);
3165 }
3166
3167 // implements Message ----------------------------------------------
3168
3169 StorageReturnMessage_OTAFlagStagingReturnMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
3170 return CreateMaybeMessage<StorageReturnMessage_OTAFlagStagingReturnMessage>(arena);
3171 }
3172 StorageReturnMessage_OTAFlagStagingReturnMessage* New() const {
3173 return New(nullptr);
3174 }
3175 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
3176 void CopyFrom(const StorageReturnMessage_OTAFlagStagingReturnMessage& from);
3177 void MergeFrom(const StorageReturnMessage_OTAFlagStagingReturnMessage& from);
3178 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
3179 bool IsInitialized() const final;
3180
3181 size_t ByteSizeLong() const final;
3182 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
3183 ::uint8_t* _InternalSerialize(
3184 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
3185 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
3186
3187 private:
3188 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
3189 void SharedDtor();
3190 void SetCachedSize(int size) const;
3191 void InternalSwap(StorageReturnMessage_OTAFlagStagingReturnMessage* other);
3192
3193 private:
3194 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
3195 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
3196 return "android.aconfigd.StorageReturnMessage.OTAFlagStagingReturnMessage";
3197 }
3198 protected:
3199 explicit StorageReturnMessage_OTAFlagStagingReturnMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
3200 bool is_message_owned = false);
3201 public:
3202
3203 std::string GetTypeName() const final;
3204
3205 // nested types ----------------------------------------------------
3206
3207 // accessors -------------------------------------------------------
3208
3209 // @@protoc_insertion_point(class_scope:android.aconfigd.StorageReturnMessage.OTAFlagStagingReturnMessage)
3210 private:
3211 class _Internal;
3212
3213 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
3214 typedef void InternalArenaConstructable_;
3215 typedef void DestructorSkippable_;
3216 struct Impl_ {
3217 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
3218 };
3219 union { Impl_ _impl_; };
3220 friend struct ::TableStruct_packages_2fmodules_2fConfigInfrastructure_2faconfigd_2fproto_2faconfigd_2eproto;
3221 };
3222 // -------------------------------------------------------------------
3223
3224 class StorageReturnMessage_FlagQueryReturnMessage final :
3225 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:android.aconfigd.StorageReturnMessage.FlagQueryReturnMessage) */ {
3226 public:
StorageReturnMessage_FlagQueryReturnMessage()3227 inline StorageReturnMessage_FlagQueryReturnMessage() : StorageReturnMessage_FlagQueryReturnMessage(nullptr) {}
3228 ~StorageReturnMessage_FlagQueryReturnMessage() override;
3229 explicit PROTOBUF_CONSTEXPR StorageReturnMessage_FlagQueryReturnMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
3230
3231 StorageReturnMessage_FlagQueryReturnMessage(const StorageReturnMessage_FlagQueryReturnMessage& from);
StorageReturnMessage_FlagQueryReturnMessage(StorageReturnMessage_FlagQueryReturnMessage && from)3232 StorageReturnMessage_FlagQueryReturnMessage(StorageReturnMessage_FlagQueryReturnMessage&& from) noexcept
3233 : StorageReturnMessage_FlagQueryReturnMessage() {
3234 *this = ::std::move(from);
3235 }
3236
3237 inline StorageReturnMessage_FlagQueryReturnMessage& operator=(const StorageReturnMessage_FlagQueryReturnMessage& from) {
3238 if (this == &from) return *this;
3239 CopyFrom(from);
3240 return *this;
3241 }
3242 inline StorageReturnMessage_FlagQueryReturnMessage& operator=(StorageReturnMessage_FlagQueryReturnMessage&& from) noexcept {
3243 if (this == &from) return *this;
3244 if (GetOwningArena() == from.GetOwningArena()
3245 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
3246 && GetOwningArena() != nullptr
3247 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
3248 ) {
3249 InternalSwap(&from);
3250 } else {
3251 CopyFrom(from);
3252 }
3253 return *this;
3254 }
3255
unknown_fields()3256 inline const std::string& unknown_fields() const {
3257 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
3258 }
mutable_unknown_fields()3259 inline std::string* mutable_unknown_fields() {
3260 return _internal_metadata_.mutable_unknown_fields<std::string>();
3261 }
3262
default_instance()3263 static const StorageReturnMessage_FlagQueryReturnMessage& default_instance() {
3264 return *internal_default_instance();
3265 }
internal_default_instance()3266 static inline const StorageReturnMessage_FlagQueryReturnMessage* internal_default_instance() {
3267 return reinterpret_cast<const StorageReturnMessage_FlagQueryReturnMessage*>(
3268 &_StorageReturnMessage_FlagQueryReturnMessage_default_instance_);
3269 }
3270 static constexpr int kIndexInFileMessages =
3271 16;
3272
swap(StorageReturnMessage_FlagQueryReturnMessage & a,StorageReturnMessage_FlagQueryReturnMessage & b)3273 friend void swap(StorageReturnMessage_FlagQueryReturnMessage& a, StorageReturnMessage_FlagQueryReturnMessage& b) {
3274 a.Swap(&b);
3275 }
Swap(StorageReturnMessage_FlagQueryReturnMessage * other)3276 inline void Swap(StorageReturnMessage_FlagQueryReturnMessage* other) {
3277 if (other == this) return;
3278 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
3279 if (GetOwningArena() != nullptr &&
3280 GetOwningArena() == other->GetOwningArena()) {
3281 #else // PROTOBUF_FORCE_COPY_IN_SWAP
3282 if (GetOwningArena() == other->GetOwningArena()) {
3283 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
3284 InternalSwap(other);
3285 } else {
3286 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
3287 }
3288 }
3289 void UnsafeArenaSwap(StorageReturnMessage_FlagQueryReturnMessage* other) {
3290 if (other == this) return;
3291 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
3292 InternalSwap(other);
3293 }
3294
3295 // implements Message ----------------------------------------------
3296
3297 StorageReturnMessage_FlagQueryReturnMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
3298 return CreateMaybeMessage<StorageReturnMessage_FlagQueryReturnMessage>(arena);
3299 }
3300 StorageReturnMessage_FlagQueryReturnMessage* New() const {
3301 return New(nullptr);
3302 }
3303 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
3304 void CopyFrom(const StorageReturnMessage_FlagQueryReturnMessage& from);
3305 void MergeFrom(const StorageReturnMessage_FlagQueryReturnMessage& from);
3306 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
3307 bool IsInitialized() const final;
3308
3309 size_t ByteSizeLong() const final;
3310 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
3311 ::uint8_t* _InternalSerialize(
3312 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
3313 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
3314
3315 private:
3316 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
3317 void SharedDtor();
3318 void SetCachedSize(int size) const;
3319 void InternalSwap(StorageReturnMessage_FlagQueryReturnMessage* other);
3320
3321 private:
3322 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
3323 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
3324 return "android.aconfigd.StorageReturnMessage.FlagQueryReturnMessage";
3325 }
3326 protected:
3327 explicit StorageReturnMessage_FlagQueryReturnMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
3328 bool is_message_owned = false);
3329 public:
3330
3331 std::string GetTypeName() const final;
3332
3333 // nested types ----------------------------------------------------
3334
3335 // accessors -------------------------------------------------------
3336
3337 enum : int {
3338 kPackageNameFieldNumber = 1,
3339 kFlagNameFieldNumber = 2,
3340 kServerFlagValueFieldNumber = 3,
3341 kLocalFlagValueFieldNumber = 4,
3342 kBootFlagValueFieldNumber = 5,
3343 kDefaultFlagValueFieldNumber = 6,
3344 kContainerFieldNumber = 11,
3345 kHasServerOverrideFieldNumber = 7,
3346 kIsReadwriteFieldNumber = 8,
3347 kHasLocalOverrideFieldNumber = 9,
3348 kHasBootLocalOverrideFieldNumber = 10,
3349 };
3350 // optional string package_name = 1;
3351 bool has_package_name() const;
3352 private:
3353 bool _internal_has_package_name() const;
3354 public:
3355 void clear_package_name();
3356 const std::string& package_name() const;
3357 template <typename ArgT0 = const std::string&, typename... ArgT>
3358 void set_package_name(ArgT0&& arg0, ArgT... args);
3359 std::string* mutable_package_name();
3360 PROTOBUF_NODISCARD std::string* release_package_name();
3361 void set_allocated_package_name(std::string* package_name);
3362 private:
3363 const std::string& _internal_package_name() const;
3364 inline PROTOBUF_ALWAYS_INLINE void _internal_set_package_name(const std::string& value);
3365 std::string* _internal_mutable_package_name();
3366 public:
3367
3368 // optional string flag_name = 2;
3369 bool has_flag_name() const;
3370 private:
3371 bool _internal_has_flag_name() const;
3372 public:
3373 void clear_flag_name();
3374 const std::string& flag_name() const;
3375 template <typename ArgT0 = const std::string&, typename... ArgT>
3376 void set_flag_name(ArgT0&& arg0, ArgT... args);
3377 std::string* mutable_flag_name();
3378 PROTOBUF_NODISCARD std::string* release_flag_name();
3379 void set_allocated_flag_name(std::string* flag_name);
3380 private:
3381 const std::string& _internal_flag_name() const;
3382 inline PROTOBUF_ALWAYS_INLINE void _internal_set_flag_name(const std::string& value);
3383 std::string* _internal_mutable_flag_name();
3384 public:
3385
3386 // optional string server_flag_value = 3;
3387 bool has_server_flag_value() const;
3388 private:
3389 bool _internal_has_server_flag_value() const;
3390 public:
3391 void clear_server_flag_value();
3392 const std::string& server_flag_value() const;
3393 template <typename ArgT0 = const std::string&, typename... ArgT>
3394 void set_server_flag_value(ArgT0&& arg0, ArgT... args);
3395 std::string* mutable_server_flag_value();
3396 PROTOBUF_NODISCARD std::string* release_server_flag_value();
3397 void set_allocated_server_flag_value(std::string* server_flag_value);
3398 private:
3399 const std::string& _internal_server_flag_value() const;
3400 inline PROTOBUF_ALWAYS_INLINE void _internal_set_server_flag_value(const std::string& value);
3401 std::string* _internal_mutable_server_flag_value();
3402 public:
3403
3404 // optional string local_flag_value = 4;
3405 bool has_local_flag_value() const;
3406 private:
3407 bool _internal_has_local_flag_value() const;
3408 public:
3409 void clear_local_flag_value();
3410 const std::string& local_flag_value() const;
3411 template <typename ArgT0 = const std::string&, typename... ArgT>
3412 void set_local_flag_value(ArgT0&& arg0, ArgT... args);
3413 std::string* mutable_local_flag_value();
3414 PROTOBUF_NODISCARD std::string* release_local_flag_value();
3415 void set_allocated_local_flag_value(std::string* local_flag_value);
3416 private:
3417 const std::string& _internal_local_flag_value() const;
3418 inline PROTOBUF_ALWAYS_INLINE void _internal_set_local_flag_value(const std::string& value);
3419 std::string* _internal_mutable_local_flag_value();
3420 public:
3421
3422 // optional string boot_flag_value = 5;
3423 bool has_boot_flag_value() const;
3424 private:
3425 bool _internal_has_boot_flag_value() const;
3426 public:
3427 void clear_boot_flag_value();
3428 const std::string& boot_flag_value() const;
3429 template <typename ArgT0 = const std::string&, typename... ArgT>
3430 void set_boot_flag_value(ArgT0&& arg0, ArgT... args);
3431 std::string* mutable_boot_flag_value();
3432 PROTOBUF_NODISCARD std::string* release_boot_flag_value();
3433 void set_allocated_boot_flag_value(std::string* boot_flag_value);
3434 private:
3435 const std::string& _internal_boot_flag_value() const;
3436 inline PROTOBUF_ALWAYS_INLINE void _internal_set_boot_flag_value(const std::string& value);
3437 std::string* _internal_mutable_boot_flag_value();
3438 public:
3439
3440 // optional string default_flag_value = 6;
3441 bool has_default_flag_value() const;
3442 private:
3443 bool _internal_has_default_flag_value() const;
3444 public:
3445 void clear_default_flag_value();
3446 const std::string& default_flag_value() const;
3447 template <typename ArgT0 = const std::string&, typename... ArgT>
3448 void set_default_flag_value(ArgT0&& arg0, ArgT... args);
3449 std::string* mutable_default_flag_value();
3450 PROTOBUF_NODISCARD std::string* release_default_flag_value();
3451 void set_allocated_default_flag_value(std::string* default_flag_value);
3452 private:
3453 const std::string& _internal_default_flag_value() const;
3454 inline PROTOBUF_ALWAYS_INLINE void _internal_set_default_flag_value(const std::string& value);
3455 std::string* _internal_mutable_default_flag_value();
3456 public:
3457
3458 // optional string container = 11;
3459 bool has_container() const;
3460 private:
3461 bool _internal_has_container() const;
3462 public:
3463 void clear_container();
3464 const std::string& container() const;
3465 template <typename ArgT0 = const std::string&, typename... ArgT>
3466 void set_container(ArgT0&& arg0, ArgT... args);
3467 std::string* mutable_container();
3468 PROTOBUF_NODISCARD std::string* release_container();
3469 void set_allocated_container(std::string* container);
3470 private:
3471 const std::string& _internal_container() const;
3472 inline PROTOBUF_ALWAYS_INLINE void _internal_set_container(const std::string& value);
3473 std::string* _internal_mutable_container();
3474 public:
3475
3476 // optional bool has_server_override = 7;
3477 bool has_has_server_override() const;
3478 private:
3479 bool _internal_has_has_server_override() const;
3480 public:
3481 void clear_has_server_override();
3482 bool has_server_override() const;
3483 void set_has_server_override(bool value);
3484 private:
3485 bool _internal_has_server_override() const;
3486 void _internal_set_has_server_override(bool value);
3487 public:
3488
3489 // optional bool is_readwrite = 8;
3490 bool has_is_readwrite() const;
3491 private:
3492 bool _internal_has_is_readwrite() const;
3493 public:
3494 void clear_is_readwrite();
3495 bool is_readwrite() const;
3496 void set_is_readwrite(bool value);
3497 private:
3498 bool _internal_is_readwrite() const;
3499 void _internal_set_is_readwrite(bool value);
3500 public:
3501
3502 // optional bool has_local_override = 9;
3503 bool has_has_local_override() const;
3504 private:
3505 bool _internal_has_has_local_override() const;
3506 public:
3507 void clear_has_local_override();
3508 bool has_local_override() const;
3509 void set_has_local_override(bool value);
3510 private:
3511 bool _internal_has_local_override() const;
3512 void _internal_set_has_local_override(bool value);
3513 public:
3514
3515 // optional bool has_boot_local_override = 10;
3516 bool has_has_boot_local_override() const;
3517 private:
3518 bool _internal_has_has_boot_local_override() const;
3519 public:
3520 void clear_has_boot_local_override();
3521 bool has_boot_local_override() const;
3522 void set_has_boot_local_override(bool value);
3523 private:
3524 bool _internal_has_boot_local_override() const;
3525 void _internal_set_has_boot_local_override(bool value);
3526 public:
3527
3528 // @@protoc_insertion_point(class_scope:android.aconfigd.StorageReturnMessage.FlagQueryReturnMessage)
3529 private:
3530 class _Internal;
3531
3532 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
3533 typedef void InternalArenaConstructable_;
3534 typedef void DestructorSkippable_;
3535 struct Impl_ {
3536 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
3537 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
3538 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr package_name_;
3539 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr flag_name_;
3540 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr server_flag_value_;
3541 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr local_flag_value_;
3542 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr boot_flag_value_;
3543 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr default_flag_value_;
3544 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr container_;
3545 bool has_server_override_;
3546 bool is_readwrite_;
3547 bool has_local_override_;
3548 bool has_boot_local_override_;
3549 };
3550 union { Impl_ _impl_; };
3551 friend struct ::TableStruct_packages_2fmodules_2fConfigInfrastructure_2faconfigd_2fproto_2faconfigd_2eproto;
3552 };
3553 // -------------------------------------------------------------------
3554
3555 class StorageReturnMessage_RemoveLocalOverrideReturnMessage final :
3556 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:android.aconfigd.StorageReturnMessage.RemoveLocalOverrideReturnMessage) */ {
3557 public:
StorageReturnMessage_RemoveLocalOverrideReturnMessage()3558 inline StorageReturnMessage_RemoveLocalOverrideReturnMessage() : StorageReturnMessage_RemoveLocalOverrideReturnMessage(nullptr) {}
3559 ~StorageReturnMessage_RemoveLocalOverrideReturnMessage() override;
3560 explicit PROTOBUF_CONSTEXPR StorageReturnMessage_RemoveLocalOverrideReturnMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
3561
3562 StorageReturnMessage_RemoveLocalOverrideReturnMessage(const StorageReturnMessage_RemoveLocalOverrideReturnMessage& from);
StorageReturnMessage_RemoveLocalOverrideReturnMessage(StorageReturnMessage_RemoveLocalOverrideReturnMessage && from)3563 StorageReturnMessage_RemoveLocalOverrideReturnMessage(StorageReturnMessage_RemoveLocalOverrideReturnMessage&& from) noexcept
3564 : StorageReturnMessage_RemoveLocalOverrideReturnMessage() {
3565 *this = ::std::move(from);
3566 }
3567
3568 inline StorageReturnMessage_RemoveLocalOverrideReturnMessage& operator=(const StorageReturnMessage_RemoveLocalOverrideReturnMessage& from) {
3569 if (this == &from) return *this;
3570 CopyFrom(from);
3571 return *this;
3572 }
3573 inline StorageReturnMessage_RemoveLocalOverrideReturnMessage& operator=(StorageReturnMessage_RemoveLocalOverrideReturnMessage&& from) noexcept {
3574 if (this == &from) return *this;
3575 if (GetOwningArena() == from.GetOwningArena()
3576 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
3577 && GetOwningArena() != nullptr
3578 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
3579 ) {
3580 InternalSwap(&from);
3581 } else {
3582 CopyFrom(from);
3583 }
3584 return *this;
3585 }
3586
unknown_fields()3587 inline const std::string& unknown_fields() const {
3588 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
3589 }
mutable_unknown_fields()3590 inline std::string* mutable_unknown_fields() {
3591 return _internal_metadata_.mutable_unknown_fields<std::string>();
3592 }
3593
default_instance()3594 static const StorageReturnMessage_RemoveLocalOverrideReturnMessage& default_instance() {
3595 return *internal_default_instance();
3596 }
internal_default_instance()3597 static inline const StorageReturnMessage_RemoveLocalOverrideReturnMessage* internal_default_instance() {
3598 return reinterpret_cast<const StorageReturnMessage_RemoveLocalOverrideReturnMessage*>(
3599 &_StorageReturnMessage_RemoveLocalOverrideReturnMessage_default_instance_);
3600 }
3601 static constexpr int kIndexInFileMessages =
3602 17;
3603
swap(StorageReturnMessage_RemoveLocalOverrideReturnMessage & a,StorageReturnMessage_RemoveLocalOverrideReturnMessage & b)3604 friend void swap(StorageReturnMessage_RemoveLocalOverrideReturnMessage& a, StorageReturnMessage_RemoveLocalOverrideReturnMessage& b) {
3605 a.Swap(&b);
3606 }
Swap(StorageReturnMessage_RemoveLocalOverrideReturnMessage * other)3607 inline void Swap(StorageReturnMessage_RemoveLocalOverrideReturnMessage* other) {
3608 if (other == this) return;
3609 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
3610 if (GetOwningArena() != nullptr &&
3611 GetOwningArena() == other->GetOwningArena()) {
3612 #else // PROTOBUF_FORCE_COPY_IN_SWAP
3613 if (GetOwningArena() == other->GetOwningArena()) {
3614 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
3615 InternalSwap(other);
3616 } else {
3617 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
3618 }
3619 }
3620 void UnsafeArenaSwap(StorageReturnMessage_RemoveLocalOverrideReturnMessage* other) {
3621 if (other == this) return;
3622 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
3623 InternalSwap(other);
3624 }
3625
3626 // implements Message ----------------------------------------------
3627
3628 StorageReturnMessage_RemoveLocalOverrideReturnMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
3629 return CreateMaybeMessage<StorageReturnMessage_RemoveLocalOverrideReturnMessage>(arena);
3630 }
3631 StorageReturnMessage_RemoveLocalOverrideReturnMessage* New() const {
3632 return New(nullptr);
3633 }
3634 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
3635 void CopyFrom(const StorageReturnMessage_RemoveLocalOverrideReturnMessage& from);
3636 void MergeFrom(const StorageReturnMessage_RemoveLocalOverrideReturnMessage& from);
3637 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
3638 bool IsInitialized() const final;
3639
3640 size_t ByteSizeLong() const final;
3641 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
3642 ::uint8_t* _InternalSerialize(
3643 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
3644 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
3645
3646 private:
3647 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
3648 void SharedDtor();
3649 void SetCachedSize(int size) const;
3650 void InternalSwap(StorageReturnMessage_RemoveLocalOverrideReturnMessage* other);
3651
3652 private:
3653 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
3654 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
3655 return "android.aconfigd.StorageReturnMessage.RemoveLocalOverrideReturnMessage";
3656 }
3657 protected:
3658 explicit StorageReturnMessage_RemoveLocalOverrideReturnMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
3659 bool is_message_owned = false);
3660 public:
3661
3662 std::string GetTypeName() const final;
3663
3664 // nested types ----------------------------------------------------
3665
3666 // accessors -------------------------------------------------------
3667
3668 // @@protoc_insertion_point(class_scope:android.aconfigd.StorageReturnMessage.RemoveLocalOverrideReturnMessage)
3669 private:
3670 class _Internal;
3671
3672 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
3673 typedef void InternalArenaConstructable_;
3674 typedef void DestructorSkippable_;
3675 struct Impl_ {
3676 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
3677 };
3678 union { Impl_ _impl_; };
3679 friend struct ::TableStruct_packages_2fmodules_2fConfigInfrastructure_2faconfigd_2fproto_2faconfigd_2eproto;
3680 };
3681 // -------------------------------------------------------------------
3682
3683 class StorageReturnMessage_ResetStorageReturnMessage final :
3684 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:android.aconfigd.StorageReturnMessage.ResetStorageReturnMessage) */ {
3685 public:
StorageReturnMessage_ResetStorageReturnMessage()3686 inline StorageReturnMessage_ResetStorageReturnMessage() : StorageReturnMessage_ResetStorageReturnMessage(nullptr) {}
3687 ~StorageReturnMessage_ResetStorageReturnMessage() override;
3688 explicit PROTOBUF_CONSTEXPR StorageReturnMessage_ResetStorageReturnMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
3689
3690 StorageReturnMessage_ResetStorageReturnMessage(const StorageReturnMessage_ResetStorageReturnMessage& from);
StorageReturnMessage_ResetStorageReturnMessage(StorageReturnMessage_ResetStorageReturnMessage && from)3691 StorageReturnMessage_ResetStorageReturnMessage(StorageReturnMessage_ResetStorageReturnMessage&& from) noexcept
3692 : StorageReturnMessage_ResetStorageReturnMessage() {
3693 *this = ::std::move(from);
3694 }
3695
3696 inline StorageReturnMessage_ResetStorageReturnMessage& operator=(const StorageReturnMessage_ResetStorageReturnMessage& from) {
3697 if (this == &from) return *this;
3698 CopyFrom(from);
3699 return *this;
3700 }
3701 inline StorageReturnMessage_ResetStorageReturnMessage& operator=(StorageReturnMessage_ResetStorageReturnMessage&& from) noexcept {
3702 if (this == &from) return *this;
3703 if (GetOwningArena() == from.GetOwningArena()
3704 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
3705 && GetOwningArena() != nullptr
3706 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
3707 ) {
3708 InternalSwap(&from);
3709 } else {
3710 CopyFrom(from);
3711 }
3712 return *this;
3713 }
3714
unknown_fields()3715 inline const std::string& unknown_fields() const {
3716 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
3717 }
mutable_unknown_fields()3718 inline std::string* mutable_unknown_fields() {
3719 return _internal_metadata_.mutable_unknown_fields<std::string>();
3720 }
3721
default_instance()3722 static const StorageReturnMessage_ResetStorageReturnMessage& default_instance() {
3723 return *internal_default_instance();
3724 }
internal_default_instance()3725 static inline const StorageReturnMessage_ResetStorageReturnMessage* internal_default_instance() {
3726 return reinterpret_cast<const StorageReturnMessage_ResetStorageReturnMessage*>(
3727 &_StorageReturnMessage_ResetStorageReturnMessage_default_instance_);
3728 }
3729 static constexpr int kIndexInFileMessages =
3730 18;
3731
swap(StorageReturnMessage_ResetStorageReturnMessage & a,StorageReturnMessage_ResetStorageReturnMessage & b)3732 friend void swap(StorageReturnMessage_ResetStorageReturnMessage& a, StorageReturnMessage_ResetStorageReturnMessage& b) {
3733 a.Swap(&b);
3734 }
Swap(StorageReturnMessage_ResetStorageReturnMessage * other)3735 inline void Swap(StorageReturnMessage_ResetStorageReturnMessage* other) {
3736 if (other == this) return;
3737 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
3738 if (GetOwningArena() != nullptr &&
3739 GetOwningArena() == other->GetOwningArena()) {
3740 #else // PROTOBUF_FORCE_COPY_IN_SWAP
3741 if (GetOwningArena() == other->GetOwningArena()) {
3742 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
3743 InternalSwap(other);
3744 } else {
3745 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
3746 }
3747 }
3748 void UnsafeArenaSwap(StorageReturnMessage_ResetStorageReturnMessage* other) {
3749 if (other == this) return;
3750 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
3751 InternalSwap(other);
3752 }
3753
3754 // implements Message ----------------------------------------------
3755
3756 StorageReturnMessage_ResetStorageReturnMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
3757 return CreateMaybeMessage<StorageReturnMessage_ResetStorageReturnMessage>(arena);
3758 }
3759 StorageReturnMessage_ResetStorageReturnMessage* New() const {
3760 return New(nullptr);
3761 }
3762 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
3763 void CopyFrom(const StorageReturnMessage_ResetStorageReturnMessage& from);
3764 void MergeFrom(const StorageReturnMessage_ResetStorageReturnMessage& from);
3765 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
3766 bool IsInitialized() const final;
3767
3768 size_t ByteSizeLong() const final;
3769 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
3770 ::uint8_t* _InternalSerialize(
3771 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
3772 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
3773
3774 private:
3775 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
3776 void SharedDtor();
3777 void SetCachedSize(int size) const;
3778 void InternalSwap(StorageReturnMessage_ResetStorageReturnMessage* other);
3779
3780 private:
3781 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
3782 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
3783 return "android.aconfigd.StorageReturnMessage.ResetStorageReturnMessage";
3784 }
3785 protected:
3786 explicit StorageReturnMessage_ResetStorageReturnMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
3787 bool is_message_owned = false);
3788 public:
3789
3790 std::string GetTypeName() const final;
3791
3792 // nested types ----------------------------------------------------
3793
3794 // accessors -------------------------------------------------------
3795
3796 // @@protoc_insertion_point(class_scope:android.aconfigd.StorageReturnMessage.ResetStorageReturnMessage)
3797 private:
3798 class _Internal;
3799
3800 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
3801 typedef void InternalArenaConstructable_;
3802 typedef void DestructorSkippable_;
3803 struct Impl_ {
3804 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
3805 };
3806 union { Impl_ _impl_; };
3807 friend struct ::TableStruct_packages_2fmodules_2fConfigInfrastructure_2faconfigd_2fproto_2faconfigd_2eproto;
3808 };
3809 // -------------------------------------------------------------------
3810
3811 class StorageReturnMessage_ListStorageReturnMessage final :
3812 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:android.aconfigd.StorageReturnMessage.ListStorageReturnMessage) */ {
3813 public:
StorageReturnMessage_ListStorageReturnMessage()3814 inline StorageReturnMessage_ListStorageReturnMessage() : StorageReturnMessage_ListStorageReturnMessage(nullptr) {}
3815 ~StorageReturnMessage_ListStorageReturnMessage() override;
3816 explicit PROTOBUF_CONSTEXPR StorageReturnMessage_ListStorageReturnMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
3817
3818 StorageReturnMessage_ListStorageReturnMessage(const StorageReturnMessage_ListStorageReturnMessage& from);
StorageReturnMessage_ListStorageReturnMessage(StorageReturnMessage_ListStorageReturnMessage && from)3819 StorageReturnMessage_ListStorageReturnMessage(StorageReturnMessage_ListStorageReturnMessage&& from) noexcept
3820 : StorageReturnMessage_ListStorageReturnMessage() {
3821 *this = ::std::move(from);
3822 }
3823
3824 inline StorageReturnMessage_ListStorageReturnMessage& operator=(const StorageReturnMessage_ListStorageReturnMessage& from) {
3825 if (this == &from) return *this;
3826 CopyFrom(from);
3827 return *this;
3828 }
3829 inline StorageReturnMessage_ListStorageReturnMessage& operator=(StorageReturnMessage_ListStorageReturnMessage&& from) noexcept {
3830 if (this == &from) return *this;
3831 if (GetOwningArena() == from.GetOwningArena()
3832 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
3833 && GetOwningArena() != nullptr
3834 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
3835 ) {
3836 InternalSwap(&from);
3837 } else {
3838 CopyFrom(from);
3839 }
3840 return *this;
3841 }
3842
unknown_fields()3843 inline const std::string& unknown_fields() const {
3844 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
3845 }
mutable_unknown_fields()3846 inline std::string* mutable_unknown_fields() {
3847 return _internal_metadata_.mutable_unknown_fields<std::string>();
3848 }
3849
default_instance()3850 static const StorageReturnMessage_ListStorageReturnMessage& default_instance() {
3851 return *internal_default_instance();
3852 }
internal_default_instance()3853 static inline const StorageReturnMessage_ListStorageReturnMessage* internal_default_instance() {
3854 return reinterpret_cast<const StorageReturnMessage_ListStorageReturnMessage*>(
3855 &_StorageReturnMessage_ListStorageReturnMessage_default_instance_);
3856 }
3857 static constexpr int kIndexInFileMessages =
3858 19;
3859
swap(StorageReturnMessage_ListStorageReturnMessage & a,StorageReturnMessage_ListStorageReturnMessage & b)3860 friend void swap(StorageReturnMessage_ListStorageReturnMessage& a, StorageReturnMessage_ListStorageReturnMessage& b) {
3861 a.Swap(&b);
3862 }
Swap(StorageReturnMessage_ListStorageReturnMessage * other)3863 inline void Swap(StorageReturnMessage_ListStorageReturnMessage* other) {
3864 if (other == this) return;
3865 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
3866 if (GetOwningArena() != nullptr &&
3867 GetOwningArena() == other->GetOwningArena()) {
3868 #else // PROTOBUF_FORCE_COPY_IN_SWAP
3869 if (GetOwningArena() == other->GetOwningArena()) {
3870 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
3871 InternalSwap(other);
3872 } else {
3873 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
3874 }
3875 }
3876 void UnsafeArenaSwap(StorageReturnMessage_ListStorageReturnMessage* other) {
3877 if (other == this) return;
3878 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
3879 InternalSwap(other);
3880 }
3881
3882 // implements Message ----------------------------------------------
3883
3884 StorageReturnMessage_ListStorageReturnMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
3885 return CreateMaybeMessage<StorageReturnMessage_ListStorageReturnMessage>(arena);
3886 }
3887 StorageReturnMessage_ListStorageReturnMessage* New() const {
3888 return New(nullptr);
3889 }
3890 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
3891 void CopyFrom(const StorageReturnMessage_ListStorageReturnMessage& from);
3892 void MergeFrom(const StorageReturnMessage_ListStorageReturnMessage& from);
3893 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
3894 bool IsInitialized() const final;
3895
3896 size_t ByteSizeLong() const final;
3897 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
3898 ::uint8_t* _InternalSerialize(
3899 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
3900 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
3901
3902 private:
3903 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
3904 void SharedDtor();
3905 void SetCachedSize(int size) const;
3906 void InternalSwap(StorageReturnMessage_ListStorageReturnMessage* other);
3907
3908 private:
3909 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
3910 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
3911 return "android.aconfigd.StorageReturnMessage.ListStorageReturnMessage";
3912 }
3913 protected:
3914 explicit StorageReturnMessage_ListStorageReturnMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
3915 bool is_message_owned = false);
3916 public:
3917
3918 std::string GetTypeName() const final;
3919
3920 // nested types ----------------------------------------------------
3921
3922 // accessors -------------------------------------------------------
3923
3924 enum : int {
3925 kFlagsFieldNumber = 1,
3926 };
3927 // repeated .android.aconfigd.StorageReturnMessage.FlagQueryReturnMessage flags = 1;
3928 int flags_size() const;
3929 private:
3930 int _internal_flags_size() const;
3931 public:
3932 void clear_flags();
3933 ::android::aconfigd::StorageReturnMessage_FlagQueryReturnMessage* mutable_flags(int index);
3934 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::android::aconfigd::StorageReturnMessage_FlagQueryReturnMessage >*
3935 mutable_flags();
3936 private:
3937 const ::android::aconfigd::StorageReturnMessage_FlagQueryReturnMessage& _internal_flags(int index) const;
3938 ::android::aconfigd::StorageReturnMessage_FlagQueryReturnMessage* _internal_add_flags();
3939 public:
3940 const ::android::aconfigd::StorageReturnMessage_FlagQueryReturnMessage& flags(int index) const;
3941 ::android::aconfigd::StorageReturnMessage_FlagQueryReturnMessage* add_flags();
3942 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::android::aconfigd::StorageReturnMessage_FlagQueryReturnMessage >&
3943 flags() const;
3944
3945 // @@protoc_insertion_point(class_scope:android.aconfigd.StorageReturnMessage.ListStorageReturnMessage)
3946 private:
3947 class _Internal;
3948
3949 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
3950 typedef void InternalArenaConstructable_;
3951 typedef void DestructorSkippable_;
3952 struct Impl_ {
3953 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::android::aconfigd::StorageReturnMessage_FlagQueryReturnMessage > flags_;
3954 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
3955 };
3956 union { Impl_ _impl_; };
3957 friend struct ::TableStruct_packages_2fmodules_2fConfigInfrastructure_2faconfigd_2fproto_2faconfigd_2eproto;
3958 };
3959 // -------------------------------------------------------------------
3960
3961 class StorageReturnMessage final :
3962 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:android.aconfigd.StorageReturnMessage) */ {
3963 public:
StorageReturnMessage()3964 inline StorageReturnMessage() : StorageReturnMessage(nullptr) {}
3965 ~StorageReturnMessage() override;
3966 explicit PROTOBUF_CONSTEXPR StorageReturnMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
3967
3968 StorageReturnMessage(const StorageReturnMessage& from);
StorageReturnMessage(StorageReturnMessage && from)3969 StorageReturnMessage(StorageReturnMessage&& from) noexcept
3970 : StorageReturnMessage() {
3971 *this = ::std::move(from);
3972 }
3973
3974 inline StorageReturnMessage& operator=(const StorageReturnMessage& from) {
3975 if (this == &from) return *this;
3976 CopyFrom(from);
3977 return *this;
3978 }
3979 inline StorageReturnMessage& operator=(StorageReturnMessage&& from) noexcept {
3980 if (this == &from) return *this;
3981 if (GetOwningArena() == from.GetOwningArena()
3982 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
3983 && GetOwningArena() != nullptr
3984 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
3985 ) {
3986 InternalSwap(&from);
3987 } else {
3988 CopyFrom(from);
3989 }
3990 return *this;
3991 }
3992
unknown_fields()3993 inline const std::string& unknown_fields() const {
3994 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
3995 }
mutable_unknown_fields()3996 inline std::string* mutable_unknown_fields() {
3997 return _internal_metadata_.mutable_unknown_fields<std::string>();
3998 }
3999
default_instance()4000 static const StorageReturnMessage& default_instance() {
4001 return *internal_default_instance();
4002 }
4003 enum MsgCase {
4004 kNewStorageMessage = 1,
4005 kFlagOverrideMessage = 2,
4006 kOtaStagingMessage = 3,
4007 kFlagQueryMessage = 4,
4008 kRemoveLocalOverrideMessage = 5,
4009 kResetStorageMessage = 6,
4010 kListStorageMessage = 7,
4011 kErrorMessage = 8,
4012 MSG_NOT_SET = 0,
4013 };
4014
internal_default_instance()4015 static inline const StorageReturnMessage* internal_default_instance() {
4016 return reinterpret_cast<const StorageReturnMessage*>(
4017 &_StorageReturnMessage_default_instance_);
4018 }
4019 static constexpr int kIndexInFileMessages =
4020 20;
4021
swap(StorageReturnMessage & a,StorageReturnMessage & b)4022 friend void swap(StorageReturnMessage& a, StorageReturnMessage& b) {
4023 a.Swap(&b);
4024 }
Swap(StorageReturnMessage * other)4025 inline void Swap(StorageReturnMessage* other) {
4026 if (other == this) return;
4027 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
4028 if (GetOwningArena() != nullptr &&
4029 GetOwningArena() == other->GetOwningArena()) {
4030 #else // PROTOBUF_FORCE_COPY_IN_SWAP
4031 if (GetOwningArena() == other->GetOwningArena()) {
4032 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
4033 InternalSwap(other);
4034 } else {
4035 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
4036 }
4037 }
4038 void UnsafeArenaSwap(StorageReturnMessage* other) {
4039 if (other == this) return;
4040 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
4041 InternalSwap(other);
4042 }
4043
4044 // implements Message ----------------------------------------------
4045
4046 StorageReturnMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
4047 return CreateMaybeMessage<StorageReturnMessage>(arena);
4048 }
4049 StorageReturnMessage* New() const {
4050 return New(nullptr);
4051 }
4052 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
4053 void CopyFrom(const StorageReturnMessage& from);
4054 void MergeFrom(const StorageReturnMessage& from);
4055 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
4056 bool IsInitialized() const final;
4057
4058 size_t ByteSizeLong() const final;
4059 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
4060 ::uint8_t* _InternalSerialize(
4061 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
4062 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
4063
4064 private:
4065 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
4066 void SharedDtor();
4067 void SetCachedSize(int size) const;
4068 void InternalSwap(StorageReturnMessage* other);
4069
4070 private:
4071 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
4072 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
4073 return "android.aconfigd.StorageReturnMessage";
4074 }
4075 protected:
4076 explicit StorageReturnMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
4077 bool is_message_owned = false);
4078 public:
4079
4080 std::string GetTypeName() const final;
4081
4082 // nested types ----------------------------------------------------
4083
4084 typedef StorageReturnMessage_NewStorageReturnMessage NewStorageReturnMessage;
4085 typedef StorageReturnMessage_FlagOverrideReturnMessage FlagOverrideReturnMessage;
4086 typedef StorageReturnMessage_OTAFlagStagingReturnMessage OTAFlagStagingReturnMessage;
4087 typedef StorageReturnMessage_FlagQueryReturnMessage FlagQueryReturnMessage;
4088 typedef StorageReturnMessage_RemoveLocalOverrideReturnMessage RemoveLocalOverrideReturnMessage;
4089 typedef StorageReturnMessage_ResetStorageReturnMessage ResetStorageReturnMessage;
4090 typedef StorageReturnMessage_ListStorageReturnMessage ListStorageReturnMessage;
4091
4092 // accessors -------------------------------------------------------
4093
4094 enum : int {
4095 kNewStorageMessageFieldNumber = 1,
4096 kFlagOverrideMessageFieldNumber = 2,
4097 kOtaStagingMessageFieldNumber = 3,
4098 kFlagQueryMessageFieldNumber = 4,
4099 kRemoveLocalOverrideMessageFieldNumber = 5,
4100 kResetStorageMessageFieldNumber = 6,
4101 kListStorageMessageFieldNumber = 7,
4102 kErrorMessageFieldNumber = 8,
4103 };
4104 // .android.aconfigd.StorageReturnMessage.NewStorageReturnMessage new_storage_message = 1;
4105 bool has_new_storage_message() const;
4106 private:
4107 bool _internal_has_new_storage_message() const;
4108 public:
4109 void clear_new_storage_message();
4110 const ::android::aconfigd::StorageReturnMessage_NewStorageReturnMessage& new_storage_message() const;
4111 PROTOBUF_NODISCARD ::android::aconfigd::StorageReturnMessage_NewStorageReturnMessage* release_new_storage_message();
4112 ::android::aconfigd::StorageReturnMessage_NewStorageReturnMessage* mutable_new_storage_message();
4113 void set_allocated_new_storage_message(::android::aconfigd::StorageReturnMessage_NewStorageReturnMessage* new_storage_message);
4114 private:
4115 const ::android::aconfigd::StorageReturnMessage_NewStorageReturnMessage& _internal_new_storage_message() const;
4116 ::android::aconfigd::StorageReturnMessage_NewStorageReturnMessage* _internal_mutable_new_storage_message();
4117 public:
4118 void unsafe_arena_set_allocated_new_storage_message(
4119 ::android::aconfigd::StorageReturnMessage_NewStorageReturnMessage* new_storage_message);
4120 ::android::aconfigd::StorageReturnMessage_NewStorageReturnMessage* unsafe_arena_release_new_storage_message();
4121
4122 // .android.aconfigd.StorageReturnMessage.FlagOverrideReturnMessage flag_override_message = 2;
4123 bool has_flag_override_message() const;
4124 private:
4125 bool _internal_has_flag_override_message() const;
4126 public:
4127 void clear_flag_override_message();
4128 const ::android::aconfigd::StorageReturnMessage_FlagOverrideReturnMessage& flag_override_message() const;
4129 PROTOBUF_NODISCARD ::android::aconfigd::StorageReturnMessage_FlagOverrideReturnMessage* release_flag_override_message();
4130 ::android::aconfigd::StorageReturnMessage_FlagOverrideReturnMessage* mutable_flag_override_message();
4131 void set_allocated_flag_override_message(::android::aconfigd::StorageReturnMessage_FlagOverrideReturnMessage* flag_override_message);
4132 private:
4133 const ::android::aconfigd::StorageReturnMessage_FlagOverrideReturnMessage& _internal_flag_override_message() const;
4134 ::android::aconfigd::StorageReturnMessage_FlagOverrideReturnMessage* _internal_mutable_flag_override_message();
4135 public:
4136 void unsafe_arena_set_allocated_flag_override_message(
4137 ::android::aconfigd::StorageReturnMessage_FlagOverrideReturnMessage* flag_override_message);
4138 ::android::aconfigd::StorageReturnMessage_FlagOverrideReturnMessage* unsafe_arena_release_flag_override_message();
4139
4140 // .android.aconfigd.StorageReturnMessage.OTAFlagStagingReturnMessage ota_staging_message = 3;
4141 bool has_ota_staging_message() const;
4142 private:
4143 bool _internal_has_ota_staging_message() const;
4144 public:
4145 void clear_ota_staging_message();
4146 const ::android::aconfigd::StorageReturnMessage_OTAFlagStagingReturnMessage& ota_staging_message() const;
4147 PROTOBUF_NODISCARD ::android::aconfigd::StorageReturnMessage_OTAFlagStagingReturnMessage* release_ota_staging_message();
4148 ::android::aconfigd::StorageReturnMessage_OTAFlagStagingReturnMessage* mutable_ota_staging_message();
4149 void set_allocated_ota_staging_message(::android::aconfigd::StorageReturnMessage_OTAFlagStagingReturnMessage* ota_staging_message);
4150 private:
4151 const ::android::aconfigd::StorageReturnMessage_OTAFlagStagingReturnMessage& _internal_ota_staging_message() const;
4152 ::android::aconfigd::StorageReturnMessage_OTAFlagStagingReturnMessage* _internal_mutable_ota_staging_message();
4153 public:
4154 void unsafe_arena_set_allocated_ota_staging_message(
4155 ::android::aconfigd::StorageReturnMessage_OTAFlagStagingReturnMessage* ota_staging_message);
4156 ::android::aconfigd::StorageReturnMessage_OTAFlagStagingReturnMessage* unsafe_arena_release_ota_staging_message();
4157
4158 // .android.aconfigd.StorageReturnMessage.FlagQueryReturnMessage flag_query_message = 4;
4159 bool has_flag_query_message() const;
4160 private:
4161 bool _internal_has_flag_query_message() const;
4162 public:
4163 void clear_flag_query_message();
4164 const ::android::aconfigd::StorageReturnMessage_FlagQueryReturnMessage& flag_query_message() const;
4165 PROTOBUF_NODISCARD ::android::aconfigd::StorageReturnMessage_FlagQueryReturnMessage* release_flag_query_message();
4166 ::android::aconfigd::StorageReturnMessage_FlagQueryReturnMessage* mutable_flag_query_message();
4167 void set_allocated_flag_query_message(::android::aconfigd::StorageReturnMessage_FlagQueryReturnMessage* flag_query_message);
4168 private:
4169 const ::android::aconfigd::StorageReturnMessage_FlagQueryReturnMessage& _internal_flag_query_message() const;
4170 ::android::aconfigd::StorageReturnMessage_FlagQueryReturnMessage* _internal_mutable_flag_query_message();
4171 public:
4172 void unsafe_arena_set_allocated_flag_query_message(
4173 ::android::aconfigd::StorageReturnMessage_FlagQueryReturnMessage* flag_query_message);
4174 ::android::aconfigd::StorageReturnMessage_FlagQueryReturnMessage* unsafe_arena_release_flag_query_message();
4175
4176 // .android.aconfigd.StorageReturnMessage.RemoveLocalOverrideReturnMessage remove_local_override_message = 5;
4177 bool has_remove_local_override_message() const;
4178 private:
4179 bool _internal_has_remove_local_override_message() const;
4180 public:
4181 void clear_remove_local_override_message();
4182 const ::android::aconfigd::StorageReturnMessage_RemoveLocalOverrideReturnMessage& remove_local_override_message() const;
4183 PROTOBUF_NODISCARD ::android::aconfigd::StorageReturnMessage_RemoveLocalOverrideReturnMessage* release_remove_local_override_message();
4184 ::android::aconfigd::StorageReturnMessage_RemoveLocalOverrideReturnMessage* mutable_remove_local_override_message();
4185 void set_allocated_remove_local_override_message(::android::aconfigd::StorageReturnMessage_RemoveLocalOverrideReturnMessage* remove_local_override_message);
4186 private:
4187 const ::android::aconfigd::StorageReturnMessage_RemoveLocalOverrideReturnMessage& _internal_remove_local_override_message() const;
4188 ::android::aconfigd::StorageReturnMessage_RemoveLocalOverrideReturnMessage* _internal_mutable_remove_local_override_message();
4189 public:
4190 void unsafe_arena_set_allocated_remove_local_override_message(
4191 ::android::aconfigd::StorageReturnMessage_RemoveLocalOverrideReturnMessage* remove_local_override_message);
4192 ::android::aconfigd::StorageReturnMessage_RemoveLocalOverrideReturnMessage* unsafe_arena_release_remove_local_override_message();
4193
4194 // .android.aconfigd.StorageReturnMessage.ResetStorageReturnMessage reset_storage_message = 6;
4195 bool has_reset_storage_message() const;
4196 private:
4197 bool _internal_has_reset_storage_message() const;
4198 public:
4199 void clear_reset_storage_message();
4200 const ::android::aconfigd::StorageReturnMessage_ResetStorageReturnMessage& reset_storage_message() const;
4201 PROTOBUF_NODISCARD ::android::aconfigd::StorageReturnMessage_ResetStorageReturnMessage* release_reset_storage_message();
4202 ::android::aconfigd::StorageReturnMessage_ResetStorageReturnMessage* mutable_reset_storage_message();
4203 void set_allocated_reset_storage_message(::android::aconfigd::StorageReturnMessage_ResetStorageReturnMessage* reset_storage_message);
4204 private:
4205 const ::android::aconfigd::StorageReturnMessage_ResetStorageReturnMessage& _internal_reset_storage_message() const;
4206 ::android::aconfigd::StorageReturnMessage_ResetStorageReturnMessage* _internal_mutable_reset_storage_message();
4207 public:
4208 void unsafe_arena_set_allocated_reset_storage_message(
4209 ::android::aconfigd::StorageReturnMessage_ResetStorageReturnMessage* reset_storage_message);
4210 ::android::aconfigd::StorageReturnMessage_ResetStorageReturnMessage* unsafe_arena_release_reset_storage_message();
4211
4212 // .android.aconfigd.StorageReturnMessage.ListStorageReturnMessage list_storage_message = 7;
4213 bool has_list_storage_message() const;
4214 private:
4215 bool _internal_has_list_storage_message() const;
4216 public:
4217 void clear_list_storage_message();
4218 const ::android::aconfigd::StorageReturnMessage_ListStorageReturnMessage& list_storage_message() const;
4219 PROTOBUF_NODISCARD ::android::aconfigd::StorageReturnMessage_ListStorageReturnMessage* release_list_storage_message();
4220 ::android::aconfigd::StorageReturnMessage_ListStorageReturnMessage* mutable_list_storage_message();
4221 void set_allocated_list_storage_message(::android::aconfigd::StorageReturnMessage_ListStorageReturnMessage* list_storage_message);
4222 private:
4223 const ::android::aconfigd::StorageReturnMessage_ListStorageReturnMessage& _internal_list_storage_message() const;
4224 ::android::aconfigd::StorageReturnMessage_ListStorageReturnMessage* _internal_mutable_list_storage_message();
4225 public:
4226 void unsafe_arena_set_allocated_list_storage_message(
4227 ::android::aconfigd::StorageReturnMessage_ListStorageReturnMessage* list_storage_message);
4228 ::android::aconfigd::StorageReturnMessage_ListStorageReturnMessage* unsafe_arena_release_list_storage_message();
4229
4230 // string error_message = 8;
4231 bool has_error_message() const;
4232 private:
4233 bool _internal_has_error_message() const;
4234 public:
4235 void clear_error_message();
4236 const std::string& error_message() const;
4237 template <typename ArgT0 = const std::string&, typename... ArgT>
4238 void set_error_message(ArgT0&& arg0, ArgT... args);
4239 std::string* mutable_error_message();
4240 PROTOBUF_NODISCARD std::string* release_error_message();
4241 void set_allocated_error_message(std::string* error_message);
4242 private:
4243 const std::string& _internal_error_message() const;
4244 inline PROTOBUF_ALWAYS_INLINE void _internal_set_error_message(const std::string& value);
4245 std::string* _internal_mutable_error_message();
4246 public:
4247
4248 void clear_msg();
4249 MsgCase msg_case() const;
4250 // @@protoc_insertion_point(class_scope:android.aconfigd.StorageReturnMessage)
4251 private:
4252 class _Internal;
4253 void set_has_new_storage_message();
4254 void set_has_flag_override_message();
4255 void set_has_ota_staging_message();
4256 void set_has_flag_query_message();
4257 void set_has_remove_local_override_message();
4258 void set_has_reset_storage_message();
4259 void set_has_list_storage_message();
4260 void set_has_error_message();
4261
4262 inline bool has_msg() const;
4263 inline void clear_has_msg();
4264
4265 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
4266 typedef void InternalArenaConstructable_;
4267 typedef void DestructorSkippable_;
4268 struct Impl_ {
4269 union MsgUnion {
4270 constexpr MsgUnion() : _constinit_{} {}
4271 ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
4272 ::android::aconfigd::StorageReturnMessage_NewStorageReturnMessage* new_storage_message_;
4273 ::android::aconfigd::StorageReturnMessage_FlagOverrideReturnMessage* flag_override_message_;
4274 ::android::aconfigd::StorageReturnMessage_OTAFlagStagingReturnMessage* ota_staging_message_;
4275 ::android::aconfigd::StorageReturnMessage_FlagQueryReturnMessage* flag_query_message_;
4276 ::android::aconfigd::StorageReturnMessage_RemoveLocalOverrideReturnMessage* remove_local_override_message_;
4277 ::android::aconfigd::StorageReturnMessage_ResetStorageReturnMessage* reset_storage_message_;
4278 ::android::aconfigd::StorageReturnMessage_ListStorageReturnMessage* list_storage_message_;
4279 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr error_message_;
4280 } msg_;
4281 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
4282 ::uint32_t _oneof_case_[1];
4283
4284 };
4285 union { Impl_ _impl_; };
4286 friend struct ::TableStruct_packages_2fmodules_2fConfigInfrastructure_2faconfigd_2fproto_2faconfigd_2eproto;
4287 };
4288 // -------------------------------------------------------------------
4289
4290 class StorageReturnMessages final :
4291 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:android.aconfigd.StorageReturnMessages) */ {
4292 public:
StorageReturnMessages()4293 inline StorageReturnMessages() : StorageReturnMessages(nullptr) {}
4294 ~StorageReturnMessages() override;
4295 explicit PROTOBUF_CONSTEXPR StorageReturnMessages(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
4296
4297 StorageReturnMessages(const StorageReturnMessages& from);
StorageReturnMessages(StorageReturnMessages && from)4298 StorageReturnMessages(StorageReturnMessages&& from) noexcept
4299 : StorageReturnMessages() {
4300 *this = ::std::move(from);
4301 }
4302
4303 inline StorageReturnMessages& operator=(const StorageReturnMessages& from) {
4304 if (this == &from) return *this;
4305 CopyFrom(from);
4306 return *this;
4307 }
4308 inline StorageReturnMessages& operator=(StorageReturnMessages&& from) noexcept {
4309 if (this == &from) return *this;
4310 if (GetOwningArena() == from.GetOwningArena()
4311 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
4312 && GetOwningArena() != nullptr
4313 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
4314 ) {
4315 InternalSwap(&from);
4316 } else {
4317 CopyFrom(from);
4318 }
4319 return *this;
4320 }
4321
unknown_fields()4322 inline const std::string& unknown_fields() const {
4323 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
4324 }
mutable_unknown_fields()4325 inline std::string* mutable_unknown_fields() {
4326 return _internal_metadata_.mutable_unknown_fields<std::string>();
4327 }
4328
default_instance()4329 static const StorageReturnMessages& default_instance() {
4330 return *internal_default_instance();
4331 }
internal_default_instance()4332 static inline const StorageReturnMessages* internal_default_instance() {
4333 return reinterpret_cast<const StorageReturnMessages*>(
4334 &_StorageReturnMessages_default_instance_);
4335 }
4336 static constexpr int kIndexInFileMessages =
4337 21;
4338
swap(StorageReturnMessages & a,StorageReturnMessages & b)4339 friend void swap(StorageReturnMessages& a, StorageReturnMessages& b) {
4340 a.Swap(&b);
4341 }
Swap(StorageReturnMessages * other)4342 inline void Swap(StorageReturnMessages* other) {
4343 if (other == this) return;
4344 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
4345 if (GetOwningArena() != nullptr &&
4346 GetOwningArena() == other->GetOwningArena()) {
4347 #else // PROTOBUF_FORCE_COPY_IN_SWAP
4348 if (GetOwningArena() == other->GetOwningArena()) {
4349 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
4350 InternalSwap(other);
4351 } else {
4352 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
4353 }
4354 }
4355 void UnsafeArenaSwap(StorageReturnMessages* other) {
4356 if (other == this) return;
4357 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
4358 InternalSwap(other);
4359 }
4360
4361 // implements Message ----------------------------------------------
4362
4363 StorageReturnMessages* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
4364 return CreateMaybeMessage<StorageReturnMessages>(arena);
4365 }
4366 StorageReturnMessages* New() const {
4367 return New(nullptr);
4368 }
4369 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
4370 void CopyFrom(const StorageReturnMessages& from);
4371 void MergeFrom(const StorageReturnMessages& from);
4372 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
4373 bool IsInitialized() const final;
4374
4375 size_t ByteSizeLong() const final;
4376 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
4377 ::uint8_t* _InternalSerialize(
4378 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
4379 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
4380
4381 private:
4382 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
4383 void SharedDtor();
4384 void SetCachedSize(int size) const;
4385 void InternalSwap(StorageReturnMessages* other);
4386
4387 private:
4388 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
4389 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
4390 return "android.aconfigd.StorageReturnMessages";
4391 }
4392 protected:
4393 explicit StorageReturnMessages(::PROTOBUF_NAMESPACE_ID::Arena* arena,
4394 bool is_message_owned = false);
4395 public:
4396
4397 std::string GetTypeName() const final;
4398
4399 // nested types ----------------------------------------------------
4400
4401 // accessors -------------------------------------------------------
4402
4403 enum : int {
4404 kMsgsFieldNumber = 1,
4405 };
4406 // repeated .android.aconfigd.StorageReturnMessage msgs = 1;
4407 int msgs_size() const;
4408 private:
4409 int _internal_msgs_size() const;
4410 public:
4411 void clear_msgs();
4412 ::android::aconfigd::StorageReturnMessage* mutable_msgs(int index);
4413 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::android::aconfigd::StorageReturnMessage >*
4414 mutable_msgs();
4415 private:
4416 const ::android::aconfigd::StorageReturnMessage& _internal_msgs(int index) const;
4417 ::android::aconfigd::StorageReturnMessage* _internal_add_msgs();
4418 public:
4419 const ::android::aconfigd::StorageReturnMessage& msgs(int index) const;
4420 ::android::aconfigd::StorageReturnMessage* add_msgs();
4421 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::android::aconfigd::StorageReturnMessage >&
4422 msgs() const;
4423
4424 // @@protoc_insertion_point(class_scope:android.aconfigd.StorageReturnMessages)
4425 private:
4426 class _Internal;
4427
4428 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
4429 typedef void InternalArenaConstructable_;
4430 typedef void DestructorSkippable_;
4431 struct Impl_ {
4432 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::android::aconfigd::StorageReturnMessage > msgs_;
4433 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
4434 };
4435 union { Impl_ _impl_; };
4436 friend struct ::TableStruct_packages_2fmodules_2fConfigInfrastructure_2faconfigd_2fproto_2faconfigd_2eproto;
4437 };
4438 // ===================================================================
4439
4440
4441 // ===================================================================
4442
4443 #ifdef __GNUC__
4444 #pragma GCC diagnostic push
4445 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
4446 #endif // __GNUC__
4447 // PersistStorageRecord
4448
4449 // optional uint32 version = 1;
_internal_has_version()4450 inline bool PersistStorageRecord::_internal_has_version() const {
4451 bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
4452 return value;
4453 }
has_version()4454 inline bool PersistStorageRecord::has_version() const {
4455 return _internal_has_version();
4456 }
clear_version()4457 inline void PersistStorageRecord::clear_version() {
4458 _impl_.version_ = 0u;
4459 _impl_._has_bits_[0] &= ~0x00000040u;
4460 }
_internal_version()4461 inline ::uint32_t PersistStorageRecord::_internal_version() const {
4462 return _impl_.version_;
4463 }
version()4464 inline ::uint32_t PersistStorageRecord::version() const {
4465 // @@protoc_insertion_point(field_get:android.aconfigd.PersistStorageRecord.version)
4466 return _internal_version();
4467 }
_internal_set_version(::uint32_t value)4468 inline void PersistStorageRecord::_internal_set_version(::uint32_t value) {
4469 _impl_._has_bits_[0] |= 0x00000040u;
4470 _impl_.version_ = value;
4471 }
set_version(::uint32_t value)4472 inline void PersistStorageRecord::set_version(::uint32_t value) {
4473 _internal_set_version(value);
4474 // @@protoc_insertion_point(field_set:android.aconfigd.PersistStorageRecord.version)
4475 }
4476
4477 // optional string container = 2;
_internal_has_container()4478 inline bool PersistStorageRecord::_internal_has_container() const {
4479 bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
4480 return value;
4481 }
has_container()4482 inline bool PersistStorageRecord::has_container() const {
4483 return _internal_has_container();
4484 }
clear_container()4485 inline void PersistStorageRecord::clear_container() {
4486 _impl_.container_.ClearToEmpty();
4487 _impl_._has_bits_[0] &= ~0x00000001u;
4488 }
container()4489 inline const std::string& PersistStorageRecord::container() const {
4490 // @@protoc_insertion_point(field_get:android.aconfigd.PersistStorageRecord.container)
4491 return _internal_container();
4492 }
4493 template <typename ArgT0, typename... ArgT>
4494 inline PROTOBUF_ALWAYS_INLINE
set_container(ArgT0 && arg0,ArgT...args)4495 void PersistStorageRecord::set_container(ArgT0&& arg0, ArgT... args) {
4496 _impl_._has_bits_[0] |= 0x00000001u;
4497 _impl_.container_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
4498 // @@protoc_insertion_point(field_set:android.aconfigd.PersistStorageRecord.container)
4499 }
mutable_container()4500 inline std::string* PersistStorageRecord::mutable_container() {
4501 std::string* _s = _internal_mutable_container();
4502 // @@protoc_insertion_point(field_mutable:android.aconfigd.PersistStorageRecord.container)
4503 return _s;
4504 }
_internal_container()4505 inline const std::string& PersistStorageRecord::_internal_container() const {
4506 return _impl_.container_.Get();
4507 }
_internal_set_container(const std::string & value)4508 inline void PersistStorageRecord::_internal_set_container(const std::string& value) {
4509 _impl_._has_bits_[0] |= 0x00000001u;
4510 _impl_.container_.Set(value, GetArenaForAllocation());
4511 }
_internal_mutable_container()4512 inline std::string* PersistStorageRecord::_internal_mutable_container() {
4513 _impl_._has_bits_[0] |= 0x00000001u;
4514 return _impl_.container_.Mutable(GetArenaForAllocation());
4515 }
release_container()4516 inline std::string* PersistStorageRecord::release_container() {
4517 // @@protoc_insertion_point(field_release:android.aconfigd.PersistStorageRecord.container)
4518 if (!_internal_has_container()) {
4519 return nullptr;
4520 }
4521 _impl_._has_bits_[0] &= ~0x00000001u;
4522 auto* p = _impl_.container_.Release();
4523 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4524 if (_impl_.container_.IsDefault()) {
4525 _impl_.container_.Set("", GetArenaForAllocation());
4526 }
4527 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4528 return p;
4529 }
set_allocated_container(std::string * container)4530 inline void PersistStorageRecord::set_allocated_container(std::string* container) {
4531 if (container != nullptr) {
4532 _impl_._has_bits_[0] |= 0x00000001u;
4533 } else {
4534 _impl_._has_bits_[0] &= ~0x00000001u;
4535 }
4536 _impl_.container_.SetAllocated(container, GetArenaForAllocation());
4537 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4538 if (_impl_.container_.IsDefault()) {
4539 _impl_.container_.Set("", GetArenaForAllocation());
4540 }
4541 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4542 // @@protoc_insertion_point(field_set_allocated:android.aconfigd.PersistStorageRecord.container)
4543 }
4544
4545 // optional string package_map = 3;
_internal_has_package_map()4546 inline bool PersistStorageRecord::_internal_has_package_map() const {
4547 bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
4548 return value;
4549 }
has_package_map()4550 inline bool PersistStorageRecord::has_package_map() const {
4551 return _internal_has_package_map();
4552 }
clear_package_map()4553 inline void PersistStorageRecord::clear_package_map() {
4554 _impl_.package_map_.ClearToEmpty();
4555 _impl_._has_bits_[0] &= ~0x00000002u;
4556 }
package_map()4557 inline const std::string& PersistStorageRecord::package_map() const {
4558 // @@protoc_insertion_point(field_get:android.aconfigd.PersistStorageRecord.package_map)
4559 return _internal_package_map();
4560 }
4561 template <typename ArgT0, typename... ArgT>
4562 inline PROTOBUF_ALWAYS_INLINE
set_package_map(ArgT0 && arg0,ArgT...args)4563 void PersistStorageRecord::set_package_map(ArgT0&& arg0, ArgT... args) {
4564 _impl_._has_bits_[0] |= 0x00000002u;
4565 _impl_.package_map_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
4566 // @@protoc_insertion_point(field_set:android.aconfigd.PersistStorageRecord.package_map)
4567 }
mutable_package_map()4568 inline std::string* PersistStorageRecord::mutable_package_map() {
4569 std::string* _s = _internal_mutable_package_map();
4570 // @@protoc_insertion_point(field_mutable:android.aconfigd.PersistStorageRecord.package_map)
4571 return _s;
4572 }
_internal_package_map()4573 inline const std::string& PersistStorageRecord::_internal_package_map() const {
4574 return _impl_.package_map_.Get();
4575 }
_internal_set_package_map(const std::string & value)4576 inline void PersistStorageRecord::_internal_set_package_map(const std::string& value) {
4577 _impl_._has_bits_[0] |= 0x00000002u;
4578 _impl_.package_map_.Set(value, GetArenaForAllocation());
4579 }
_internal_mutable_package_map()4580 inline std::string* PersistStorageRecord::_internal_mutable_package_map() {
4581 _impl_._has_bits_[0] |= 0x00000002u;
4582 return _impl_.package_map_.Mutable(GetArenaForAllocation());
4583 }
release_package_map()4584 inline std::string* PersistStorageRecord::release_package_map() {
4585 // @@protoc_insertion_point(field_release:android.aconfigd.PersistStorageRecord.package_map)
4586 if (!_internal_has_package_map()) {
4587 return nullptr;
4588 }
4589 _impl_._has_bits_[0] &= ~0x00000002u;
4590 auto* p = _impl_.package_map_.Release();
4591 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4592 if (_impl_.package_map_.IsDefault()) {
4593 _impl_.package_map_.Set("", GetArenaForAllocation());
4594 }
4595 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4596 return p;
4597 }
set_allocated_package_map(std::string * package_map)4598 inline void PersistStorageRecord::set_allocated_package_map(std::string* package_map) {
4599 if (package_map != nullptr) {
4600 _impl_._has_bits_[0] |= 0x00000002u;
4601 } else {
4602 _impl_._has_bits_[0] &= ~0x00000002u;
4603 }
4604 _impl_.package_map_.SetAllocated(package_map, GetArenaForAllocation());
4605 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4606 if (_impl_.package_map_.IsDefault()) {
4607 _impl_.package_map_.Set("", GetArenaForAllocation());
4608 }
4609 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4610 // @@protoc_insertion_point(field_set_allocated:android.aconfigd.PersistStorageRecord.package_map)
4611 }
4612
4613 // optional string flag_map = 4;
_internal_has_flag_map()4614 inline bool PersistStorageRecord::_internal_has_flag_map() const {
4615 bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
4616 return value;
4617 }
has_flag_map()4618 inline bool PersistStorageRecord::has_flag_map() const {
4619 return _internal_has_flag_map();
4620 }
clear_flag_map()4621 inline void PersistStorageRecord::clear_flag_map() {
4622 _impl_.flag_map_.ClearToEmpty();
4623 _impl_._has_bits_[0] &= ~0x00000004u;
4624 }
flag_map()4625 inline const std::string& PersistStorageRecord::flag_map() const {
4626 // @@protoc_insertion_point(field_get:android.aconfigd.PersistStorageRecord.flag_map)
4627 return _internal_flag_map();
4628 }
4629 template <typename ArgT0, typename... ArgT>
4630 inline PROTOBUF_ALWAYS_INLINE
set_flag_map(ArgT0 && arg0,ArgT...args)4631 void PersistStorageRecord::set_flag_map(ArgT0&& arg0, ArgT... args) {
4632 _impl_._has_bits_[0] |= 0x00000004u;
4633 _impl_.flag_map_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
4634 // @@protoc_insertion_point(field_set:android.aconfigd.PersistStorageRecord.flag_map)
4635 }
mutable_flag_map()4636 inline std::string* PersistStorageRecord::mutable_flag_map() {
4637 std::string* _s = _internal_mutable_flag_map();
4638 // @@protoc_insertion_point(field_mutable:android.aconfigd.PersistStorageRecord.flag_map)
4639 return _s;
4640 }
_internal_flag_map()4641 inline const std::string& PersistStorageRecord::_internal_flag_map() const {
4642 return _impl_.flag_map_.Get();
4643 }
_internal_set_flag_map(const std::string & value)4644 inline void PersistStorageRecord::_internal_set_flag_map(const std::string& value) {
4645 _impl_._has_bits_[0] |= 0x00000004u;
4646 _impl_.flag_map_.Set(value, GetArenaForAllocation());
4647 }
_internal_mutable_flag_map()4648 inline std::string* PersistStorageRecord::_internal_mutable_flag_map() {
4649 _impl_._has_bits_[0] |= 0x00000004u;
4650 return _impl_.flag_map_.Mutable(GetArenaForAllocation());
4651 }
release_flag_map()4652 inline std::string* PersistStorageRecord::release_flag_map() {
4653 // @@protoc_insertion_point(field_release:android.aconfigd.PersistStorageRecord.flag_map)
4654 if (!_internal_has_flag_map()) {
4655 return nullptr;
4656 }
4657 _impl_._has_bits_[0] &= ~0x00000004u;
4658 auto* p = _impl_.flag_map_.Release();
4659 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4660 if (_impl_.flag_map_.IsDefault()) {
4661 _impl_.flag_map_.Set("", GetArenaForAllocation());
4662 }
4663 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4664 return p;
4665 }
set_allocated_flag_map(std::string * flag_map)4666 inline void PersistStorageRecord::set_allocated_flag_map(std::string* flag_map) {
4667 if (flag_map != nullptr) {
4668 _impl_._has_bits_[0] |= 0x00000004u;
4669 } else {
4670 _impl_._has_bits_[0] &= ~0x00000004u;
4671 }
4672 _impl_.flag_map_.SetAllocated(flag_map, GetArenaForAllocation());
4673 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4674 if (_impl_.flag_map_.IsDefault()) {
4675 _impl_.flag_map_.Set("", GetArenaForAllocation());
4676 }
4677 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4678 // @@protoc_insertion_point(field_set_allocated:android.aconfigd.PersistStorageRecord.flag_map)
4679 }
4680
4681 // optional string flag_val = 5;
_internal_has_flag_val()4682 inline bool PersistStorageRecord::_internal_has_flag_val() const {
4683 bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
4684 return value;
4685 }
has_flag_val()4686 inline bool PersistStorageRecord::has_flag_val() const {
4687 return _internal_has_flag_val();
4688 }
clear_flag_val()4689 inline void PersistStorageRecord::clear_flag_val() {
4690 _impl_.flag_val_.ClearToEmpty();
4691 _impl_._has_bits_[0] &= ~0x00000008u;
4692 }
flag_val()4693 inline const std::string& PersistStorageRecord::flag_val() const {
4694 // @@protoc_insertion_point(field_get:android.aconfigd.PersistStorageRecord.flag_val)
4695 return _internal_flag_val();
4696 }
4697 template <typename ArgT0, typename... ArgT>
4698 inline PROTOBUF_ALWAYS_INLINE
set_flag_val(ArgT0 && arg0,ArgT...args)4699 void PersistStorageRecord::set_flag_val(ArgT0&& arg0, ArgT... args) {
4700 _impl_._has_bits_[0] |= 0x00000008u;
4701 _impl_.flag_val_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
4702 // @@protoc_insertion_point(field_set:android.aconfigd.PersistStorageRecord.flag_val)
4703 }
mutable_flag_val()4704 inline std::string* PersistStorageRecord::mutable_flag_val() {
4705 std::string* _s = _internal_mutable_flag_val();
4706 // @@protoc_insertion_point(field_mutable:android.aconfigd.PersistStorageRecord.flag_val)
4707 return _s;
4708 }
_internal_flag_val()4709 inline const std::string& PersistStorageRecord::_internal_flag_val() const {
4710 return _impl_.flag_val_.Get();
4711 }
_internal_set_flag_val(const std::string & value)4712 inline void PersistStorageRecord::_internal_set_flag_val(const std::string& value) {
4713 _impl_._has_bits_[0] |= 0x00000008u;
4714 _impl_.flag_val_.Set(value, GetArenaForAllocation());
4715 }
_internal_mutable_flag_val()4716 inline std::string* PersistStorageRecord::_internal_mutable_flag_val() {
4717 _impl_._has_bits_[0] |= 0x00000008u;
4718 return _impl_.flag_val_.Mutable(GetArenaForAllocation());
4719 }
release_flag_val()4720 inline std::string* PersistStorageRecord::release_flag_val() {
4721 // @@protoc_insertion_point(field_release:android.aconfigd.PersistStorageRecord.flag_val)
4722 if (!_internal_has_flag_val()) {
4723 return nullptr;
4724 }
4725 _impl_._has_bits_[0] &= ~0x00000008u;
4726 auto* p = _impl_.flag_val_.Release();
4727 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4728 if (_impl_.flag_val_.IsDefault()) {
4729 _impl_.flag_val_.Set("", GetArenaForAllocation());
4730 }
4731 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4732 return p;
4733 }
set_allocated_flag_val(std::string * flag_val)4734 inline void PersistStorageRecord::set_allocated_flag_val(std::string* flag_val) {
4735 if (flag_val != nullptr) {
4736 _impl_._has_bits_[0] |= 0x00000008u;
4737 } else {
4738 _impl_._has_bits_[0] &= ~0x00000008u;
4739 }
4740 _impl_.flag_val_.SetAllocated(flag_val, GetArenaForAllocation());
4741 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4742 if (_impl_.flag_val_.IsDefault()) {
4743 _impl_.flag_val_.Set("", GetArenaForAllocation());
4744 }
4745 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4746 // @@protoc_insertion_point(field_set_allocated:android.aconfigd.PersistStorageRecord.flag_val)
4747 }
4748
4749 // optional string digest = 6;
_internal_has_digest()4750 inline bool PersistStorageRecord::_internal_has_digest() const {
4751 bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
4752 return value;
4753 }
has_digest()4754 inline bool PersistStorageRecord::has_digest() const {
4755 return _internal_has_digest();
4756 }
clear_digest()4757 inline void PersistStorageRecord::clear_digest() {
4758 _impl_.digest_.ClearToEmpty();
4759 _impl_._has_bits_[0] &= ~0x00000010u;
4760 }
digest()4761 inline const std::string& PersistStorageRecord::digest() const {
4762 // @@protoc_insertion_point(field_get:android.aconfigd.PersistStorageRecord.digest)
4763 return _internal_digest();
4764 }
4765 template <typename ArgT0, typename... ArgT>
4766 inline PROTOBUF_ALWAYS_INLINE
set_digest(ArgT0 && arg0,ArgT...args)4767 void PersistStorageRecord::set_digest(ArgT0&& arg0, ArgT... args) {
4768 _impl_._has_bits_[0] |= 0x00000010u;
4769 _impl_.digest_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
4770 // @@protoc_insertion_point(field_set:android.aconfigd.PersistStorageRecord.digest)
4771 }
mutable_digest()4772 inline std::string* PersistStorageRecord::mutable_digest() {
4773 std::string* _s = _internal_mutable_digest();
4774 // @@protoc_insertion_point(field_mutable:android.aconfigd.PersistStorageRecord.digest)
4775 return _s;
4776 }
_internal_digest()4777 inline const std::string& PersistStorageRecord::_internal_digest() const {
4778 return _impl_.digest_.Get();
4779 }
_internal_set_digest(const std::string & value)4780 inline void PersistStorageRecord::_internal_set_digest(const std::string& value) {
4781 _impl_._has_bits_[0] |= 0x00000010u;
4782 _impl_.digest_.Set(value, GetArenaForAllocation());
4783 }
_internal_mutable_digest()4784 inline std::string* PersistStorageRecord::_internal_mutable_digest() {
4785 _impl_._has_bits_[0] |= 0x00000010u;
4786 return _impl_.digest_.Mutable(GetArenaForAllocation());
4787 }
release_digest()4788 inline std::string* PersistStorageRecord::release_digest() {
4789 // @@protoc_insertion_point(field_release:android.aconfigd.PersistStorageRecord.digest)
4790 if (!_internal_has_digest()) {
4791 return nullptr;
4792 }
4793 _impl_._has_bits_[0] &= ~0x00000010u;
4794 auto* p = _impl_.digest_.Release();
4795 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4796 if (_impl_.digest_.IsDefault()) {
4797 _impl_.digest_.Set("", GetArenaForAllocation());
4798 }
4799 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4800 return p;
4801 }
set_allocated_digest(std::string * digest)4802 inline void PersistStorageRecord::set_allocated_digest(std::string* digest) {
4803 if (digest != nullptr) {
4804 _impl_._has_bits_[0] |= 0x00000010u;
4805 } else {
4806 _impl_._has_bits_[0] &= ~0x00000010u;
4807 }
4808 _impl_.digest_.SetAllocated(digest, GetArenaForAllocation());
4809 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4810 if (_impl_.digest_.IsDefault()) {
4811 _impl_.digest_.Set("", GetArenaForAllocation());
4812 }
4813 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4814 // @@protoc_insertion_point(field_set_allocated:android.aconfigd.PersistStorageRecord.digest)
4815 }
4816
4817 // optional string flag_info = 7;
_internal_has_flag_info()4818 inline bool PersistStorageRecord::_internal_has_flag_info() const {
4819 bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
4820 return value;
4821 }
has_flag_info()4822 inline bool PersistStorageRecord::has_flag_info() const {
4823 return _internal_has_flag_info();
4824 }
clear_flag_info()4825 inline void PersistStorageRecord::clear_flag_info() {
4826 _impl_.flag_info_.ClearToEmpty();
4827 _impl_._has_bits_[0] &= ~0x00000020u;
4828 }
flag_info()4829 inline const std::string& PersistStorageRecord::flag_info() const {
4830 // @@protoc_insertion_point(field_get:android.aconfigd.PersistStorageRecord.flag_info)
4831 return _internal_flag_info();
4832 }
4833 template <typename ArgT0, typename... ArgT>
4834 inline PROTOBUF_ALWAYS_INLINE
set_flag_info(ArgT0 && arg0,ArgT...args)4835 void PersistStorageRecord::set_flag_info(ArgT0&& arg0, ArgT... args) {
4836 _impl_._has_bits_[0] |= 0x00000020u;
4837 _impl_.flag_info_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
4838 // @@protoc_insertion_point(field_set:android.aconfigd.PersistStorageRecord.flag_info)
4839 }
mutable_flag_info()4840 inline std::string* PersistStorageRecord::mutable_flag_info() {
4841 std::string* _s = _internal_mutable_flag_info();
4842 // @@protoc_insertion_point(field_mutable:android.aconfigd.PersistStorageRecord.flag_info)
4843 return _s;
4844 }
_internal_flag_info()4845 inline const std::string& PersistStorageRecord::_internal_flag_info() const {
4846 return _impl_.flag_info_.Get();
4847 }
_internal_set_flag_info(const std::string & value)4848 inline void PersistStorageRecord::_internal_set_flag_info(const std::string& value) {
4849 _impl_._has_bits_[0] |= 0x00000020u;
4850 _impl_.flag_info_.Set(value, GetArenaForAllocation());
4851 }
_internal_mutable_flag_info()4852 inline std::string* PersistStorageRecord::_internal_mutable_flag_info() {
4853 _impl_._has_bits_[0] |= 0x00000020u;
4854 return _impl_.flag_info_.Mutable(GetArenaForAllocation());
4855 }
release_flag_info()4856 inline std::string* PersistStorageRecord::release_flag_info() {
4857 // @@protoc_insertion_point(field_release:android.aconfigd.PersistStorageRecord.flag_info)
4858 if (!_internal_has_flag_info()) {
4859 return nullptr;
4860 }
4861 _impl_._has_bits_[0] &= ~0x00000020u;
4862 auto* p = _impl_.flag_info_.Release();
4863 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4864 if (_impl_.flag_info_.IsDefault()) {
4865 _impl_.flag_info_.Set("", GetArenaForAllocation());
4866 }
4867 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4868 return p;
4869 }
set_allocated_flag_info(std::string * flag_info)4870 inline void PersistStorageRecord::set_allocated_flag_info(std::string* flag_info) {
4871 if (flag_info != nullptr) {
4872 _impl_._has_bits_[0] |= 0x00000020u;
4873 } else {
4874 _impl_._has_bits_[0] &= ~0x00000020u;
4875 }
4876 _impl_.flag_info_.SetAllocated(flag_info, GetArenaForAllocation());
4877 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4878 if (_impl_.flag_info_.IsDefault()) {
4879 _impl_.flag_info_.Set("", GetArenaForAllocation());
4880 }
4881 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4882 // @@protoc_insertion_point(field_set_allocated:android.aconfigd.PersistStorageRecord.flag_info)
4883 }
4884
4885 // -------------------------------------------------------------------
4886
4887 // PersistStorageRecords
4888
4889 // repeated .android.aconfigd.PersistStorageRecord records = 1;
_internal_records_size()4890 inline int PersistStorageRecords::_internal_records_size() const {
4891 return _impl_.records_.size();
4892 }
records_size()4893 inline int PersistStorageRecords::records_size() const {
4894 return _internal_records_size();
4895 }
clear_records()4896 inline void PersistStorageRecords::clear_records() {
4897 _impl_.records_.Clear();
4898 }
mutable_records(int index)4899 inline ::android::aconfigd::PersistStorageRecord* PersistStorageRecords::mutable_records(int index) {
4900 // @@protoc_insertion_point(field_mutable:android.aconfigd.PersistStorageRecords.records)
4901 return _impl_.records_.Mutable(index);
4902 }
4903 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::android::aconfigd::PersistStorageRecord >*
mutable_records()4904 PersistStorageRecords::mutable_records() {
4905 // @@protoc_insertion_point(field_mutable_list:android.aconfigd.PersistStorageRecords.records)
4906 return &_impl_.records_;
4907 }
_internal_records(int index)4908 inline const ::android::aconfigd::PersistStorageRecord& PersistStorageRecords::_internal_records(int index) const {
4909 return _impl_.records_.Get(index);
4910 }
records(int index)4911 inline const ::android::aconfigd::PersistStorageRecord& PersistStorageRecords::records(int index) const {
4912 // @@protoc_insertion_point(field_get:android.aconfigd.PersistStorageRecords.records)
4913 return _internal_records(index);
4914 }
_internal_add_records()4915 inline ::android::aconfigd::PersistStorageRecord* PersistStorageRecords::_internal_add_records() {
4916 return _impl_.records_.Add();
4917 }
add_records()4918 inline ::android::aconfigd::PersistStorageRecord* PersistStorageRecords::add_records() {
4919 ::android::aconfigd::PersistStorageRecord* _add = _internal_add_records();
4920 // @@protoc_insertion_point(field_add:android.aconfigd.PersistStorageRecords.records)
4921 return _add;
4922 }
4923 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::android::aconfigd::PersistStorageRecord >&
records()4924 PersistStorageRecords::records() const {
4925 // @@protoc_insertion_point(field_list:android.aconfigd.PersistStorageRecords.records)
4926 return _impl_.records_;
4927 }
4928
4929 // -------------------------------------------------------------------
4930
4931 // FlagOverride
4932
4933 // optional string package_name = 1;
_internal_has_package_name()4934 inline bool FlagOverride::_internal_has_package_name() const {
4935 bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
4936 return value;
4937 }
has_package_name()4938 inline bool FlagOverride::has_package_name() const {
4939 return _internal_has_package_name();
4940 }
clear_package_name()4941 inline void FlagOverride::clear_package_name() {
4942 _impl_.package_name_.ClearToEmpty();
4943 _impl_._has_bits_[0] &= ~0x00000001u;
4944 }
package_name()4945 inline const std::string& FlagOverride::package_name() const {
4946 // @@protoc_insertion_point(field_get:android.aconfigd.FlagOverride.package_name)
4947 return _internal_package_name();
4948 }
4949 template <typename ArgT0, typename... ArgT>
4950 inline PROTOBUF_ALWAYS_INLINE
set_package_name(ArgT0 && arg0,ArgT...args)4951 void FlagOverride::set_package_name(ArgT0&& arg0, ArgT... args) {
4952 _impl_._has_bits_[0] |= 0x00000001u;
4953 _impl_.package_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
4954 // @@protoc_insertion_point(field_set:android.aconfigd.FlagOverride.package_name)
4955 }
mutable_package_name()4956 inline std::string* FlagOverride::mutable_package_name() {
4957 std::string* _s = _internal_mutable_package_name();
4958 // @@protoc_insertion_point(field_mutable:android.aconfigd.FlagOverride.package_name)
4959 return _s;
4960 }
_internal_package_name()4961 inline const std::string& FlagOverride::_internal_package_name() const {
4962 return _impl_.package_name_.Get();
4963 }
_internal_set_package_name(const std::string & value)4964 inline void FlagOverride::_internal_set_package_name(const std::string& value) {
4965 _impl_._has_bits_[0] |= 0x00000001u;
4966 _impl_.package_name_.Set(value, GetArenaForAllocation());
4967 }
_internal_mutable_package_name()4968 inline std::string* FlagOverride::_internal_mutable_package_name() {
4969 _impl_._has_bits_[0] |= 0x00000001u;
4970 return _impl_.package_name_.Mutable(GetArenaForAllocation());
4971 }
release_package_name()4972 inline std::string* FlagOverride::release_package_name() {
4973 // @@protoc_insertion_point(field_release:android.aconfigd.FlagOverride.package_name)
4974 if (!_internal_has_package_name()) {
4975 return nullptr;
4976 }
4977 _impl_._has_bits_[0] &= ~0x00000001u;
4978 auto* p = _impl_.package_name_.Release();
4979 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4980 if (_impl_.package_name_.IsDefault()) {
4981 _impl_.package_name_.Set("", GetArenaForAllocation());
4982 }
4983 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4984 return p;
4985 }
set_allocated_package_name(std::string * package_name)4986 inline void FlagOverride::set_allocated_package_name(std::string* package_name) {
4987 if (package_name != nullptr) {
4988 _impl_._has_bits_[0] |= 0x00000001u;
4989 } else {
4990 _impl_._has_bits_[0] &= ~0x00000001u;
4991 }
4992 _impl_.package_name_.SetAllocated(package_name, GetArenaForAllocation());
4993 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4994 if (_impl_.package_name_.IsDefault()) {
4995 _impl_.package_name_.Set("", GetArenaForAllocation());
4996 }
4997 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4998 // @@protoc_insertion_point(field_set_allocated:android.aconfigd.FlagOverride.package_name)
4999 }
5000
5001 // optional string flag_name = 2;
_internal_has_flag_name()5002 inline bool FlagOverride::_internal_has_flag_name() const {
5003 bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
5004 return value;
5005 }
has_flag_name()5006 inline bool FlagOverride::has_flag_name() const {
5007 return _internal_has_flag_name();
5008 }
clear_flag_name()5009 inline void FlagOverride::clear_flag_name() {
5010 _impl_.flag_name_.ClearToEmpty();
5011 _impl_._has_bits_[0] &= ~0x00000002u;
5012 }
flag_name()5013 inline const std::string& FlagOverride::flag_name() const {
5014 // @@protoc_insertion_point(field_get:android.aconfigd.FlagOverride.flag_name)
5015 return _internal_flag_name();
5016 }
5017 template <typename ArgT0, typename... ArgT>
5018 inline PROTOBUF_ALWAYS_INLINE
set_flag_name(ArgT0 && arg0,ArgT...args)5019 void FlagOverride::set_flag_name(ArgT0&& arg0, ArgT... args) {
5020 _impl_._has_bits_[0] |= 0x00000002u;
5021 _impl_.flag_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
5022 // @@protoc_insertion_point(field_set:android.aconfigd.FlagOverride.flag_name)
5023 }
mutable_flag_name()5024 inline std::string* FlagOverride::mutable_flag_name() {
5025 std::string* _s = _internal_mutable_flag_name();
5026 // @@protoc_insertion_point(field_mutable:android.aconfigd.FlagOverride.flag_name)
5027 return _s;
5028 }
_internal_flag_name()5029 inline const std::string& FlagOverride::_internal_flag_name() const {
5030 return _impl_.flag_name_.Get();
5031 }
_internal_set_flag_name(const std::string & value)5032 inline void FlagOverride::_internal_set_flag_name(const std::string& value) {
5033 _impl_._has_bits_[0] |= 0x00000002u;
5034 _impl_.flag_name_.Set(value, GetArenaForAllocation());
5035 }
_internal_mutable_flag_name()5036 inline std::string* FlagOverride::_internal_mutable_flag_name() {
5037 _impl_._has_bits_[0] |= 0x00000002u;
5038 return _impl_.flag_name_.Mutable(GetArenaForAllocation());
5039 }
release_flag_name()5040 inline std::string* FlagOverride::release_flag_name() {
5041 // @@protoc_insertion_point(field_release:android.aconfigd.FlagOverride.flag_name)
5042 if (!_internal_has_flag_name()) {
5043 return nullptr;
5044 }
5045 _impl_._has_bits_[0] &= ~0x00000002u;
5046 auto* p = _impl_.flag_name_.Release();
5047 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
5048 if (_impl_.flag_name_.IsDefault()) {
5049 _impl_.flag_name_.Set("", GetArenaForAllocation());
5050 }
5051 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
5052 return p;
5053 }
set_allocated_flag_name(std::string * flag_name)5054 inline void FlagOverride::set_allocated_flag_name(std::string* flag_name) {
5055 if (flag_name != nullptr) {
5056 _impl_._has_bits_[0] |= 0x00000002u;
5057 } else {
5058 _impl_._has_bits_[0] &= ~0x00000002u;
5059 }
5060 _impl_.flag_name_.SetAllocated(flag_name, GetArenaForAllocation());
5061 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
5062 if (_impl_.flag_name_.IsDefault()) {
5063 _impl_.flag_name_.Set("", GetArenaForAllocation());
5064 }
5065 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
5066 // @@protoc_insertion_point(field_set_allocated:android.aconfigd.FlagOverride.flag_name)
5067 }
5068
5069 // optional string flag_value = 3;
_internal_has_flag_value()5070 inline bool FlagOverride::_internal_has_flag_value() const {
5071 bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
5072 return value;
5073 }
has_flag_value()5074 inline bool FlagOverride::has_flag_value() const {
5075 return _internal_has_flag_value();
5076 }
clear_flag_value()5077 inline void FlagOverride::clear_flag_value() {
5078 _impl_.flag_value_.ClearToEmpty();
5079 _impl_._has_bits_[0] &= ~0x00000004u;
5080 }
flag_value()5081 inline const std::string& FlagOverride::flag_value() const {
5082 // @@protoc_insertion_point(field_get:android.aconfigd.FlagOverride.flag_value)
5083 return _internal_flag_value();
5084 }
5085 template <typename ArgT0, typename... ArgT>
5086 inline PROTOBUF_ALWAYS_INLINE
set_flag_value(ArgT0 && arg0,ArgT...args)5087 void FlagOverride::set_flag_value(ArgT0&& arg0, ArgT... args) {
5088 _impl_._has_bits_[0] |= 0x00000004u;
5089 _impl_.flag_value_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
5090 // @@protoc_insertion_point(field_set:android.aconfigd.FlagOverride.flag_value)
5091 }
mutable_flag_value()5092 inline std::string* FlagOverride::mutable_flag_value() {
5093 std::string* _s = _internal_mutable_flag_value();
5094 // @@protoc_insertion_point(field_mutable:android.aconfigd.FlagOverride.flag_value)
5095 return _s;
5096 }
_internal_flag_value()5097 inline const std::string& FlagOverride::_internal_flag_value() const {
5098 return _impl_.flag_value_.Get();
5099 }
_internal_set_flag_value(const std::string & value)5100 inline void FlagOverride::_internal_set_flag_value(const std::string& value) {
5101 _impl_._has_bits_[0] |= 0x00000004u;
5102 _impl_.flag_value_.Set(value, GetArenaForAllocation());
5103 }
_internal_mutable_flag_value()5104 inline std::string* FlagOverride::_internal_mutable_flag_value() {
5105 _impl_._has_bits_[0] |= 0x00000004u;
5106 return _impl_.flag_value_.Mutable(GetArenaForAllocation());
5107 }
release_flag_value()5108 inline std::string* FlagOverride::release_flag_value() {
5109 // @@protoc_insertion_point(field_release:android.aconfigd.FlagOverride.flag_value)
5110 if (!_internal_has_flag_value()) {
5111 return nullptr;
5112 }
5113 _impl_._has_bits_[0] &= ~0x00000004u;
5114 auto* p = _impl_.flag_value_.Release();
5115 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
5116 if (_impl_.flag_value_.IsDefault()) {
5117 _impl_.flag_value_.Set("", GetArenaForAllocation());
5118 }
5119 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
5120 return p;
5121 }
set_allocated_flag_value(std::string * flag_value)5122 inline void FlagOverride::set_allocated_flag_value(std::string* flag_value) {
5123 if (flag_value != nullptr) {
5124 _impl_._has_bits_[0] |= 0x00000004u;
5125 } else {
5126 _impl_._has_bits_[0] &= ~0x00000004u;
5127 }
5128 _impl_.flag_value_.SetAllocated(flag_value, GetArenaForAllocation());
5129 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
5130 if (_impl_.flag_value_.IsDefault()) {
5131 _impl_.flag_value_.Set("", GetArenaForAllocation());
5132 }
5133 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
5134 // @@protoc_insertion_point(field_set_allocated:android.aconfigd.FlagOverride.flag_value)
5135 }
5136
5137 // -------------------------------------------------------------------
5138
5139 // LocalFlagOverrides
5140
5141 // repeated .android.aconfigd.FlagOverride overrides = 1;
_internal_overrides_size()5142 inline int LocalFlagOverrides::_internal_overrides_size() const {
5143 return _impl_.overrides_.size();
5144 }
overrides_size()5145 inline int LocalFlagOverrides::overrides_size() const {
5146 return _internal_overrides_size();
5147 }
clear_overrides()5148 inline void LocalFlagOverrides::clear_overrides() {
5149 _impl_.overrides_.Clear();
5150 }
mutable_overrides(int index)5151 inline ::android::aconfigd::FlagOverride* LocalFlagOverrides::mutable_overrides(int index) {
5152 // @@protoc_insertion_point(field_mutable:android.aconfigd.LocalFlagOverrides.overrides)
5153 return _impl_.overrides_.Mutable(index);
5154 }
5155 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::android::aconfigd::FlagOverride >*
mutable_overrides()5156 LocalFlagOverrides::mutable_overrides() {
5157 // @@protoc_insertion_point(field_mutable_list:android.aconfigd.LocalFlagOverrides.overrides)
5158 return &_impl_.overrides_;
5159 }
_internal_overrides(int index)5160 inline const ::android::aconfigd::FlagOverride& LocalFlagOverrides::_internal_overrides(int index) const {
5161 return _impl_.overrides_.Get(index);
5162 }
overrides(int index)5163 inline const ::android::aconfigd::FlagOverride& LocalFlagOverrides::overrides(int index) const {
5164 // @@protoc_insertion_point(field_get:android.aconfigd.LocalFlagOverrides.overrides)
5165 return _internal_overrides(index);
5166 }
_internal_add_overrides()5167 inline ::android::aconfigd::FlagOverride* LocalFlagOverrides::_internal_add_overrides() {
5168 return _impl_.overrides_.Add();
5169 }
add_overrides()5170 inline ::android::aconfigd::FlagOverride* LocalFlagOverrides::add_overrides() {
5171 ::android::aconfigd::FlagOverride* _add = _internal_add_overrides();
5172 // @@protoc_insertion_point(field_add:android.aconfigd.LocalFlagOverrides.overrides)
5173 return _add;
5174 }
5175 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::android::aconfigd::FlagOverride >&
overrides()5176 LocalFlagOverrides::overrides() const {
5177 // @@protoc_insertion_point(field_list:android.aconfigd.LocalFlagOverrides.overrides)
5178 return _impl_.overrides_;
5179 }
5180
5181 // -------------------------------------------------------------------
5182
5183 // StorageRequestMessage_NewStorageMessage
5184
5185 // optional string container = 1;
_internal_has_container()5186 inline bool StorageRequestMessage_NewStorageMessage::_internal_has_container() const {
5187 bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
5188 return value;
5189 }
has_container()5190 inline bool StorageRequestMessage_NewStorageMessage::has_container() const {
5191 return _internal_has_container();
5192 }
clear_container()5193 inline void StorageRequestMessage_NewStorageMessage::clear_container() {
5194 _impl_.container_.ClearToEmpty();
5195 _impl_._has_bits_[0] &= ~0x00000001u;
5196 }
container()5197 inline const std::string& StorageRequestMessage_NewStorageMessage::container() const {
5198 // @@protoc_insertion_point(field_get:android.aconfigd.StorageRequestMessage.NewStorageMessage.container)
5199 return _internal_container();
5200 }
5201 template <typename ArgT0, typename... ArgT>
5202 inline PROTOBUF_ALWAYS_INLINE
set_container(ArgT0 && arg0,ArgT...args)5203 void StorageRequestMessage_NewStorageMessage::set_container(ArgT0&& arg0, ArgT... args) {
5204 _impl_._has_bits_[0] |= 0x00000001u;
5205 _impl_.container_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
5206 // @@protoc_insertion_point(field_set:android.aconfigd.StorageRequestMessage.NewStorageMessage.container)
5207 }
mutable_container()5208 inline std::string* StorageRequestMessage_NewStorageMessage::mutable_container() {
5209 std::string* _s = _internal_mutable_container();
5210 // @@protoc_insertion_point(field_mutable:android.aconfigd.StorageRequestMessage.NewStorageMessage.container)
5211 return _s;
5212 }
_internal_container()5213 inline const std::string& StorageRequestMessage_NewStorageMessage::_internal_container() const {
5214 return _impl_.container_.Get();
5215 }
_internal_set_container(const std::string & value)5216 inline void StorageRequestMessage_NewStorageMessage::_internal_set_container(const std::string& value) {
5217 _impl_._has_bits_[0] |= 0x00000001u;
5218 _impl_.container_.Set(value, GetArenaForAllocation());
5219 }
_internal_mutable_container()5220 inline std::string* StorageRequestMessage_NewStorageMessage::_internal_mutable_container() {
5221 _impl_._has_bits_[0] |= 0x00000001u;
5222 return _impl_.container_.Mutable(GetArenaForAllocation());
5223 }
release_container()5224 inline std::string* StorageRequestMessage_NewStorageMessage::release_container() {
5225 // @@protoc_insertion_point(field_release:android.aconfigd.StorageRequestMessage.NewStorageMessage.container)
5226 if (!_internal_has_container()) {
5227 return nullptr;
5228 }
5229 _impl_._has_bits_[0] &= ~0x00000001u;
5230 auto* p = _impl_.container_.Release();
5231 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
5232 if (_impl_.container_.IsDefault()) {
5233 _impl_.container_.Set("", GetArenaForAllocation());
5234 }
5235 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
5236 return p;
5237 }
set_allocated_container(std::string * container)5238 inline void StorageRequestMessage_NewStorageMessage::set_allocated_container(std::string* container) {
5239 if (container != nullptr) {
5240 _impl_._has_bits_[0] |= 0x00000001u;
5241 } else {
5242 _impl_._has_bits_[0] &= ~0x00000001u;
5243 }
5244 _impl_.container_.SetAllocated(container, GetArenaForAllocation());
5245 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
5246 if (_impl_.container_.IsDefault()) {
5247 _impl_.container_.Set("", GetArenaForAllocation());
5248 }
5249 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
5250 // @@protoc_insertion_point(field_set_allocated:android.aconfigd.StorageRequestMessage.NewStorageMessage.container)
5251 }
5252
5253 // optional string package_map = 2;
_internal_has_package_map()5254 inline bool StorageRequestMessage_NewStorageMessage::_internal_has_package_map() const {
5255 bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
5256 return value;
5257 }
has_package_map()5258 inline bool StorageRequestMessage_NewStorageMessage::has_package_map() const {
5259 return _internal_has_package_map();
5260 }
clear_package_map()5261 inline void StorageRequestMessage_NewStorageMessage::clear_package_map() {
5262 _impl_.package_map_.ClearToEmpty();
5263 _impl_._has_bits_[0] &= ~0x00000002u;
5264 }
package_map()5265 inline const std::string& StorageRequestMessage_NewStorageMessage::package_map() const {
5266 // @@protoc_insertion_point(field_get:android.aconfigd.StorageRequestMessage.NewStorageMessage.package_map)
5267 return _internal_package_map();
5268 }
5269 template <typename ArgT0, typename... ArgT>
5270 inline PROTOBUF_ALWAYS_INLINE
set_package_map(ArgT0 && arg0,ArgT...args)5271 void StorageRequestMessage_NewStorageMessage::set_package_map(ArgT0&& arg0, ArgT... args) {
5272 _impl_._has_bits_[0] |= 0x00000002u;
5273 _impl_.package_map_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
5274 // @@protoc_insertion_point(field_set:android.aconfigd.StorageRequestMessage.NewStorageMessage.package_map)
5275 }
mutable_package_map()5276 inline std::string* StorageRequestMessage_NewStorageMessage::mutable_package_map() {
5277 std::string* _s = _internal_mutable_package_map();
5278 // @@protoc_insertion_point(field_mutable:android.aconfigd.StorageRequestMessage.NewStorageMessage.package_map)
5279 return _s;
5280 }
_internal_package_map()5281 inline const std::string& StorageRequestMessage_NewStorageMessage::_internal_package_map() const {
5282 return _impl_.package_map_.Get();
5283 }
_internal_set_package_map(const std::string & value)5284 inline void StorageRequestMessage_NewStorageMessage::_internal_set_package_map(const std::string& value) {
5285 _impl_._has_bits_[0] |= 0x00000002u;
5286 _impl_.package_map_.Set(value, GetArenaForAllocation());
5287 }
_internal_mutable_package_map()5288 inline std::string* StorageRequestMessage_NewStorageMessage::_internal_mutable_package_map() {
5289 _impl_._has_bits_[0] |= 0x00000002u;
5290 return _impl_.package_map_.Mutable(GetArenaForAllocation());
5291 }
release_package_map()5292 inline std::string* StorageRequestMessage_NewStorageMessage::release_package_map() {
5293 // @@protoc_insertion_point(field_release:android.aconfigd.StorageRequestMessage.NewStorageMessage.package_map)
5294 if (!_internal_has_package_map()) {
5295 return nullptr;
5296 }
5297 _impl_._has_bits_[0] &= ~0x00000002u;
5298 auto* p = _impl_.package_map_.Release();
5299 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
5300 if (_impl_.package_map_.IsDefault()) {
5301 _impl_.package_map_.Set("", GetArenaForAllocation());
5302 }
5303 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
5304 return p;
5305 }
set_allocated_package_map(std::string * package_map)5306 inline void StorageRequestMessage_NewStorageMessage::set_allocated_package_map(std::string* package_map) {
5307 if (package_map != nullptr) {
5308 _impl_._has_bits_[0] |= 0x00000002u;
5309 } else {
5310 _impl_._has_bits_[0] &= ~0x00000002u;
5311 }
5312 _impl_.package_map_.SetAllocated(package_map, GetArenaForAllocation());
5313 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
5314 if (_impl_.package_map_.IsDefault()) {
5315 _impl_.package_map_.Set("", GetArenaForAllocation());
5316 }
5317 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
5318 // @@protoc_insertion_point(field_set_allocated:android.aconfigd.StorageRequestMessage.NewStorageMessage.package_map)
5319 }
5320
5321 // optional string flag_map = 3;
_internal_has_flag_map()5322 inline bool StorageRequestMessage_NewStorageMessage::_internal_has_flag_map() const {
5323 bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
5324 return value;
5325 }
has_flag_map()5326 inline bool StorageRequestMessage_NewStorageMessage::has_flag_map() const {
5327 return _internal_has_flag_map();
5328 }
clear_flag_map()5329 inline void StorageRequestMessage_NewStorageMessage::clear_flag_map() {
5330 _impl_.flag_map_.ClearToEmpty();
5331 _impl_._has_bits_[0] &= ~0x00000004u;
5332 }
flag_map()5333 inline const std::string& StorageRequestMessage_NewStorageMessage::flag_map() const {
5334 // @@protoc_insertion_point(field_get:android.aconfigd.StorageRequestMessage.NewStorageMessage.flag_map)
5335 return _internal_flag_map();
5336 }
5337 template <typename ArgT0, typename... ArgT>
5338 inline PROTOBUF_ALWAYS_INLINE
set_flag_map(ArgT0 && arg0,ArgT...args)5339 void StorageRequestMessage_NewStorageMessage::set_flag_map(ArgT0&& arg0, ArgT... args) {
5340 _impl_._has_bits_[0] |= 0x00000004u;
5341 _impl_.flag_map_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
5342 // @@protoc_insertion_point(field_set:android.aconfigd.StorageRequestMessage.NewStorageMessage.flag_map)
5343 }
mutable_flag_map()5344 inline std::string* StorageRequestMessage_NewStorageMessage::mutable_flag_map() {
5345 std::string* _s = _internal_mutable_flag_map();
5346 // @@protoc_insertion_point(field_mutable:android.aconfigd.StorageRequestMessage.NewStorageMessage.flag_map)
5347 return _s;
5348 }
_internal_flag_map()5349 inline const std::string& StorageRequestMessage_NewStorageMessage::_internal_flag_map() const {
5350 return _impl_.flag_map_.Get();
5351 }
_internal_set_flag_map(const std::string & value)5352 inline void StorageRequestMessage_NewStorageMessage::_internal_set_flag_map(const std::string& value) {
5353 _impl_._has_bits_[0] |= 0x00000004u;
5354 _impl_.flag_map_.Set(value, GetArenaForAllocation());
5355 }
_internal_mutable_flag_map()5356 inline std::string* StorageRequestMessage_NewStorageMessage::_internal_mutable_flag_map() {
5357 _impl_._has_bits_[0] |= 0x00000004u;
5358 return _impl_.flag_map_.Mutable(GetArenaForAllocation());
5359 }
release_flag_map()5360 inline std::string* StorageRequestMessage_NewStorageMessage::release_flag_map() {
5361 // @@protoc_insertion_point(field_release:android.aconfigd.StorageRequestMessage.NewStorageMessage.flag_map)
5362 if (!_internal_has_flag_map()) {
5363 return nullptr;
5364 }
5365 _impl_._has_bits_[0] &= ~0x00000004u;
5366 auto* p = _impl_.flag_map_.Release();
5367 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
5368 if (_impl_.flag_map_.IsDefault()) {
5369 _impl_.flag_map_.Set("", GetArenaForAllocation());
5370 }
5371 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
5372 return p;
5373 }
set_allocated_flag_map(std::string * flag_map)5374 inline void StorageRequestMessage_NewStorageMessage::set_allocated_flag_map(std::string* flag_map) {
5375 if (flag_map != nullptr) {
5376 _impl_._has_bits_[0] |= 0x00000004u;
5377 } else {
5378 _impl_._has_bits_[0] &= ~0x00000004u;
5379 }
5380 _impl_.flag_map_.SetAllocated(flag_map, GetArenaForAllocation());
5381 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
5382 if (_impl_.flag_map_.IsDefault()) {
5383 _impl_.flag_map_.Set("", GetArenaForAllocation());
5384 }
5385 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
5386 // @@protoc_insertion_point(field_set_allocated:android.aconfigd.StorageRequestMessage.NewStorageMessage.flag_map)
5387 }
5388
5389 // optional string flag_value = 4;
_internal_has_flag_value()5390 inline bool StorageRequestMessage_NewStorageMessage::_internal_has_flag_value() const {
5391 bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
5392 return value;
5393 }
has_flag_value()5394 inline bool StorageRequestMessage_NewStorageMessage::has_flag_value() const {
5395 return _internal_has_flag_value();
5396 }
clear_flag_value()5397 inline void StorageRequestMessage_NewStorageMessage::clear_flag_value() {
5398 _impl_.flag_value_.ClearToEmpty();
5399 _impl_._has_bits_[0] &= ~0x00000008u;
5400 }
flag_value()5401 inline const std::string& StorageRequestMessage_NewStorageMessage::flag_value() const {
5402 // @@protoc_insertion_point(field_get:android.aconfigd.StorageRequestMessage.NewStorageMessage.flag_value)
5403 return _internal_flag_value();
5404 }
5405 template <typename ArgT0, typename... ArgT>
5406 inline PROTOBUF_ALWAYS_INLINE
set_flag_value(ArgT0 && arg0,ArgT...args)5407 void StorageRequestMessage_NewStorageMessage::set_flag_value(ArgT0&& arg0, ArgT... args) {
5408 _impl_._has_bits_[0] |= 0x00000008u;
5409 _impl_.flag_value_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
5410 // @@protoc_insertion_point(field_set:android.aconfigd.StorageRequestMessage.NewStorageMessage.flag_value)
5411 }
mutable_flag_value()5412 inline std::string* StorageRequestMessage_NewStorageMessage::mutable_flag_value() {
5413 std::string* _s = _internal_mutable_flag_value();
5414 // @@protoc_insertion_point(field_mutable:android.aconfigd.StorageRequestMessage.NewStorageMessage.flag_value)
5415 return _s;
5416 }
_internal_flag_value()5417 inline const std::string& StorageRequestMessage_NewStorageMessage::_internal_flag_value() const {
5418 return _impl_.flag_value_.Get();
5419 }
_internal_set_flag_value(const std::string & value)5420 inline void StorageRequestMessage_NewStorageMessage::_internal_set_flag_value(const std::string& value) {
5421 _impl_._has_bits_[0] |= 0x00000008u;
5422 _impl_.flag_value_.Set(value, GetArenaForAllocation());
5423 }
_internal_mutable_flag_value()5424 inline std::string* StorageRequestMessage_NewStorageMessage::_internal_mutable_flag_value() {
5425 _impl_._has_bits_[0] |= 0x00000008u;
5426 return _impl_.flag_value_.Mutable(GetArenaForAllocation());
5427 }
release_flag_value()5428 inline std::string* StorageRequestMessage_NewStorageMessage::release_flag_value() {
5429 // @@protoc_insertion_point(field_release:android.aconfigd.StorageRequestMessage.NewStorageMessage.flag_value)
5430 if (!_internal_has_flag_value()) {
5431 return nullptr;
5432 }
5433 _impl_._has_bits_[0] &= ~0x00000008u;
5434 auto* p = _impl_.flag_value_.Release();
5435 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
5436 if (_impl_.flag_value_.IsDefault()) {
5437 _impl_.flag_value_.Set("", GetArenaForAllocation());
5438 }
5439 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
5440 return p;
5441 }
set_allocated_flag_value(std::string * flag_value)5442 inline void StorageRequestMessage_NewStorageMessage::set_allocated_flag_value(std::string* flag_value) {
5443 if (flag_value != nullptr) {
5444 _impl_._has_bits_[0] |= 0x00000008u;
5445 } else {
5446 _impl_._has_bits_[0] &= ~0x00000008u;
5447 }
5448 _impl_.flag_value_.SetAllocated(flag_value, GetArenaForAllocation());
5449 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
5450 if (_impl_.flag_value_.IsDefault()) {
5451 _impl_.flag_value_.Set("", GetArenaForAllocation());
5452 }
5453 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
5454 // @@protoc_insertion_point(field_set_allocated:android.aconfigd.StorageRequestMessage.NewStorageMessage.flag_value)
5455 }
5456
5457 // optional string flag_info = 5;
_internal_has_flag_info()5458 inline bool StorageRequestMessage_NewStorageMessage::_internal_has_flag_info() const {
5459 bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
5460 return value;
5461 }
has_flag_info()5462 inline bool StorageRequestMessage_NewStorageMessage::has_flag_info() const {
5463 return _internal_has_flag_info();
5464 }
clear_flag_info()5465 inline void StorageRequestMessage_NewStorageMessage::clear_flag_info() {
5466 _impl_.flag_info_.ClearToEmpty();
5467 _impl_._has_bits_[0] &= ~0x00000010u;
5468 }
flag_info()5469 inline const std::string& StorageRequestMessage_NewStorageMessage::flag_info() const {
5470 // @@protoc_insertion_point(field_get:android.aconfigd.StorageRequestMessage.NewStorageMessage.flag_info)
5471 return _internal_flag_info();
5472 }
5473 template <typename ArgT0, typename... ArgT>
5474 inline PROTOBUF_ALWAYS_INLINE
set_flag_info(ArgT0 && arg0,ArgT...args)5475 void StorageRequestMessage_NewStorageMessage::set_flag_info(ArgT0&& arg0, ArgT... args) {
5476 _impl_._has_bits_[0] |= 0x00000010u;
5477 _impl_.flag_info_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
5478 // @@protoc_insertion_point(field_set:android.aconfigd.StorageRequestMessage.NewStorageMessage.flag_info)
5479 }
mutable_flag_info()5480 inline std::string* StorageRequestMessage_NewStorageMessage::mutable_flag_info() {
5481 std::string* _s = _internal_mutable_flag_info();
5482 // @@protoc_insertion_point(field_mutable:android.aconfigd.StorageRequestMessage.NewStorageMessage.flag_info)
5483 return _s;
5484 }
_internal_flag_info()5485 inline const std::string& StorageRequestMessage_NewStorageMessage::_internal_flag_info() const {
5486 return _impl_.flag_info_.Get();
5487 }
_internal_set_flag_info(const std::string & value)5488 inline void StorageRequestMessage_NewStorageMessage::_internal_set_flag_info(const std::string& value) {
5489 _impl_._has_bits_[0] |= 0x00000010u;
5490 _impl_.flag_info_.Set(value, GetArenaForAllocation());
5491 }
_internal_mutable_flag_info()5492 inline std::string* StorageRequestMessage_NewStorageMessage::_internal_mutable_flag_info() {
5493 _impl_._has_bits_[0] |= 0x00000010u;
5494 return _impl_.flag_info_.Mutable(GetArenaForAllocation());
5495 }
release_flag_info()5496 inline std::string* StorageRequestMessage_NewStorageMessage::release_flag_info() {
5497 // @@protoc_insertion_point(field_release:android.aconfigd.StorageRequestMessage.NewStorageMessage.flag_info)
5498 if (!_internal_has_flag_info()) {
5499 return nullptr;
5500 }
5501 _impl_._has_bits_[0] &= ~0x00000010u;
5502 auto* p = _impl_.flag_info_.Release();
5503 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
5504 if (_impl_.flag_info_.IsDefault()) {
5505 _impl_.flag_info_.Set("", GetArenaForAllocation());
5506 }
5507 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
5508 return p;
5509 }
set_allocated_flag_info(std::string * flag_info)5510 inline void StorageRequestMessage_NewStorageMessage::set_allocated_flag_info(std::string* flag_info) {
5511 if (flag_info != nullptr) {
5512 _impl_._has_bits_[0] |= 0x00000010u;
5513 } else {
5514 _impl_._has_bits_[0] &= ~0x00000010u;
5515 }
5516 _impl_.flag_info_.SetAllocated(flag_info, GetArenaForAllocation());
5517 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
5518 if (_impl_.flag_info_.IsDefault()) {
5519 _impl_.flag_info_.Set("", GetArenaForAllocation());
5520 }
5521 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
5522 // @@protoc_insertion_point(field_set_allocated:android.aconfigd.StorageRequestMessage.NewStorageMessage.flag_info)
5523 }
5524
5525 // -------------------------------------------------------------------
5526
5527 // StorageRequestMessage_FlagOverrideMessage
5528
5529 // optional string package_name = 1;
_internal_has_package_name()5530 inline bool StorageRequestMessage_FlagOverrideMessage::_internal_has_package_name() const {
5531 bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
5532 return value;
5533 }
has_package_name()5534 inline bool StorageRequestMessage_FlagOverrideMessage::has_package_name() const {
5535 return _internal_has_package_name();
5536 }
clear_package_name()5537 inline void StorageRequestMessage_FlagOverrideMessage::clear_package_name() {
5538 _impl_.package_name_.ClearToEmpty();
5539 _impl_._has_bits_[0] &= ~0x00000001u;
5540 }
package_name()5541 inline const std::string& StorageRequestMessage_FlagOverrideMessage::package_name() const {
5542 // @@protoc_insertion_point(field_get:android.aconfigd.StorageRequestMessage.FlagOverrideMessage.package_name)
5543 return _internal_package_name();
5544 }
5545 template <typename ArgT0, typename... ArgT>
5546 inline PROTOBUF_ALWAYS_INLINE
set_package_name(ArgT0 && arg0,ArgT...args)5547 void StorageRequestMessage_FlagOverrideMessage::set_package_name(ArgT0&& arg0, ArgT... args) {
5548 _impl_._has_bits_[0] |= 0x00000001u;
5549 _impl_.package_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
5550 // @@protoc_insertion_point(field_set:android.aconfigd.StorageRequestMessage.FlagOverrideMessage.package_name)
5551 }
mutable_package_name()5552 inline std::string* StorageRequestMessage_FlagOverrideMessage::mutable_package_name() {
5553 std::string* _s = _internal_mutable_package_name();
5554 // @@protoc_insertion_point(field_mutable:android.aconfigd.StorageRequestMessage.FlagOverrideMessage.package_name)
5555 return _s;
5556 }
_internal_package_name()5557 inline const std::string& StorageRequestMessage_FlagOverrideMessage::_internal_package_name() const {
5558 return _impl_.package_name_.Get();
5559 }
_internal_set_package_name(const std::string & value)5560 inline void StorageRequestMessage_FlagOverrideMessage::_internal_set_package_name(const std::string& value) {
5561 _impl_._has_bits_[0] |= 0x00000001u;
5562 _impl_.package_name_.Set(value, GetArenaForAllocation());
5563 }
_internal_mutable_package_name()5564 inline std::string* StorageRequestMessage_FlagOverrideMessage::_internal_mutable_package_name() {
5565 _impl_._has_bits_[0] |= 0x00000001u;
5566 return _impl_.package_name_.Mutable(GetArenaForAllocation());
5567 }
release_package_name()5568 inline std::string* StorageRequestMessage_FlagOverrideMessage::release_package_name() {
5569 // @@protoc_insertion_point(field_release:android.aconfigd.StorageRequestMessage.FlagOverrideMessage.package_name)
5570 if (!_internal_has_package_name()) {
5571 return nullptr;
5572 }
5573 _impl_._has_bits_[0] &= ~0x00000001u;
5574 auto* p = _impl_.package_name_.Release();
5575 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
5576 if (_impl_.package_name_.IsDefault()) {
5577 _impl_.package_name_.Set("", GetArenaForAllocation());
5578 }
5579 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
5580 return p;
5581 }
set_allocated_package_name(std::string * package_name)5582 inline void StorageRequestMessage_FlagOverrideMessage::set_allocated_package_name(std::string* package_name) {
5583 if (package_name != nullptr) {
5584 _impl_._has_bits_[0] |= 0x00000001u;
5585 } else {
5586 _impl_._has_bits_[0] &= ~0x00000001u;
5587 }
5588 _impl_.package_name_.SetAllocated(package_name, GetArenaForAllocation());
5589 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
5590 if (_impl_.package_name_.IsDefault()) {
5591 _impl_.package_name_.Set("", GetArenaForAllocation());
5592 }
5593 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
5594 // @@protoc_insertion_point(field_set_allocated:android.aconfigd.StorageRequestMessage.FlagOverrideMessage.package_name)
5595 }
5596
5597 // optional string flag_name = 2;
_internal_has_flag_name()5598 inline bool StorageRequestMessage_FlagOverrideMessage::_internal_has_flag_name() const {
5599 bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
5600 return value;
5601 }
has_flag_name()5602 inline bool StorageRequestMessage_FlagOverrideMessage::has_flag_name() const {
5603 return _internal_has_flag_name();
5604 }
clear_flag_name()5605 inline void StorageRequestMessage_FlagOverrideMessage::clear_flag_name() {
5606 _impl_.flag_name_.ClearToEmpty();
5607 _impl_._has_bits_[0] &= ~0x00000002u;
5608 }
flag_name()5609 inline const std::string& StorageRequestMessage_FlagOverrideMessage::flag_name() const {
5610 // @@protoc_insertion_point(field_get:android.aconfigd.StorageRequestMessage.FlagOverrideMessage.flag_name)
5611 return _internal_flag_name();
5612 }
5613 template <typename ArgT0, typename... ArgT>
5614 inline PROTOBUF_ALWAYS_INLINE
set_flag_name(ArgT0 && arg0,ArgT...args)5615 void StorageRequestMessage_FlagOverrideMessage::set_flag_name(ArgT0&& arg0, ArgT... args) {
5616 _impl_._has_bits_[0] |= 0x00000002u;
5617 _impl_.flag_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
5618 // @@protoc_insertion_point(field_set:android.aconfigd.StorageRequestMessage.FlagOverrideMessage.flag_name)
5619 }
mutable_flag_name()5620 inline std::string* StorageRequestMessage_FlagOverrideMessage::mutable_flag_name() {
5621 std::string* _s = _internal_mutable_flag_name();
5622 // @@protoc_insertion_point(field_mutable:android.aconfigd.StorageRequestMessage.FlagOverrideMessage.flag_name)
5623 return _s;
5624 }
_internal_flag_name()5625 inline const std::string& StorageRequestMessage_FlagOverrideMessage::_internal_flag_name() const {
5626 return _impl_.flag_name_.Get();
5627 }
_internal_set_flag_name(const std::string & value)5628 inline void StorageRequestMessage_FlagOverrideMessage::_internal_set_flag_name(const std::string& value) {
5629 _impl_._has_bits_[0] |= 0x00000002u;
5630 _impl_.flag_name_.Set(value, GetArenaForAllocation());
5631 }
_internal_mutable_flag_name()5632 inline std::string* StorageRequestMessage_FlagOverrideMessage::_internal_mutable_flag_name() {
5633 _impl_._has_bits_[0] |= 0x00000002u;
5634 return _impl_.flag_name_.Mutable(GetArenaForAllocation());
5635 }
release_flag_name()5636 inline std::string* StorageRequestMessage_FlagOverrideMessage::release_flag_name() {
5637 // @@protoc_insertion_point(field_release:android.aconfigd.StorageRequestMessage.FlagOverrideMessage.flag_name)
5638 if (!_internal_has_flag_name()) {
5639 return nullptr;
5640 }
5641 _impl_._has_bits_[0] &= ~0x00000002u;
5642 auto* p = _impl_.flag_name_.Release();
5643 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
5644 if (_impl_.flag_name_.IsDefault()) {
5645 _impl_.flag_name_.Set("", GetArenaForAllocation());
5646 }
5647 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
5648 return p;
5649 }
set_allocated_flag_name(std::string * flag_name)5650 inline void StorageRequestMessage_FlagOverrideMessage::set_allocated_flag_name(std::string* flag_name) {
5651 if (flag_name != nullptr) {
5652 _impl_._has_bits_[0] |= 0x00000002u;
5653 } else {
5654 _impl_._has_bits_[0] &= ~0x00000002u;
5655 }
5656 _impl_.flag_name_.SetAllocated(flag_name, GetArenaForAllocation());
5657 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
5658 if (_impl_.flag_name_.IsDefault()) {
5659 _impl_.flag_name_.Set("", GetArenaForAllocation());
5660 }
5661 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
5662 // @@protoc_insertion_point(field_set_allocated:android.aconfigd.StorageRequestMessage.FlagOverrideMessage.flag_name)
5663 }
5664
5665 // optional string flag_value = 3;
_internal_has_flag_value()5666 inline bool StorageRequestMessage_FlagOverrideMessage::_internal_has_flag_value() const {
5667 bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
5668 return value;
5669 }
has_flag_value()5670 inline bool StorageRequestMessage_FlagOverrideMessage::has_flag_value() const {
5671 return _internal_has_flag_value();
5672 }
clear_flag_value()5673 inline void StorageRequestMessage_FlagOverrideMessage::clear_flag_value() {
5674 _impl_.flag_value_.ClearToEmpty();
5675 _impl_._has_bits_[0] &= ~0x00000004u;
5676 }
flag_value()5677 inline const std::string& StorageRequestMessage_FlagOverrideMessage::flag_value() const {
5678 // @@protoc_insertion_point(field_get:android.aconfigd.StorageRequestMessage.FlagOverrideMessage.flag_value)
5679 return _internal_flag_value();
5680 }
5681 template <typename ArgT0, typename... ArgT>
5682 inline PROTOBUF_ALWAYS_INLINE
set_flag_value(ArgT0 && arg0,ArgT...args)5683 void StorageRequestMessage_FlagOverrideMessage::set_flag_value(ArgT0&& arg0, ArgT... args) {
5684 _impl_._has_bits_[0] |= 0x00000004u;
5685 _impl_.flag_value_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
5686 // @@protoc_insertion_point(field_set:android.aconfigd.StorageRequestMessage.FlagOverrideMessage.flag_value)
5687 }
mutable_flag_value()5688 inline std::string* StorageRequestMessage_FlagOverrideMessage::mutable_flag_value() {
5689 std::string* _s = _internal_mutable_flag_value();
5690 // @@protoc_insertion_point(field_mutable:android.aconfigd.StorageRequestMessage.FlagOverrideMessage.flag_value)
5691 return _s;
5692 }
_internal_flag_value()5693 inline const std::string& StorageRequestMessage_FlagOverrideMessage::_internal_flag_value() const {
5694 return _impl_.flag_value_.Get();
5695 }
_internal_set_flag_value(const std::string & value)5696 inline void StorageRequestMessage_FlagOverrideMessage::_internal_set_flag_value(const std::string& value) {
5697 _impl_._has_bits_[0] |= 0x00000004u;
5698 _impl_.flag_value_.Set(value, GetArenaForAllocation());
5699 }
_internal_mutable_flag_value()5700 inline std::string* StorageRequestMessage_FlagOverrideMessage::_internal_mutable_flag_value() {
5701 _impl_._has_bits_[0] |= 0x00000004u;
5702 return _impl_.flag_value_.Mutable(GetArenaForAllocation());
5703 }
release_flag_value()5704 inline std::string* StorageRequestMessage_FlagOverrideMessage::release_flag_value() {
5705 // @@protoc_insertion_point(field_release:android.aconfigd.StorageRequestMessage.FlagOverrideMessage.flag_value)
5706 if (!_internal_has_flag_value()) {
5707 return nullptr;
5708 }
5709 _impl_._has_bits_[0] &= ~0x00000004u;
5710 auto* p = _impl_.flag_value_.Release();
5711 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
5712 if (_impl_.flag_value_.IsDefault()) {
5713 _impl_.flag_value_.Set("", GetArenaForAllocation());
5714 }
5715 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
5716 return p;
5717 }
set_allocated_flag_value(std::string * flag_value)5718 inline void StorageRequestMessage_FlagOverrideMessage::set_allocated_flag_value(std::string* flag_value) {
5719 if (flag_value != nullptr) {
5720 _impl_._has_bits_[0] |= 0x00000004u;
5721 } else {
5722 _impl_._has_bits_[0] &= ~0x00000004u;
5723 }
5724 _impl_.flag_value_.SetAllocated(flag_value, GetArenaForAllocation());
5725 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
5726 if (_impl_.flag_value_.IsDefault()) {
5727 _impl_.flag_value_.Set("", GetArenaForAllocation());
5728 }
5729 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
5730 // @@protoc_insertion_point(field_set_allocated:android.aconfigd.StorageRequestMessage.FlagOverrideMessage.flag_value)
5731 }
5732
5733 // optional .android.aconfigd.StorageRequestMessage.FlagOverrideType override_type = 4;
_internal_has_override_type()5734 inline bool StorageRequestMessage_FlagOverrideMessage::_internal_has_override_type() const {
5735 bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
5736 return value;
5737 }
has_override_type()5738 inline bool StorageRequestMessage_FlagOverrideMessage::has_override_type() const {
5739 return _internal_has_override_type();
5740 }
clear_override_type()5741 inline void StorageRequestMessage_FlagOverrideMessage::clear_override_type() {
5742 _impl_.override_type_ = 1;
5743 _impl_._has_bits_[0] &= ~0x00000008u;
5744 }
_internal_override_type()5745 inline ::android::aconfigd::StorageRequestMessage_FlagOverrideType StorageRequestMessage_FlagOverrideMessage::_internal_override_type() const {
5746 return static_cast< ::android::aconfigd::StorageRequestMessage_FlagOverrideType >(_impl_.override_type_);
5747 }
override_type()5748 inline ::android::aconfigd::StorageRequestMessage_FlagOverrideType StorageRequestMessage_FlagOverrideMessage::override_type() const {
5749 // @@protoc_insertion_point(field_get:android.aconfigd.StorageRequestMessage.FlagOverrideMessage.override_type)
5750 return _internal_override_type();
5751 }
_internal_set_override_type(::android::aconfigd::StorageRequestMessage_FlagOverrideType value)5752 inline void StorageRequestMessage_FlagOverrideMessage::_internal_set_override_type(::android::aconfigd::StorageRequestMessage_FlagOverrideType value) {
5753 assert(::android::aconfigd::StorageRequestMessage_FlagOverrideType_IsValid(value));
5754 _impl_._has_bits_[0] |= 0x00000008u;
5755 _impl_.override_type_ = value;
5756 }
set_override_type(::android::aconfigd::StorageRequestMessage_FlagOverrideType value)5757 inline void StorageRequestMessage_FlagOverrideMessage::set_override_type(::android::aconfigd::StorageRequestMessage_FlagOverrideType value) {
5758 _internal_set_override_type(value);
5759 // @@protoc_insertion_point(field_set:android.aconfigd.StorageRequestMessage.FlagOverrideMessage.override_type)
5760 }
5761
5762 // -------------------------------------------------------------------
5763
5764 // StorageRequestMessage_OTAFlagStagingMessage
5765
5766 // optional string build_id = 1;
_internal_has_build_id()5767 inline bool StorageRequestMessage_OTAFlagStagingMessage::_internal_has_build_id() const {
5768 bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
5769 return value;
5770 }
has_build_id()5771 inline bool StorageRequestMessage_OTAFlagStagingMessage::has_build_id() const {
5772 return _internal_has_build_id();
5773 }
clear_build_id()5774 inline void StorageRequestMessage_OTAFlagStagingMessage::clear_build_id() {
5775 _impl_.build_id_.ClearToEmpty();
5776 _impl_._has_bits_[0] &= ~0x00000001u;
5777 }
build_id()5778 inline const std::string& StorageRequestMessage_OTAFlagStagingMessage::build_id() const {
5779 // @@protoc_insertion_point(field_get:android.aconfigd.StorageRequestMessage.OTAFlagStagingMessage.build_id)
5780 return _internal_build_id();
5781 }
5782 template <typename ArgT0, typename... ArgT>
5783 inline PROTOBUF_ALWAYS_INLINE
set_build_id(ArgT0 && arg0,ArgT...args)5784 void StorageRequestMessage_OTAFlagStagingMessage::set_build_id(ArgT0&& arg0, ArgT... args) {
5785 _impl_._has_bits_[0] |= 0x00000001u;
5786 _impl_.build_id_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
5787 // @@protoc_insertion_point(field_set:android.aconfigd.StorageRequestMessage.OTAFlagStagingMessage.build_id)
5788 }
mutable_build_id()5789 inline std::string* StorageRequestMessage_OTAFlagStagingMessage::mutable_build_id() {
5790 std::string* _s = _internal_mutable_build_id();
5791 // @@protoc_insertion_point(field_mutable:android.aconfigd.StorageRequestMessage.OTAFlagStagingMessage.build_id)
5792 return _s;
5793 }
_internal_build_id()5794 inline const std::string& StorageRequestMessage_OTAFlagStagingMessage::_internal_build_id() const {
5795 return _impl_.build_id_.Get();
5796 }
_internal_set_build_id(const std::string & value)5797 inline void StorageRequestMessage_OTAFlagStagingMessage::_internal_set_build_id(const std::string& value) {
5798 _impl_._has_bits_[0] |= 0x00000001u;
5799 _impl_.build_id_.Set(value, GetArenaForAllocation());
5800 }
_internal_mutable_build_id()5801