1 // Generated by the protocol buffer compiler. DO NOT EDIT!
2 // source: system/core/storaged/storaged.proto
3
4 #ifndef GOOGLE_PROTOBUF_INCLUDED_system_2fcore_2fstoraged_2fstoraged_2eproto
5 #define GOOGLE_PROTOBUF_INCLUDED_system_2fcore_2fstoraged_2fstoraged_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 // @@protoc_insertion_point(includes)
33 #include <google/protobuf/port_def.inc>
34 #define PROTOBUF_INTERNAL_EXPORT_system_2fcore_2fstoraged_2fstoraged_2eproto
35 PROTOBUF_NAMESPACE_OPEN
36 namespace internal {
37 class AnyMetadata;
38 } // namespace internal
39 PROTOBUF_NAMESPACE_CLOSE
40
41 // Internal implementation detail -- do not use these members.
42 struct TableStruct_system_2fcore_2fstoraged_2fstoraged_2eproto {
43 static const ::uint32_t offsets[];
44 };
45 namespace storaged_proto {
46 class IOPerfHistory;
47 struct IOPerfHistoryDefaultTypeInternal;
48 extern IOPerfHistoryDefaultTypeInternal _IOPerfHistory_default_instance_;
49 class IOUsage;
50 struct IOUsageDefaultTypeInternal;
51 extern IOUsageDefaultTypeInternal _IOUsage_default_instance_;
52 class StoragedProto;
53 struct StoragedProtoDefaultTypeInternal;
54 extern StoragedProtoDefaultTypeInternal _StoragedProto_default_instance_;
55 class TaskIOUsage;
56 struct TaskIOUsageDefaultTypeInternal;
57 extern TaskIOUsageDefaultTypeInternal _TaskIOUsage_default_instance_;
58 class UidIOItem;
59 struct UidIOItemDefaultTypeInternal;
60 extern UidIOItemDefaultTypeInternal _UidIOItem_default_instance_;
61 class UidIORecords;
62 struct UidIORecordsDefaultTypeInternal;
63 extern UidIORecordsDefaultTypeInternal _UidIORecords_default_instance_;
64 class UidIOUsage;
65 struct UidIOUsageDefaultTypeInternal;
66 extern UidIOUsageDefaultTypeInternal _UidIOUsage_default_instance_;
67 class UidRecord;
68 struct UidRecordDefaultTypeInternal;
69 extern UidRecordDefaultTypeInternal _UidRecord_default_instance_;
70 } // namespace storaged_proto
71 PROTOBUF_NAMESPACE_OPEN
72 template<> ::storaged_proto::IOPerfHistory* Arena::CreateMaybeMessage<::storaged_proto::IOPerfHistory>(Arena*);
73 template<> ::storaged_proto::IOUsage* Arena::CreateMaybeMessage<::storaged_proto::IOUsage>(Arena*);
74 template<> ::storaged_proto::StoragedProto* Arena::CreateMaybeMessage<::storaged_proto::StoragedProto>(Arena*);
75 template<> ::storaged_proto::TaskIOUsage* Arena::CreateMaybeMessage<::storaged_proto::TaskIOUsage>(Arena*);
76 template<> ::storaged_proto::UidIOItem* Arena::CreateMaybeMessage<::storaged_proto::UidIOItem>(Arena*);
77 template<> ::storaged_proto::UidIORecords* Arena::CreateMaybeMessage<::storaged_proto::UidIORecords>(Arena*);
78 template<> ::storaged_proto::UidIOUsage* Arena::CreateMaybeMessage<::storaged_proto::UidIOUsage>(Arena*);
79 template<> ::storaged_proto::UidRecord* Arena::CreateMaybeMessage<::storaged_proto::UidRecord>(Arena*);
80 PROTOBUF_NAMESPACE_CLOSE
81 namespace storaged_proto {
82
83 // ===================================================================
84
85 class IOUsage final :
86 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:storaged_proto.IOUsage) */ {
87 public:
IOUsage()88 inline IOUsage() : IOUsage(nullptr) {}
89 ~IOUsage() override;
90 explicit PROTOBUF_CONSTEXPR IOUsage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
91
92 IOUsage(const IOUsage& from);
IOUsage(IOUsage && from)93 IOUsage(IOUsage&& from) noexcept
94 : IOUsage() {
95 *this = ::std::move(from);
96 }
97
98 inline IOUsage& operator=(const IOUsage& from) {
99 if (this == &from) return *this;
100 CopyFrom(from);
101 return *this;
102 }
103 inline IOUsage& operator=(IOUsage&& from) noexcept {
104 if (this == &from) return *this;
105 if (GetOwningArena() == from.GetOwningArena()
106 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
107 && GetOwningArena() != nullptr
108 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
109 ) {
110 InternalSwap(&from);
111 } else {
112 CopyFrom(from);
113 }
114 return *this;
115 }
116
unknown_fields()117 inline const std::string& unknown_fields() const {
118 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
119 }
mutable_unknown_fields()120 inline std::string* mutable_unknown_fields() {
121 return _internal_metadata_.mutable_unknown_fields<std::string>();
122 }
123
default_instance()124 static const IOUsage& default_instance() {
125 return *internal_default_instance();
126 }
internal_default_instance()127 static inline const IOUsage* internal_default_instance() {
128 return reinterpret_cast<const IOUsage*>(
129 &_IOUsage_default_instance_);
130 }
131 static constexpr int kIndexInFileMessages =
132 0;
133
swap(IOUsage & a,IOUsage & b)134 friend void swap(IOUsage& a, IOUsage& b) {
135 a.Swap(&b);
136 }
Swap(IOUsage * other)137 inline void Swap(IOUsage* other) {
138 if (other == this) return;
139 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
140 if (GetOwningArena() != nullptr &&
141 GetOwningArena() == other->GetOwningArena()) {
142 #else // PROTOBUF_FORCE_COPY_IN_SWAP
143 if (GetOwningArena() == other->GetOwningArena()) {
144 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
145 InternalSwap(other);
146 } else {
147 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
148 }
149 }
150 void UnsafeArenaSwap(IOUsage* other) {
151 if (other == this) return;
152 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
153 InternalSwap(other);
154 }
155
156 // implements Message ----------------------------------------------
157
158 IOUsage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
159 return CreateMaybeMessage<IOUsage>(arena);
160 }
161 IOUsage* New() const {
162 return New(nullptr);
163 }
164 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
165 void CopyFrom(const IOUsage& from);
166 void MergeFrom(const IOUsage& from);
167 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
168 bool IsInitialized() const final;
169
170 size_t ByteSizeLong() const final;
171 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
172 ::uint8_t* _InternalSerialize(
173 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
174 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
175
176 private:
177 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
178 void SharedDtor();
179 void SetCachedSize(int size) const;
180 void InternalSwap(IOUsage* other);
181
182 private:
183 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
184 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
185 return "storaged_proto.IOUsage";
186 }
187 protected:
188 explicit IOUsage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
189 bool is_message_owned = false);
190 public:
191
192 std::string GetTypeName() const final;
193
194 // nested types ----------------------------------------------------
195
196 // accessors -------------------------------------------------------
197
198 enum : int {
199 kRdFgChgOnFieldNumber = 1,
200 kRdFgChgOffFieldNumber = 2,
201 kRdBgChgOnFieldNumber = 3,
202 kRdBgChgOffFieldNumber = 4,
203 kWrFgChgOnFieldNumber = 5,
204 kWrFgChgOffFieldNumber = 6,
205 kWrBgChgOnFieldNumber = 7,
206 kWrBgChgOffFieldNumber = 8,
207 };
208 // optional uint64 rd_fg_chg_on = 1;
209 bool has_rd_fg_chg_on() const;
210 private:
211 bool _internal_has_rd_fg_chg_on() const;
212 public:
213 void clear_rd_fg_chg_on();
214 ::uint64_t rd_fg_chg_on() const;
215 void set_rd_fg_chg_on(::uint64_t value);
216 private:
217 ::uint64_t _internal_rd_fg_chg_on() const;
218 void _internal_set_rd_fg_chg_on(::uint64_t value);
219 public:
220
221 // optional uint64 rd_fg_chg_off = 2;
222 bool has_rd_fg_chg_off() const;
223 private:
224 bool _internal_has_rd_fg_chg_off() const;
225 public:
226 void clear_rd_fg_chg_off();
227 ::uint64_t rd_fg_chg_off() const;
228 void set_rd_fg_chg_off(::uint64_t value);
229 private:
230 ::uint64_t _internal_rd_fg_chg_off() const;
231 void _internal_set_rd_fg_chg_off(::uint64_t value);
232 public:
233
234 // optional uint64 rd_bg_chg_on = 3;
235 bool has_rd_bg_chg_on() const;
236 private:
237 bool _internal_has_rd_bg_chg_on() const;
238 public:
239 void clear_rd_bg_chg_on();
240 ::uint64_t rd_bg_chg_on() const;
241 void set_rd_bg_chg_on(::uint64_t value);
242 private:
243 ::uint64_t _internal_rd_bg_chg_on() const;
244 void _internal_set_rd_bg_chg_on(::uint64_t value);
245 public:
246
247 // optional uint64 rd_bg_chg_off = 4;
248 bool has_rd_bg_chg_off() const;
249 private:
250 bool _internal_has_rd_bg_chg_off() const;
251 public:
252 void clear_rd_bg_chg_off();
253 ::uint64_t rd_bg_chg_off() const;
254 void set_rd_bg_chg_off(::uint64_t value);
255 private:
256 ::uint64_t _internal_rd_bg_chg_off() const;
257 void _internal_set_rd_bg_chg_off(::uint64_t value);
258 public:
259
260 // optional uint64 wr_fg_chg_on = 5;
261 bool has_wr_fg_chg_on() const;
262 private:
263 bool _internal_has_wr_fg_chg_on() const;
264 public:
265 void clear_wr_fg_chg_on();
266 ::uint64_t wr_fg_chg_on() const;
267 void set_wr_fg_chg_on(::uint64_t value);
268 private:
269 ::uint64_t _internal_wr_fg_chg_on() const;
270 void _internal_set_wr_fg_chg_on(::uint64_t value);
271 public:
272
273 // optional uint64 wr_fg_chg_off = 6;
274 bool has_wr_fg_chg_off() const;
275 private:
276 bool _internal_has_wr_fg_chg_off() const;
277 public:
278 void clear_wr_fg_chg_off();
279 ::uint64_t wr_fg_chg_off() const;
280 void set_wr_fg_chg_off(::uint64_t value);
281 private:
282 ::uint64_t _internal_wr_fg_chg_off() const;
283 void _internal_set_wr_fg_chg_off(::uint64_t value);
284 public:
285
286 // optional uint64 wr_bg_chg_on = 7;
287 bool has_wr_bg_chg_on() const;
288 private:
289 bool _internal_has_wr_bg_chg_on() const;
290 public:
291 void clear_wr_bg_chg_on();
292 ::uint64_t wr_bg_chg_on() const;
293 void set_wr_bg_chg_on(::uint64_t value);
294 private:
295 ::uint64_t _internal_wr_bg_chg_on() const;
296 void _internal_set_wr_bg_chg_on(::uint64_t value);
297 public:
298
299 // optional uint64 wr_bg_chg_off = 8;
300 bool has_wr_bg_chg_off() const;
301 private:
302 bool _internal_has_wr_bg_chg_off() const;
303 public:
304 void clear_wr_bg_chg_off();
305 ::uint64_t wr_bg_chg_off() const;
306 void set_wr_bg_chg_off(::uint64_t value);
307 private:
308 ::uint64_t _internal_wr_bg_chg_off() const;
309 void _internal_set_wr_bg_chg_off(::uint64_t value);
310 public:
311
312 // @@protoc_insertion_point(class_scope:storaged_proto.IOUsage)
313 private:
314 class _Internal;
315
316 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
317 typedef void InternalArenaConstructable_;
318 typedef void DestructorSkippable_;
319 struct Impl_ {
320 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
321 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
322 ::uint64_t rd_fg_chg_on_;
323 ::uint64_t rd_fg_chg_off_;
324 ::uint64_t rd_bg_chg_on_;
325 ::uint64_t rd_bg_chg_off_;
326 ::uint64_t wr_fg_chg_on_;
327 ::uint64_t wr_fg_chg_off_;
328 ::uint64_t wr_bg_chg_on_;
329 ::uint64_t wr_bg_chg_off_;
330 };
331 union { Impl_ _impl_; };
332 friend struct ::TableStruct_system_2fcore_2fstoraged_2fstoraged_2eproto;
333 };
334 // -------------------------------------------------------------------
335
336 class TaskIOUsage final :
337 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:storaged_proto.TaskIOUsage) */ {
338 public:
TaskIOUsage()339 inline TaskIOUsage() : TaskIOUsage(nullptr) {}
340 ~TaskIOUsage() override;
341 explicit PROTOBUF_CONSTEXPR TaskIOUsage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
342
343 TaskIOUsage(const TaskIOUsage& from);
TaskIOUsage(TaskIOUsage && from)344 TaskIOUsage(TaskIOUsage&& from) noexcept
345 : TaskIOUsage() {
346 *this = ::std::move(from);
347 }
348
349 inline TaskIOUsage& operator=(const TaskIOUsage& from) {
350 if (this == &from) return *this;
351 CopyFrom(from);
352 return *this;
353 }
354 inline TaskIOUsage& operator=(TaskIOUsage&& from) noexcept {
355 if (this == &from) return *this;
356 if (GetOwningArena() == from.GetOwningArena()
357 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
358 && GetOwningArena() != nullptr
359 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
360 ) {
361 InternalSwap(&from);
362 } else {
363 CopyFrom(from);
364 }
365 return *this;
366 }
367
unknown_fields()368 inline const std::string& unknown_fields() const {
369 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
370 }
mutable_unknown_fields()371 inline std::string* mutable_unknown_fields() {
372 return _internal_metadata_.mutable_unknown_fields<std::string>();
373 }
374
default_instance()375 static const TaskIOUsage& default_instance() {
376 return *internal_default_instance();
377 }
internal_default_instance()378 static inline const TaskIOUsage* internal_default_instance() {
379 return reinterpret_cast<const TaskIOUsage*>(
380 &_TaskIOUsage_default_instance_);
381 }
382 static constexpr int kIndexInFileMessages =
383 1;
384
swap(TaskIOUsage & a,TaskIOUsage & b)385 friend void swap(TaskIOUsage& a, TaskIOUsage& b) {
386 a.Swap(&b);
387 }
Swap(TaskIOUsage * other)388 inline void Swap(TaskIOUsage* other) {
389 if (other == this) return;
390 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
391 if (GetOwningArena() != nullptr &&
392 GetOwningArena() == other->GetOwningArena()) {
393 #else // PROTOBUF_FORCE_COPY_IN_SWAP
394 if (GetOwningArena() == other->GetOwningArena()) {
395 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
396 InternalSwap(other);
397 } else {
398 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
399 }
400 }
401 void UnsafeArenaSwap(TaskIOUsage* other) {
402 if (other == this) return;
403 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
404 InternalSwap(other);
405 }
406
407 // implements Message ----------------------------------------------
408
409 TaskIOUsage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
410 return CreateMaybeMessage<TaskIOUsage>(arena);
411 }
412 TaskIOUsage* New() const {
413 return New(nullptr);
414 }
415 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
416 void CopyFrom(const TaskIOUsage& from);
417 void MergeFrom(const TaskIOUsage& from);
418 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
419 bool IsInitialized() const final;
420
421 size_t ByteSizeLong() const final;
422 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
423 ::uint8_t* _InternalSerialize(
424 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
425 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
426
427 private:
428 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
429 void SharedDtor();
430 void SetCachedSize(int size) const;
431 void InternalSwap(TaskIOUsage* other);
432
433 private:
434 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
435 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
436 return "storaged_proto.TaskIOUsage";
437 }
438 protected:
439 explicit TaskIOUsage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
440 bool is_message_owned = false);
441 public:
442
443 std::string GetTypeName() const final;
444
445 // nested types ----------------------------------------------------
446
447 // accessors -------------------------------------------------------
448
449 enum : int {
450 kTaskNameFieldNumber = 1,
451 kIosFieldNumber = 2,
452 };
453 // optional string task_name = 1;
454 bool has_task_name() const;
455 private:
456 bool _internal_has_task_name() const;
457 public:
458 void clear_task_name();
459 const std::string& task_name() const;
460 template <typename ArgT0 = const std::string&, typename... ArgT>
461 void set_task_name(ArgT0&& arg0, ArgT... args);
462 std::string* mutable_task_name();
463 PROTOBUF_NODISCARD std::string* release_task_name();
464 void set_allocated_task_name(std::string* task_name);
465 private:
466 const std::string& _internal_task_name() const;
467 inline PROTOBUF_ALWAYS_INLINE void _internal_set_task_name(const std::string& value);
468 std::string* _internal_mutable_task_name();
469 public:
470
471 // optional .storaged_proto.IOUsage ios = 2;
472 bool has_ios() const;
473 private:
474 bool _internal_has_ios() const;
475 public:
476 void clear_ios();
477 const ::storaged_proto::IOUsage& ios() const;
478 PROTOBUF_NODISCARD ::storaged_proto::IOUsage* release_ios();
479 ::storaged_proto::IOUsage* mutable_ios();
480 void set_allocated_ios(::storaged_proto::IOUsage* ios);
481 private:
482 const ::storaged_proto::IOUsage& _internal_ios() const;
483 ::storaged_proto::IOUsage* _internal_mutable_ios();
484 public:
485 void unsafe_arena_set_allocated_ios(
486 ::storaged_proto::IOUsage* ios);
487 ::storaged_proto::IOUsage* unsafe_arena_release_ios();
488
489 // @@protoc_insertion_point(class_scope:storaged_proto.TaskIOUsage)
490 private:
491 class _Internal;
492
493 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
494 typedef void InternalArenaConstructable_;
495 typedef void DestructorSkippable_;
496 struct Impl_ {
497 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
498 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
499 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr task_name_;
500 ::storaged_proto::IOUsage* ios_;
501 };
502 union { Impl_ _impl_; };
503 friend struct ::TableStruct_system_2fcore_2fstoraged_2fstoraged_2eproto;
504 };
505 // -------------------------------------------------------------------
506
507 class UidRecord final :
508 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:storaged_proto.UidRecord) */ {
509 public:
UidRecord()510 inline UidRecord() : UidRecord(nullptr) {}
511 ~UidRecord() override;
512 explicit PROTOBUF_CONSTEXPR UidRecord(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
513
514 UidRecord(const UidRecord& from);
UidRecord(UidRecord && from)515 UidRecord(UidRecord&& from) noexcept
516 : UidRecord() {
517 *this = ::std::move(from);
518 }
519
520 inline UidRecord& operator=(const UidRecord& from) {
521 if (this == &from) return *this;
522 CopyFrom(from);
523 return *this;
524 }
525 inline UidRecord& operator=(UidRecord&& from) noexcept {
526 if (this == &from) return *this;
527 if (GetOwningArena() == from.GetOwningArena()
528 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
529 && GetOwningArena() != nullptr
530 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
531 ) {
532 InternalSwap(&from);
533 } else {
534 CopyFrom(from);
535 }
536 return *this;
537 }
538
unknown_fields()539 inline const std::string& unknown_fields() const {
540 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
541 }
mutable_unknown_fields()542 inline std::string* mutable_unknown_fields() {
543 return _internal_metadata_.mutable_unknown_fields<std::string>();
544 }
545
default_instance()546 static const UidRecord& default_instance() {
547 return *internal_default_instance();
548 }
internal_default_instance()549 static inline const UidRecord* internal_default_instance() {
550 return reinterpret_cast<const UidRecord*>(
551 &_UidRecord_default_instance_);
552 }
553 static constexpr int kIndexInFileMessages =
554 2;
555
swap(UidRecord & a,UidRecord & b)556 friend void swap(UidRecord& a, UidRecord& b) {
557 a.Swap(&b);
558 }
Swap(UidRecord * other)559 inline void Swap(UidRecord* other) {
560 if (other == this) return;
561 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
562 if (GetOwningArena() != nullptr &&
563 GetOwningArena() == other->GetOwningArena()) {
564 #else // PROTOBUF_FORCE_COPY_IN_SWAP
565 if (GetOwningArena() == other->GetOwningArena()) {
566 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
567 InternalSwap(other);
568 } else {
569 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
570 }
571 }
572 void UnsafeArenaSwap(UidRecord* other) {
573 if (other == this) return;
574 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
575 InternalSwap(other);
576 }
577
578 // implements Message ----------------------------------------------
579
580 UidRecord* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
581 return CreateMaybeMessage<UidRecord>(arena);
582 }
583 UidRecord* New() const {
584 return New(nullptr);
585 }
586 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
587 void CopyFrom(const UidRecord& from);
588 void MergeFrom(const UidRecord& from);
589 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
590 bool IsInitialized() const final;
591
592 size_t ByteSizeLong() const final;
593 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
594 ::uint8_t* _InternalSerialize(
595 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
596 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
597
598 private:
599 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
600 void SharedDtor();
601 void SetCachedSize(int size) const;
602 void InternalSwap(UidRecord* other);
603
604 private:
605 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
606 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
607 return "storaged_proto.UidRecord";
608 }
609 protected:
610 explicit UidRecord(::PROTOBUF_NAMESPACE_ID::Arena* arena,
611 bool is_message_owned = false);
612 public:
613
614 std::string GetTypeName() const final;
615
616 // nested types ----------------------------------------------------
617
618 // accessors -------------------------------------------------------
619
620 enum : int {
621 kTaskIoFieldNumber = 4,
622 kUidNameFieldNumber = 1,
623 kUidIoFieldNumber = 3,
624 kUserIdFieldNumber = 2,
625 };
626 // repeated .storaged_proto.TaskIOUsage task_io = 4;
627 int task_io_size() const;
628 private:
629 int _internal_task_io_size() const;
630 public:
631 void clear_task_io();
632 ::storaged_proto::TaskIOUsage* mutable_task_io(int index);
633 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::storaged_proto::TaskIOUsage >*
634 mutable_task_io();
635 private:
636 const ::storaged_proto::TaskIOUsage& _internal_task_io(int index) const;
637 ::storaged_proto::TaskIOUsage* _internal_add_task_io();
638 public:
639 const ::storaged_proto::TaskIOUsage& task_io(int index) const;
640 ::storaged_proto::TaskIOUsage* add_task_io();
641 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::storaged_proto::TaskIOUsage >&
642 task_io() const;
643
644 // optional string uid_name = 1;
645 bool has_uid_name() const;
646 private:
647 bool _internal_has_uid_name() const;
648 public:
649 void clear_uid_name();
650 const std::string& uid_name() const;
651 template <typename ArgT0 = const std::string&, typename... ArgT>
652 void set_uid_name(ArgT0&& arg0, ArgT... args);
653 std::string* mutable_uid_name();
654 PROTOBUF_NODISCARD std::string* release_uid_name();
655 void set_allocated_uid_name(std::string* uid_name);
656 private:
657 const std::string& _internal_uid_name() const;
658 inline PROTOBUF_ALWAYS_INLINE void _internal_set_uid_name(const std::string& value);
659 std::string* _internal_mutable_uid_name();
660 public:
661
662 // optional .storaged_proto.IOUsage uid_io = 3;
663 bool has_uid_io() const;
664 private:
665 bool _internal_has_uid_io() const;
666 public:
667 void clear_uid_io();
668 const ::storaged_proto::IOUsage& uid_io() const;
669 PROTOBUF_NODISCARD ::storaged_proto::IOUsage* release_uid_io();
670 ::storaged_proto::IOUsage* mutable_uid_io();
671 void set_allocated_uid_io(::storaged_proto::IOUsage* uid_io);
672 private:
673 const ::storaged_proto::IOUsage& _internal_uid_io() const;
674 ::storaged_proto::IOUsage* _internal_mutable_uid_io();
675 public:
676 void unsafe_arena_set_allocated_uid_io(
677 ::storaged_proto::IOUsage* uid_io);
678 ::storaged_proto::IOUsage* unsafe_arena_release_uid_io();
679
680 // optional uint32 user_id = 2;
681 bool has_user_id() const;
682 private:
683 bool _internal_has_user_id() const;
684 public:
685 void clear_user_id();
686 ::uint32_t user_id() const;
687 void set_user_id(::uint32_t value);
688 private:
689 ::uint32_t _internal_user_id() const;
690 void _internal_set_user_id(::uint32_t value);
691 public:
692
693 // @@protoc_insertion_point(class_scope:storaged_proto.UidRecord)
694 private:
695 class _Internal;
696
697 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
698 typedef void InternalArenaConstructable_;
699 typedef void DestructorSkippable_;
700 struct Impl_ {
701 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
702 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
703 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::storaged_proto::TaskIOUsage > task_io_;
704 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr uid_name_;
705 ::storaged_proto::IOUsage* uid_io_;
706 ::uint32_t user_id_;
707 };
708 union { Impl_ _impl_; };
709 friend struct ::TableStruct_system_2fcore_2fstoraged_2fstoraged_2eproto;
710 };
711 // -------------------------------------------------------------------
712
713 class UidIORecords final :
714 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:storaged_proto.UidIORecords) */ {
715 public:
UidIORecords()716 inline UidIORecords() : UidIORecords(nullptr) {}
717 ~UidIORecords() override;
718 explicit PROTOBUF_CONSTEXPR UidIORecords(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
719
720 UidIORecords(const UidIORecords& from);
UidIORecords(UidIORecords && from)721 UidIORecords(UidIORecords&& from) noexcept
722 : UidIORecords() {
723 *this = ::std::move(from);
724 }
725
726 inline UidIORecords& operator=(const UidIORecords& from) {
727 if (this == &from) return *this;
728 CopyFrom(from);
729 return *this;
730 }
731 inline UidIORecords& operator=(UidIORecords&& from) noexcept {
732 if (this == &from) return *this;
733 if (GetOwningArena() == from.GetOwningArena()
734 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
735 && GetOwningArena() != nullptr
736 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
737 ) {
738 InternalSwap(&from);
739 } else {
740 CopyFrom(from);
741 }
742 return *this;
743 }
744
unknown_fields()745 inline const std::string& unknown_fields() const {
746 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
747 }
mutable_unknown_fields()748 inline std::string* mutable_unknown_fields() {
749 return _internal_metadata_.mutable_unknown_fields<std::string>();
750 }
751
default_instance()752 static const UidIORecords& default_instance() {
753 return *internal_default_instance();
754 }
internal_default_instance()755 static inline const UidIORecords* internal_default_instance() {
756 return reinterpret_cast<const UidIORecords*>(
757 &_UidIORecords_default_instance_);
758 }
759 static constexpr int kIndexInFileMessages =
760 3;
761
swap(UidIORecords & a,UidIORecords & b)762 friend void swap(UidIORecords& a, UidIORecords& b) {
763 a.Swap(&b);
764 }
Swap(UidIORecords * other)765 inline void Swap(UidIORecords* other) {
766 if (other == this) return;
767 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
768 if (GetOwningArena() != nullptr &&
769 GetOwningArena() == other->GetOwningArena()) {
770 #else // PROTOBUF_FORCE_COPY_IN_SWAP
771 if (GetOwningArena() == other->GetOwningArena()) {
772 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
773 InternalSwap(other);
774 } else {
775 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
776 }
777 }
778 void UnsafeArenaSwap(UidIORecords* other) {
779 if (other == this) return;
780 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
781 InternalSwap(other);
782 }
783
784 // implements Message ----------------------------------------------
785
786 UidIORecords* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
787 return CreateMaybeMessage<UidIORecords>(arena);
788 }
789 UidIORecords* New() const {
790 return New(nullptr);
791 }
792 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
793 void CopyFrom(const UidIORecords& from);
794 void MergeFrom(const UidIORecords& from);
795 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
796 bool IsInitialized() const final;
797
798 size_t ByteSizeLong() const final;
799 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
800 ::uint8_t* _InternalSerialize(
801 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
802 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
803
804 private:
805 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
806 void SharedDtor();
807 void SetCachedSize(int size) const;
808 void InternalSwap(UidIORecords* other);
809
810 private:
811 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
812 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
813 return "storaged_proto.UidIORecords";
814 }
815 protected:
816 explicit UidIORecords(::PROTOBUF_NAMESPACE_ID::Arena* arena,
817 bool is_message_owned = false);
818 public:
819
820 std::string GetTypeName() const final;
821
822 // nested types ----------------------------------------------------
823
824 // accessors -------------------------------------------------------
825
826 enum : int {
827 kEntriesFieldNumber = 2,
828 kStartTsFieldNumber = 1,
829 };
830 // repeated .storaged_proto.UidRecord entries = 2;
831 int entries_size() const;
832 private:
833 int _internal_entries_size() const;
834 public:
835 void clear_entries();
836 ::storaged_proto::UidRecord* mutable_entries(int index);
837 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::storaged_proto::UidRecord >*
838 mutable_entries();
839 private:
840 const ::storaged_proto::UidRecord& _internal_entries(int index) const;
841 ::storaged_proto::UidRecord* _internal_add_entries();
842 public:
843 const ::storaged_proto::UidRecord& entries(int index) const;
844 ::storaged_proto::UidRecord* add_entries();
845 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::storaged_proto::UidRecord >&
846 entries() const;
847
848 // optional uint64 start_ts = 1;
849 bool has_start_ts() const;
850 private:
851 bool _internal_has_start_ts() const;
852 public:
853 void clear_start_ts();
854 ::uint64_t start_ts() const;
855 void set_start_ts(::uint64_t value);
856 private:
857 ::uint64_t _internal_start_ts() const;
858 void _internal_set_start_ts(::uint64_t value);
859 public:
860
861 // @@protoc_insertion_point(class_scope:storaged_proto.UidIORecords)
862 private:
863 class _Internal;
864
865 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
866 typedef void InternalArenaConstructable_;
867 typedef void DestructorSkippable_;
868 struct Impl_ {
869 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
870 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
871 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::storaged_proto::UidRecord > entries_;
872 ::uint64_t start_ts_;
873 };
874 union { Impl_ _impl_; };
875 friend struct ::TableStruct_system_2fcore_2fstoraged_2fstoraged_2eproto;
876 };
877 // -------------------------------------------------------------------
878
879 class UidIOItem final :
880 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:storaged_proto.UidIOItem) */ {
881 public:
UidIOItem()882 inline UidIOItem() : UidIOItem(nullptr) {}
883 ~UidIOItem() override;
884 explicit PROTOBUF_CONSTEXPR UidIOItem(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
885
886 UidIOItem(const UidIOItem& from);
UidIOItem(UidIOItem && from)887 UidIOItem(UidIOItem&& from) noexcept
888 : UidIOItem() {
889 *this = ::std::move(from);
890 }
891
892 inline UidIOItem& operator=(const UidIOItem& from) {
893 if (this == &from) return *this;
894 CopyFrom(from);
895 return *this;
896 }
897 inline UidIOItem& operator=(UidIOItem&& from) noexcept {
898 if (this == &from) return *this;
899 if (GetOwningArena() == from.GetOwningArena()
900 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
901 && GetOwningArena() != nullptr
902 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
903 ) {
904 InternalSwap(&from);
905 } else {
906 CopyFrom(from);
907 }
908 return *this;
909 }
910
unknown_fields()911 inline const std::string& unknown_fields() const {
912 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
913 }
mutable_unknown_fields()914 inline std::string* mutable_unknown_fields() {
915 return _internal_metadata_.mutable_unknown_fields<std::string>();
916 }
917
default_instance()918 static const UidIOItem& default_instance() {
919 return *internal_default_instance();
920 }
internal_default_instance()921 static inline const UidIOItem* internal_default_instance() {
922 return reinterpret_cast<const UidIOItem*>(
923 &_UidIOItem_default_instance_);
924 }
925 static constexpr int kIndexInFileMessages =
926 4;
927
swap(UidIOItem & a,UidIOItem & b)928 friend void swap(UidIOItem& a, UidIOItem& b) {
929 a.Swap(&b);
930 }
Swap(UidIOItem * other)931 inline void Swap(UidIOItem* other) {
932 if (other == this) return;
933 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
934 if (GetOwningArena() != nullptr &&
935 GetOwningArena() == other->GetOwningArena()) {
936 #else // PROTOBUF_FORCE_COPY_IN_SWAP
937 if (GetOwningArena() == other->GetOwningArena()) {
938 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
939 InternalSwap(other);
940 } else {
941 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
942 }
943 }
944 void UnsafeArenaSwap(UidIOItem* other) {
945 if (other == this) return;
946 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
947 InternalSwap(other);
948 }
949
950 // implements Message ----------------------------------------------
951
952 UidIOItem* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
953 return CreateMaybeMessage<UidIOItem>(arena);
954 }
955 UidIOItem* New() const {
956 return New(nullptr);
957 }
958 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
959 void CopyFrom(const UidIOItem& from);
960 void MergeFrom(const UidIOItem& from);
961 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
962 bool IsInitialized() const final;
963
964 size_t ByteSizeLong() const final;
965 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
966 ::uint8_t* _InternalSerialize(
967 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
968 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
969
970 private:
971 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
972 void SharedDtor();
973 void SetCachedSize(int size) const;
974 void InternalSwap(UidIOItem* other);
975
976 private:
977 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
978 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
979 return "storaged_proto.UidIOItem";
980 }
981 protected:
982 explicit UidIOItem(::PROTOBUF_NAMESPACE_ID::Arena* arena,
983 bool is_message_owned = false);
984 public:
985
986 std::string GetTypeName() const final;
987
988 // nested types ----------------------------------------------------
989
990 // accessors -------------------------------------------------------
991
992 enum : int {
993 kRecordsFieldNumber = 2,
994 kEndTsFieldNumber = 1,
995 };
996 // optional .storaged_proto.UidIORecords records = 2;
997 bool has_records() const;
998 private:
999 bool _internal_has_records() const;
1000 public:
1001 void clear_records();
1002 const ::storaged_proto::UidIORecords& records() const;
1003 PROTOBUF_NODISCARD ::storaged_proto::UidIORecords* release_records();
1004 ::storaged_proto::UidIORecords* mutable_records();
1005 void set_allocated_records(::storaged_proto::UidIORecords* records);
1006 private:
1007 const ::storaged_proto::UidIORecords& _internal_records() const;
1008 ::storaged_proto::UidIORecords* _internal_mutable_records();
1009 public:
1010 void unsafe_arena_set_allocated_records(
1011 ::storaged_proto::UidIORecords* records);
1012 ::storaged_proto::UidIORecords* unsafe_arena_release_records();
1013
1014 // optional uint64 end_ts = 1;
1015 bool has_end_ts() const;
1016 private:
1017 bool _internal_has_end_ts() const;
1018 public:
1019 void clear_end_ts();
1020 ::uint64_t end_ts() const;
1021 void set_end_ts(::uint64_t value);
1022 private:
1023 ::uint64_t _internal_end_ts() const;
1024 void _internal_set_end_ts(::uint64_t value);
1025 public:
1026
1027 // @@protoc_insertion_point(class_scope:storaged_proto.UidIOItem)
1028 private:
1029 class _Internal;
1030
1031 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1032 typedef void InternalArenaConstructable_;
1033 typedef void DestructorSkippable_;
1034 struct Impl_ {
1035 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
1036 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1037 ::storaged_proto::UidIORecords* records_;
1038 ::uint64_t end_ts_;
1039 };
1040 union { Impl_ _impl_; };
1041 friend struct ::TableStruct_system_2fcore_2fstoraged_2fstoraged_2eproto;
1042 };
1043 // -------------------------------------------------------------------
1044
1045 class UidIOUsage final :
1046 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:storaged_proto.UidIOUsage) */ {
1047 public:
UidIOUsage()1048 inline UidIOUsage() : UidIOUsage(nullptr) {}
1049 ~UidIOUsage() override;
1050 explicit PROTOBUF_CONSTEXPR UidIOUsage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1051
1052 UidIOUsage(const UidIOUsage& from);
UidIOUsage(UidIOUsage && from)1053 UidIOUsage(UidIOUsage&& from) noexcept
1054 : UidIOUsage() {
1055 *this = ::std::move(from);
1056 }
1057
1058 inline UidIOUsage& operator=(const UidIOUsage& from) {
1059 if (this == &from) return *this;
1060 CopyFrom(from);
1061 return *this;
1062 }
1063 inline UidIOUsage& operator=(UidIOUsage&& from) noexcept {
1064 if (this == &from) return *this;
1065 if (GetOwningArena() == from.GetOwningArena()
1066 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1067 && GetOwningArena() != nullptr
1068 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
1069 ) {
1070 InternalSwap(&from);
1071 } else {
1072 CopyFrom(from);
1073 }
1074 return *this;
1075 }
1076
unknown_fields()1077 inline const std::string& unknown_fields() const {
1078 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
1079 }
mutable_unknown_fields()1080 inline std::string* mutable_unknown_fields() {
1081 return _internal_metadata_.mutable_unknown_fields<std::string>();
1082 }
1083
default_instance()1084 static const UidIOUsage& default_instance() {
1085 return *internal_default_instance();
1086 }
internal_default_instance()1087 static inline const UidIOUsage* internal_default_instance() {
1088 return reinterpret_cast<const UidIOUsage*>(
1089 &_UidIOUsage_default_instance_);
1090 }
1091 static constexpr int kIndexInFileMessages =
1092 5;
1093
swap(UidIOUsage & a,UidIOUsage & b)1094 friend void swap(UidIOUsage& a, UidIOUsage& b) {
1095 a.Swap(&b);
1096 }
Swap(UidIOUsage * other)1097 inline void Swap(UidIOUsage* other) {
1098 if (other == this) return;
1099 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1100 if (GetOwningArena() != nullptr &&
1101 GetOwningArena() == other->GetOwningArena()) {
1102 #else // PROTOBUF_FORCE_COPY_IN_SWAP
1103 if (GetOwningArena() == other->GetOwningArena()) {
1104 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
1105 InternalSwap(other);
1106 } else {
1107 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1108 }
1109 }
1110 void UnsafeArenaSwap(UidIOUsage* other) {
1111 if (other == this) return;
1112 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1113 InternalSwap(other);
1114 }
1115
1116 // implements Message ----------------------------------------------
1117
1118 UidIOUsage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1119 return CreateMaybeMessage<UidIOUsage>(arena);
1120 }
1121 UidIOUsage* New() const {
1122 return New(nullptr);
1123 }
1124 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
1125 void CopyFrom(const UidIOUsage& from);
1126 void MergeFrom(const UidIOUsage& from);
1127 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1128 bool IsInitialized() const final;
1129
1130 size_t ByteSizeLong() const final;
1131 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1132 ::uint8_t* _InternalSerialize(
1133 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1134 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1135
1136 private:
1137 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1138 void SharedDtor();
1139 void SetCachedSize(int size) const;
1140 void InternalSwap(UidIOUsage* other);
1141
1142 private:
1143 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1144 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1145 return "storaged_proto.UidIOUsage";
1146 }
1147 protected:
1148 explicit UidIOUsage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1149 bool is_message_owned = false);
1150 public:
1151
1152 std::string GetTypeName() const final;
1153
1154 // nested types ----------------------------------------------------
1155
1156 // accessors -------------------------------------------------------
1157
1158 enum : int {
1159 kUidIoItemsFieldNumber = 2,
1160 };
1161 // repeated .storaged_proto.UidIOItem uid_io_items = 2;
1162 int uid_io_items_size() const;
1163 private:
1164 int _internal_uid_io_items_size() const;
1165 public:
1166 void clear_uid_io_items();
1167 ::storaged_proto::UidIOItem* mutable_uid_io_items(int index);
1168 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::storaged_proto::UidIOItem >*
1169 mutable_uid_io_items();
1170 private:
1171 const ::storaged_proto::UidIOItem& _internal_uid_io_items(int index) const;
1172 ::storaged_proto::UidIOItem* _internal_add_uid_io_items();
1173 public:
1174 const ::storaged_proto::UidIOItem& uid_io_items(int index) const;
1175 ::storaged_proto::UidIOItem* add_uid_io_items();
1176 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::storaged_proto::UidIOItem >&
1177 uid_io_items() const;
1178
1179 // @@protoc_insertion_point(class_scope:storaged_proto.UidIOUsage)
1180 private:
1181 class _Internal;
1182
1183 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1184 typedef void InternalArenaConstructable_;
1185 typedef void DestructorSkippable_;
1186 struct Impl_ {
1187 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::storaged_proto::UidIOItem > uid_io_items_;
1188 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1189 };
1190 union { Impl_ _impl_; };
1191 friend struct ::TableStruct_system_2fcore_2fstoraged_2fstoraged_2eproto;
1192 };
1193 // -------------------------------------------------------------------
1194
1195 class IOPerfHistory final :
1196 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:storaged_proto.IOPerfHistory) */ {
1197 public:
IOPerfHistory()1198 inline IOPerfHistory() : IOPerfHistory(nullptr) {}
1199 ~IOPerfHistory() override;
1200 explicit PROTOBUF_CONSTEXPR IOPerfHistory(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1201
1202 IOPerfHistory(const IOPerfHistory& from);
IOPerfHistory(IOPerfHistory && from)1203 IOPerfHistory(IOPerfHistory&& from) noexcept
1204 : IOPerfHistory() {
1205 *this = ::std::move(from);
1206 }
1207
1208 inline IOPerfHistory& operator=(const IOPerfHistory& from) {
1209 if (this == &from) return *this;
1210 CopyFrom(from);
1211 return *this;
1212 }
1213 inline IOPerfHistory& operator=(IOPerfHistory&& from) noexcept {
1214 if (this == &from) return *this;
1215 if (GetOwningArena() == from.GetOwningArena()
1216 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1217 && GetOwningArena() != nullptr
1218 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
1219 ) {
1220 InternalSwap(&from);
1221 } else {
1222 CopyFrom(from);
1223 }
1224 return *this;
1225 }
1226
unknown_fields()1227 inline const std::string& unknown_fields() const {
1228 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
1229 }
mutable_unknown_fields()1230 inline std::string* mutable_unknown_fields() {
1231 return _internal_metadata_.mutable_unknown_fields<std::string>();
1232 }
1233
default_instance()1234 static const IOPerfHistory& default_instance() {
1235 return *internal_default_instance();
1236 }
internal_default_instance()1237 static inline const IOPerfHistory* internal_default_instance() {
1238 return reinterpret_cast<const IOPerfHistory*>(
1239 &_IOPerfHistory_default_instance_);
1240 }
1241 static constexpr int kIndexInFileMessages =
1242 6;
1243
swap(IOPerfHistory & a,IOPerfHistory & b)1244 friend void swap(IOPerfHistory& a, IOPerfHistory& b) {
1245 a.Swap(&b);
1246 }
Swap(IOPerfHistory * other)1247 inline void Swap(IOPerfHistory* other) {
1248 if (other == this) return;
1249 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1250 if (GetOwningArena() != nullptr &&
1251 GetOwningArena() == other->GetOwningArena()) {
1252 #else // PROTOBUF_FORCE_COPY_IN_SWAP
1253 if (GetOwningArena() == other->GetOwningArena()) {
1254 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
1255 InternalSwap(other);
1256 } else {
1257 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1258 }
1259 }
1260 void UnsafeArenaSwap(IOPerfHistory* other) {
1261 if (other == this) return;
1262 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1263 InternalSwap(other);
1264 }
1265
1266 // implements Message ----------------------------------------------
1267
1268 IOPerfHistory* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1269 return CreateMaybeMessage<IOPerfHistory>(arena);
1270 }
1271 IOPerfHistory* New() const {
1272 return New(nullptr);
1273 }
1274 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
1275 void CopyFrom(const IOPerfHistory& from);
1276 void MergeFrom(const IOPerfHistory& from);
1277 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1278 bool IsInitialized() const final;
1279
1280 size_t ByteSizeLong() const final;
1281 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1282 ::uint8_t* _InternalSerialize(
1283 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1284 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1285
1286 private:
1287 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1288 void SharedDtor();
1289 void SetCachedSize(int size) const;
1290 void InternalSwap(IOPerfHistory* other);
1291
1292 private:
1293 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1294 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1295 return "storaged_proto.IOPerfHistory";
1296 }
1297 protected:
1298 explicit IOPerfHistory(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1299 bool is_message_owned = false);
1300 public:
1301
1302 std::string GetTypeName() const final;
1303
1304 // nested types ----------------------------------------------------
1305
1306 // accessors -------------------------------------------------------
1307
1308 enum : int {
1309 kRecentPerfFieldNumber = 2,
1310 kDailyPerfFieldNumber = 4,
1311 kWeeklyPerfFieldNumber = 6,
1312 kDayStartSecFieldNumber = 1,
1313 kNrSamplesFieldNumber = 3,
1314 kNrDaysFieldNumber = 5,
1315 kNrWeeksFieldNumber = 7,
1316 };
1317 // repeated uint32 recent_perf = 2;
1318 int recent_perf_size() const;
1319 private:
1320 int _internal_recent_perf_size() const;
1321 public:
1322 void clear_recent_perf();
1323 private:
1324 ::uint32_t _internal_recent_perf(int index) const;
1325 const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::uint32_t >&
1326 _internal_recent_perf() const;
1327 void _internal_add_recent_perf(::uint32_t value);
1328 ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::uint32_t >*
1329 _internal_mutable_recent_perf();
1330 public:
1331 ::uint32_t recent_perf(int index) const;
1332 void set_recent_perf(int index, ::uint32_t value);
1333 void add_recent_perf(::uint32_t value);
1334 const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::uint32_t >&
1335 recent_perf() const;
1336 ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::uint32_t >*
1337 mutable_recent_perf();
1338
1339 // repeated uint32 daily_perf = 4;
1340 int daily_perf_size() const;
1341 private:
1342 int _internal_daily_perf_size() const;
1343 public:
1344 void clear_daily_perf();
1345 private:
1346 ::uint32_t _internal_daily_perf(int index) const;
1347 const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::uint32_t >&
1348 _internal_daily_perf() const;
1349 void _internal_add_daily_perf(::uint32_t value);
1350 ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::uint32_t >*
1351 _internal_mutable_daily_perf();
1352 public:
1353 ::uint32_t daily_perf(int index) const;
1354 void set_daily_perf(int index, ::uint32_t value);
1355 void add_daily_perf(::uint32_t value);
1356 const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::uint32_t >&
1357 daily_perf() const;
1358 ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::uint32_t >*
1359 mutable_daily_perf();
1360
1361 // repeated uint32 weekly_perf = 6;
1362 int weekly_perf_size() const;
1363 private:
1364 int _internal_weekly_perf_size() const;
1365 public:
1366 void clear_weekly_perf();
1367 private:
1368 ::uint32_t _internal_weekly_perf(int index) const;
1369 const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::uint32_t >&
1370 _internal_weekly_perf() const;
1371 void _internal_add_weekly_perf(::uint32_t value);
1372 ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::uint32_t >*
1373 _internal_mutable_weekly_perf();
1374 public:
1375 ::uint32_t weekly_perf(int index) const;
1376 void set_weekly_perf(int index, ::uint32_t value);
1377 void add_weekly_perf(::uint32_t value);
1378 const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::uint32_t >&
1379 weekly_perf() const;
1380 ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::uint32_t >*
1381 mutable_weekly_perf();
1382
1383 // optional uint64 day_start_sec = 1;
1384 bool has_day_start_sec() const;
1385 private:
1386 bool _internal_has_day_start_sec() const;
1387 public:
1388 void clear_day_start_sec();
1389 ::uint64_t day_start_sec() const;
1390 void set_day_start_sec(::uint64_t value);
1391 private:
1392 ::uint64_t _internal_day_start_sec() const;
1393 void _internal_set_day_start_sec(::uint64_t value);
1394 public:
1395
1396 // optional uint32 nr_samples = 3;
1397 bool has_nr_samples() const;
1398 private:
1399 bool _internal_has_nr_samples() const;
1400 public:
1401 void clear_nr_samples();
1402 ::uint32_t nr_samples() const;
1403 void set_nr_samples(::uint32_t value);
1404 private:
1405 ::uint32_t _internal_nr_samples() const;
1406 void _internal_set_nr_samples(::uint32_t value);
1407 public:
1408
1409 // optional uint32 nr_days = 5;
1410 bool has_nr_days() const;
1411 private:
1412 bool _internal_has_nr_days() const;
1413 public:
1414 void clear_nr_days();
1415 ::uint32_t nr_days() const;
1416 void set_nr_days(::uint32_t value);
1417 private:
1418 ::uint32_t _internal_nr_days() const;
1419 void _internal_set_nr_days(::uint32_t value);
1420 public:
1421
1422 // optional uint32 nr_weeks = 7;
1423 bool has_nr_weeks() const;
1424 private:
1425 bool _internal_has_nr_weeks() const;
1426 public:
1427 void clear_nr_weeks();
1428 ::uint32_t nr_weeks() const;
1429 void set_nr_weeks(::uint32_t value);
1430 private:
1431 ::uint32_t _internal_nr_weeks() const;
1432 void _internal_set_nr_weeks(::uint32_t value);
1433 public:
1434
1435 // @@protoc_insertion_point(class_scope:storaged_proto.IOPerfHistory)
1436 private:
1437 class _Internal;
1438
1439 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1440 typedef void InternalArenaConstructable_;
1441 typedef void DestructorSkippable_;
1442 struct Impl_ {
1443 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
1444 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1445 ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::uint32_t > recent_perf_;
1446 ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::uint32_t > daily_perf_;
1447 ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::uint32_t > weekly_perf_;
1448 ::uint64_t day_start_sec_;
1449 ::uint32_t nr_samples_;
1450 ::uint32_t nr_days_;
1451 ::uint32_t nr_weeks_;
1452 };
1453 union { Impl_ _impl_; };
1454 friend struct ::TableStruct_system_2fcore_2fstoraged_2fstoraged_2eproto;
1455 };
1456 // -------------------------------------------------------------------
1457
1458 class StoragedProto final :
1459 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:storaged_proto.StoragedProto) */ {
1460 public:
StoragedProto()1461 inline StoragedProto() : StoragedProto(nullptr) {}
1462 ~StoragedProto() override;
1463 explicit PROTOBUF_CONSTEXPR StoragedProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1464
1465 StoragedProto(const StoragedProto& from);
StoragedProto(StoragedProto && from)1466 StoragedProto(StoragedProto&& from) noexcept
1467 : StoragedProto() {
1468 *this = ::std::move(from);
1469 }
1470
1471 inline StoragedProto& operator=(const StoragedProto& from) {
1472 if (this == &from) return *this;
1473 CopyFrom(from);
1474 return *this;
1475 }
1476 inline StoragedProto& operator=(StoragedProto&& from) noexcept {
1477 if (this == &from) return *this;
1478 if (GetOwningArena() == from.GetOwningArena()
1479 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1480 && GetOwningArena() != nullptr
1481 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
1482 ) {
1483 InternalSwap(&from);
1484 } else {
1485 CopyFrom(from);
1486 }
1487 return *this;
1488 }
1489
unknown_fields()1490 inline const std::string& unknown_fields() const {
1491 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
1492 }
mutable_unknown_fields()1493 inline std::string* mutable_unknown_fields() {
1494 return _internal_metadata_.mutable_unknown_fields<std::string>();
1495 }
1496
default_instance()1497 static const StoragedProto& default_instance() {
1498 return *internal_default_instance();
1499 }
internal_default_instance()1500 static inline const StoragedProto* internal_default_instance() {
1501 return reinterpret_cast<const StoragedProto*>(
1502 &_StoragedProto_default_instance_);
1503 }
1504 static constexpr int kIndexInFileMessages =
1505 7;
1506
swap(StoragedProto & a,StoragedProto & b)1507 friend void swap(StoragedProto& a, StoragedProto& b) {
1508 a.Swap(&b);
1509 }
Swap(StoragedProto * other)1510 inline void Swap(StoragedProto* other) {
1511 if (other == this) return;
1512 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1513 if (GetOwningArena() != nullptr &&
1514 GetOwningArena() == other->GetOwningArena()) {
1515 #else // PROTOBUF_FORCE_COPY_IN_SWAP
1516 if (GetOwningArena() == other->GetOwningArena()) {
1517 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
1518 InternalSwap(other);
1519 } else {
1520 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1521 }
1522 }
1523 void UnsafeArenaSwap(StoragedProto* other) {
1524 if (other == this) return;
1525 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1526 InternalSwap(other);
1527 }
1528
1529 // implements Message ----------------------------------------------
1530
1531 StoragedProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1532 return CreateMaybeMessage<StoragedProto>(arena);
1533 }
1534 StoragedProto* New() const {
1535 return New(nullptr);
1536 }
1537 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
1538 void CopyFrom(const StoragedProto& from);
1539 void MergeFrom(const StoragedProto& from);
1540 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1541 bool IsInitialized() const final;
1542
1543 size_t ByteSizeLong() const final;
1544 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1545 ::uint8_t* _InternalSerialize(
1546 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1547 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1548
1549 private:
1550 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1551 void SharedDtor();
1552 void SetCachedSize(int size) const;
1553 void InternalSwap(StoragedProto* other);
1554
1555 private:
1556 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1557 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1558 return "storaged_proto.StoragedProto";
1559 }
1560 protected:
1561 explicit StoragedProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1562 bool is_message_owned = false);
1563 public:
1564
1565 std::string GetTypeName() const final;
1566
1567 // nested types ----------------------------------------------------
1568
1569 // accessors -------------------------------------------------------
1570
1571 enum : int {
1572 kPaddingFieldNumber = 5,
1573 kUidIoUsageFieldNumber = 3,
1574 kPerfHistoryFieldNumber = 4,
1575 kCrcFieldNumber = 1,
1576 kVersionFieldNumber = 2,
1577 };
1578 // optional bytes padding = 5;
1579 bool has_padding() const;
1580 private:
1581 bool _internal_has_padding() const;
1582 public:
1583 void clear_padding();
1584 const std::string& padding() const;
1585 template <typename ArgT0 = const std::string&, typename... ArgT>
1586 void set_padding(ArgT0&& arg0, ArgT... args);
1587 std::string* mutable_padding();
1588 PROTOBUF_NODISCARD std::string* release_padding();
1589 void set_allocated_padding(std::string* padding);
1590 private:
1591 const std::string& _internal_padding() const;
1592 inline PROTOBUF_ALWAYS_INLINE void _internal_set_padding(const std::string& value);
1593 std::string* _internal_mutable_padding();
1594 public:
1595
1596 // optional .storaged_proto.UidIOUsage uid_io_usage = 3;
1597 bool has_uid_io_usage() const;
1598 private:
1599 bool _internal_has_uid_io_usage() const;
1600 public:
1601 void clear_uid_io_usage();
1602 const ::storaged_proto::UidIOUsage& uid_io_usage() const;
1603 PROTOBUF_NODISCARD ::storaged_proto::UidIOUsage* release_uid_io_usage();
1604 ::storaged_proto::UidIOUsage* mutable_uid_io_usage();
1605 void set_allocated_uid_io_usage(::storaged_proto::UidIOUsage* uid_io_usage);
1606 private:
1607 const ::storaged_proto::UidIOUsage& _internal_uid_io_usage() const;
1608 ::storaged_proto::UidIOUsage* _internal_mutable_uid_io_usage();
1609 public:
1610 void unsafe_arena_set_allocated_uid_io_usage(
1611 ::storaged_proto::UidIOUsage* uid_io_usage);
1612 ::storaged_proto::UidIOUsage* unsafe_arena_release_uid_io_usage();
1613
1614 // optional .storaged_proto.IOPerfHistory perf_history = 4;
1615 bool has_perf_history() const;
1616 private:
1617 bool _internal_has_perf_history() const;
1618 public:
1619 void clear_perf_history();
1620 const ::storaged_proto::IOPerfHistory& perf_history() const;
1621 PROTOBUF_NODISCARD ::storaged_proto::IOPerfHistory* release_perf_history();
1622 ::storaged_proto::IOPerfHistory* mutable_perf_history();
1623 void set_allocated_perf_history(::storaged_proto::IOPerfHistory* perf_history);
1624 private:
1625 const ::storaged_proto::IOPerfHistory& _internal_perf_history() const;
1626 ::storaged_proto::IOPerfHistory* _internal_mutable_perf_history();
1627 public:
1628 void unsafe_arena_set_allocated_perf_history(
1629 ::storaged_proto::IOPerfHistory* perf_history);
1630 ::storaged_proto::IOPerfHistory* unsafe_arena_release_perf_history();
1631
1632 // optional uint32 crc = 1;
1633 bool has_crc() const;
1634 private:
1635 bool _internal_has_crc() const;
1636 public:
1637 void clear_crc();
1638 ::uint32_t crc() const;
1639 void set_crc(::uint32_t value);
1640 private:
1641 ::uint32_t _internal_crc() const;
1642 void _internal_set_crc(::uint32_t value);
1643 public:
1644
1645 // optional uint32 version = 2;
1646 bool has_version() const;
1647 private:
1648 bool _internal_has_version() const;
1649 public:
1650 void clear_version();
1651 ::uint32_t version() const;
1652 void set_version(::uint32_t value);
1653 private:
1654 ::uint32_t _internal_version() const;
1655 void _internal_set_version(::uint32_t value);
1656 public:
1657
1658 // @@protoc_insertion_point(class_scope:storaged_proto.StoragedProto)
1659 private:
1660 class _Internal;
1661
1662 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1663 typedef void InternalArenaConstructable_;
1664 typedef void DestructorSkippable_;
1665 struct Impl_ {
1666 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
1667 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1668 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr padding_;
1669 ::storaged_proto::UidIOUsage* uid_io_usage_;
1670 ::storaged_proto::IOPerfHistory* perf_history_;
1671 ::uint32_t crc_;
1672 ::uint32_t version_;
1673 };
1674 union { Impl_ _impl_; };
1675 friend struct ::TableStruct_system_2fcore_2fstoraged_2fstoraged_2eproto;
1676 };
1677 // ===================================================================
1678
1679
1680 // ===================================================================
1681
1682 #ifdef __GNUC__
1683 #pragma GCC diagnostic push
1684 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
1685 #endif // __GNUC__
1686 // IOUsage
1687
1688 // optional uint64 rd_fg_chg_on = 1;
_internal_has_rd_fg_chg_on()1689 inline bool IOUsage::_internal_has_rd_fg_chg_on() const {
1690 bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
1691 return value;
1692 }
has_rd_fg_chg_on()1693 inline bool IOUsage::has_rd_fg_chg_on() const {
1694 return _internal_has_rd_fg_chg_on();
1695 }
clear_rd_fg_chg_on()1696 inline void IOUsage::clear_rd_fg_chg_on() {
1697 _impl_.rd_fg_chg_on_ = ::uint64_t{0u};
1698 _impl_._has_bits_[0] &= ~0x00000001u;
1699 }
_internal_rd_fg_chg_on()1700 inline ::uint64_t IOUsage::_internal_rd_fg_chg_on() const {
1701 return _impl_.rd_fg_chg_on_;
1702 }
rd_fg_chg_on()1703 inline ::uint64_t IOUsage::rd_fg_chg_on() const {
1704 // @@protoc_insertion_point(field_get:storaged_proto.IOUsage.rd_fg_chg_on)
1705 return _internal_rd_fg_chg_on();
1706 }
_internal_set_rd_fg_chg_on(::uint64_t value)1707 inline void IOUsage::_internal_set_rd_fg_chg_on(::uint64_t value) {
1708 _impl_._has_bits_[0] |= 0x00000001u;
1709 _impl_.rd_fg_chg_on_ = value;
1710 }
set_rd_fg_chg_on(::uint64_t value)1711 inline void IOUsage::set_rd_fg_chg_on(::uint64_t value) {
1712 _internal_set_rd_fg_chg_on(value);
1713 // @@protoc_insertion_point(field_set:storaged_proto.IOUsage.rd_fg_chg_on)
1714 }
1715
1716 // optional uint64 rd_fg_chg_off = 2;
_internal_has_rd_fg_chg_off()1717 inline bool IOUsage::_internal_has_rd_fg_chg_off() const {
1718 bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
1719 return value;
1720 }
has_rd_fg_chg_off()1721 inline bool IOUsage::has_rd_fg_chg_off() const {
1722 return _internal_has_rd_fg_chg_off();
1723 }
clear_rd_fg_chg_off()1724 inline void IOUsage::clear_rd_fg_chg_off() {
1725 _impl_.rd_fg_chg_off_ = ::uint64_t{0u};
1726 _impl_._has_bits_[0] &= ~0x00000002u;
1727 }
_internal_rd_fg_chg_off()1728 inline ::uint64_t IOUsage::_internal_rd_fg_chg_off() const {
1729 return _impl_.rd_fg_chg_off_;
1730 }
rd_fg_chg_off()1731 inline ::uint64_t IOUsage::rd_fg_chg_off() const {
1732 // @@protoc_insertion_point(field_get:storaged_proto.IOUsage.rd_fg_chg_off)
1733 return _internal_rd_fg_chg_off();
1734 }
_internal_set_rd_fg_chg_off(::uint64_t value)1735 inline void IOUsage::_internal_set_rd_fg_chg_off(::uint64_t value) {
1736 _impl_._has_bits_[0] |= 0x00000002u;
1737 _impl_.rd_fg_chg_off_ = value;
1738 }
set_rd_fg_chg_off(::uint64_t value)1739 inline void IOUsage::set_rd_fg_chg_off(::uint64_t value) {
1740 _internal_set_rd_fg_chg_off(value);
1741 // @@protoc_insertion_point(field_set:storaged_proto.IOUsage.rd_fg_chg_off)
1742 }
1743
1744 // optional uint64 rd_bg_chg_on = 3;
_internal_has_rd_bg_chg_on()1745 inline bool IOUsage::_internal_has_rd_bg_chg_on() const {
1746 bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
1747 return value;
1748 }
has_rd_bg_chg_on()1749 inline bool IOUsage::has_rd_bg_chg_on() const {
1750 return _internal_has_rd_bg_chg_on();
1751 }
clear_rd_bg_chg_on()1752 inline void IOUsage::clear_rd_bg_chg_on() {
1753 _impl_.rd_bg_chg_on_ = ::uint64_t{0u};
1754 _impl_._has_bits_[0] &= ~0x00000004u;
1755 }
_internal_rd_bg_chg_on()1756 inline ::uint64_t IOUsage::_internal_rd_bg_chg_on() const {
1757 return _impl_.rd_bg_chg_on_;
1758 }
rd_bg_chg_on()1759 inline ::uint64_t IOUsage::rd_bg_chg_on() const {
1760 // @@protoc_insertion_point(field_get:storaged_proto.IOUsage.rd_bg_chg_on)
1761 return _internal_rd_bg_chg_on();
1762 }
_internal_set_rd_bg_chg_on(::uint64_t value)1763 inline void IOUsage::_internal_set_rd_bg_chg_on(::uint64_t value) {
1764 _impl_._has_bits_[0] |= 0x00000004u;
1765 _impl_.rd_bg_chg_on_ = value;
1766 }
set_rd_bg_chg_on(::uint64_t value)1767 inline void IOUsage::set_rd_bg_chg_on(::uint64_t value) {
1768 _internal_set_rd_bg_chg_on(value);
1769 // @@protoc_insertion_point(field_set:storaged_proto.IOUsage.rd_bg_chg_on)
1770 }
1771
1772 // optional uint64 rd_bg_chg_off = 4;
_internal_has_rd_bg_chg_off()1773 inline bool IOUsage::_internal_has_rd_bg_chg_off() const {
1774 bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
1775 return value;
1776 }
has_rd_bg_chg_off()1777 inline bool IOUsage::has_rd_bg_chg_off() const {
1778 return _internal_has_rd_bg_chg_off();
1779 }
clear_rd_bg_chg_off()1780 inline void IOUsage::clear_rd_bg_chg_off() {
1781 _impl_.rd_bg_chg_off_ = ::uint64_t{0u};
1782 _impl_._has_bits_[0] &= ~0x00000008u;
1783 }
_internal_rd_bg_chg_off()1784 inline ::uint64_t IOUsage::_internal_rd_bg_chg_off() const {
1785 return _impl_.rd_bg_chg_off_;
1786 }
rd_bg_chg_off()1787 inline ::uint64_t IOUsage::rd_bg_chg_off() const {
1788 // @@protoc_insertion_point(field_get:storaged_proto.IOUsage.rd_bg_chg_off)
1789 return _internal_rd_bg_chg_off();
1790 }
_internal_set_rd_bg_chg_off(::uint64_t value)1791 inline void IOUsage::_internal_set_rd_bg_chg_off(::uint64_t value) {
1792 _impl_._has_bits_[0] |= 0x00000008u;
1793 _impl_.rd_bg_chg_off_ = value;
1794 }
set_rd_bg_chg_off(::uint64_t value)1795 inline void IOUsage::set_rd_bg_chg_off(::uint64_t value) {
1796 _internal_set_rd_bg_chg_off(value);
1797 // @@protoc_insertion_point(field_set:storaged_proto.IOUsage.rd_bg_chg_off)
1798 }
1799
1800 // optional uint64 wr_fg_chg_on = 5;
_internal_has_wr_fg_chg_on()1801 inline bool IOUsage::_internal_has_wr_fg_chg_on() const {
1802 bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
1803 return value;
1804 }
has_wr_fg_chg_on()1805 inline bool IOUsage::has_wr_fg_chg_on() const {
1806 return _internal_has_wr_fg_chg_on();
1807 }
clear_wr_fg_chg_on()1808 inline void IOUsage::clear_wr_fg_chg_on() {
1809 _impl_.wr_fg_chg_on_ = ::uint64_t{0u};
1810 _impl_._has_bits_[0] &= ~0x00000010u;
1811 }
_internal_wr_fg_chg_on()1812 inline ::uint64_t IOUsage::_internal_wr_fg_chg_on() const {
1813 return _impl_.wr_fg_chg_on_;
1814 }
wr_fg_chg_on()1815 inline ::uint64_t IOUsage::wr_fg_chg_on() const {
1816 // @@protoc_insertion_point(field_get:storaged_proto.IOUsage.wr_fg_chg_on)
1817 return _internal_wr_fg_chg_on();
1818 }
_internal_set_wr_fg_chg_on(::uint64_t value)1819 inline void IOUsage::_internal_set_wr_fg_chg_on(::uint64_t value) {
1820 _impl_._has_bits_[0] |= 0x00000010u;
1821 _impl_.wr_fg_chg_on_ = value;
1822 }
set_wr_fg_chg_on(::uint64_t value)1823 inline void IOUsage::set_wr_fg_chg_on(::uint64_t value) {
1824 _internal_set_wr_fg_chg_on(value);
1825 // @@protoc_insertion_point(field_set:storaged_proto.IOUsage.wr_fg_chg_on)
1826 }
1827
1828 // optional uint64 wr_fg_chg_off = 6;
_internal_has_wr_fg_chg_off()1829 inline bool IOUsage::_internal_has_wr_fg_chg_off() const {
1830 bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
1831 return value;
1832 }
has_wr_fg_chg_off()1833 inline bool IOUsage::has_wr_fg_chg_off() const {
1834 return _internal_has_wr_fg_chg_off();
1835 }
clear_wr_fg_chg_off()1836 inline void IOUsage::clear_wr_fg_chg_off() {
1837 _impl_.wr_fg_chg_off_ = ::uint64_t{0u};
1838 _impl_._has_bits_[0] &= ~0x00000020u;
1839 }
_internal_wr_fg_chg_off()1840 inline ::uint64_t IOUsage::_internal_wr_fg_chg_off() const {
1841 return _impl_.wr_fg_chg_off_;
1842 }
wr_fg_chg_off()1843 inline ::uint64_t IOUsage::wr_fg_chg_off() const {
1844 // @@protoc_insertion_point(field_get:storaged_proto.IOUsage.wr_fg_chg_off)
1845 return _internal_wr_fg_chg_off();
1846 }
_internal_set_wr_fg_chg_off(::uint64_t value)1847 inline void IOUsage::_internal_set_wr_fg_chg_off(::uint64_t value) {
1848 _impl_._has_bits_[0] |= 0x00000020u;
1849 _impl_.wr_fg_chg_off_ = value;
1850 }
set_wr_fg_chg_off(::uint64_t value)1851 inline void IOUsage::set_wr_fg_chg_off(::uint64_t value) {
1852 _internal_set_wr_fg_chg_off(value);
1853 // @@protoc_insertion_point(field_set:storaged_proto.IOUsage.wr_fg_chg_off)
1854 }
1855
1856 // optional uint64 wr_bg_chg_on = 7;
_internal_has_wr_bg_chg_on()1857 inline bool IOUsage::_internal_has_wr_bg_chg_on() const {
1858 bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
1859 return value;
1860 }
has_wr_bg_chg_on()1861 inline bool IOUsage::has_wr_bg_chg_on() const {
1862 return _internal_has_wr_bg_chg_on();
1863 }
clear_wr_bg_chg_on()1864 inline void IOUsage::clear_wr_bg_chg_on() {
1865 _impl_.wr_bg_chg_on_ = ::uint64_t{0u};
1866 _impl_._has_bits_[0] &= ~0x00000040u;
1867 }
_internal_wr_bg_chg_on()1868 inline ::uint64_t IOUsage::_internal_wr_bg_chg_on() const {
1869 return _impl_.wr_bg_chg_on_;
1870 }
wr_bg_chg_on()1871 inline ::uint64_t IOUsage::wr_bg_chg_on() const {
1872 // @@protoc_insertion_point(field_get:storaged_proto.IOUsage.wr_bg_chg_on)
1873 return _internal_wr_bg_chg_on();
1874 }
_internal_set_wr_bg_chg_on(::uint64_t value)1875 inline void IOUsage::_internal_set_wr_bg_chg_on(::uint64_t value) {
1876 _impl_._has_bits_[0] |= 0x00000040u;
1877 _impl_.wr_bg_chg_on_ = value;
1878 }
set_wr_bg_chg_on(::uint64_t value)1879 inline void IOUsage::set_wr_bg_chg_on(::uint64_t value) {
1880 _internal_set_wr_bg_chg_on(value);
1881 // @@protoc_insertion_point(field_set:storaged_proto.IOUsage.wr_bg_chg_on)
1882 }
1883
1884 // optional uint64 wr_bg_chg_off = 8;
_internal_has_wr_bg_chg_off()1885 inline bool IOUsage::_internal_has_wr_bg_chg_off() const {
1886 bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
1887 return value;
1888 }
has_wr_bg_chg_off()1889 inline bool IOUsage::has_wr_bg_chg_off() const {
1890 return _internal_has_wr_bg_chg_off();
1891 }
clear_wr_bg_chg_off()1892 inline void IOUsage::clear_wr_bg_chg_off() {
1893 _impl_.wr_bg_chg_off_ = ::uint64_t{0u};
1894 _impl_._has_bits_[0] &= ~0x00000080u;
1895 }
_internal_wr_bg_chg_off()1896 inline ::uint64_t IOUsage::_internal_wr_bg_chg_off() const {
1897 return _impl_.wr_bg_chg_off_;
1898 }
wr_bg_chg_off()1899 inline ::uint64_t IOUsage::wr_bg_chg_off() const {
1900 // @@protoc_insertion_point(field_get:storaged_proto.IOUsage.wr_bg_chg_off)
1901 return _internal_wr_bg_chg_off();
1902 }
_internal_set_wr_bg_chg_off(::uint64_t value)1903 inline void IOUsage::_internal_set_wr_bg_chg_off(::uint64_t value) {
1904 _impl_._has_bits_[0] |= 0x00000080u;
1905 _impl_.wr_bg_chg_off_ = value;
1906 }
set_wr_bg_chg_off(::uint64_t value)1907 inline void IOUsage::set_wr_bg_chg_off(::uint64_t value) {
1908 _internal_set_wr_bg_chg_off(value);
1909 // @@protoc_insertion_point(field_set:storaged_proto.IOUsage.wr_bg_chg_off)
1910 }
1911
1912 // -------------------------------------------------------------------
1913
1914 // TaskIOUsage
1915
1916 // optional string task_name = 1;
_internal_has_task_name()1917 inline bool TaskIOUsage::_internal_has_task_name() const {
1918 bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
1919 return value;
1920 }
has_task_name()1921 inline bool TaskIOUsage::has_task_name() const {
1922 return _internal_has_task_name();
1923 }
clear_task_name()1924 inline void TaskIOUsage::clear_task_name() {
1925 _impl_.task_name_.ClearToEmpty();
1926 _impl_._has_bits_[0] &= ~0x00000001u;
1927 }
task_name()1928 inline const std::string& TaskIOUsage::task_name() const {
1929 // @@protoc_insertion_point(field_get:storaged_proto.TaskIOUsage.task_name)
1930 return _internal_task_name();
1931 }
1932 template <typename ArgT0, typename... ArgT>
1933 inline PROTOBUF_ALWAYS_INLINE
set_task_name(ArgT0 && arg0,ArgT...args)1934 void TaskIOUsage::set_task_name(ArgT0&& arg0, ArgT... args) {
1935 _impl_._has_bits_[0] |= 0x00000001u;
1936 _impl_.task_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
1937 // @@protoc_insertion_point(field_set:storaged_proto.TaskIOUsage.task_name)
1938 }
mutable_task_name()1939 inline std::string* TaskIOUsage::mutable_task_name() {
1940 std::string* _s = _internal_mutable_task_name();
1941 // @@protoc_insertion_point(field_mutable:storaged_proto.TaskIOUsage.task_name)
1942 return _s;
1943 }
_internal_task_name()1944 inline const std::string& TaskIOUsage::_internal_task_name() const {
1945 return _impl_.task_name_.Get();
1946 }
_internal_set_task_name(const std::string & value)1947 inline void TaskIOUsage::_internal_set_task_name(const std::string& value) {
1948 _impl_._has_bits_[0] |= 0x00000001u;
1949 _impl_.task_name_.Set(value, GetArenaForAllocation());
1950 }
_internal_mutable_task_name()1951 inline std::string* TaskIOUsage::_internal_mutable_task_name() {
1952 _impl_._has_bits_[0] |= 0x00000001u;
1953 return _impl_.task_name_.Mutable(GetArenaForAllocation());
1954 }
release_task_name()1955 inline std::string* TaskIOUsage::release_task_name() {
1956 // @@protoc_insertion_point(field_release:storaged_proto.TaskIOUsage.task_name)
1957 if (!_internal_has_task_name()) {
1958 return nullptr;
1959 }
1960 _impl_._has_bits_[0] &= ~0x00000001u;
1961 auto* p = _impl_.task_name_.Release();
1962 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1963 if (_impl_.task_name_.IsDefault()) {
1964 _impl_.task_name_.Set("", GetArenaForAllocation());
1965 }
1966 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1967 return p;
1968 }
set_allocated_task_name(std::string * task_name)1969 inline void TaskIOUsage::set_allocated_task_name(std::string* task_name) {
1970 if (task_name != nullptr) {
1971 _impl_._has_bits_[0] |= 0x00000001u;
1972 } else {
1973 _impl_._has_bits_[0] &= ~0x00000001u;
1974 }
1975 _impl_.task_name_.SetAllocated(task_name, GetArenaForAllocation());
1976 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1977 if (_impl_.task_name_.IsDefault()) {
1978 _impl_.task_name_.Set("", GetArenaForAllocation());
1979 }
1980 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1981 // @@protoc_insertion_point(field_set_allocated:storaged_proto.TaskIOUsage.task_name)
1982 }
1983
1984 // optional .storaged_proto.IOUsage ios = 2;
_internal_has_ios()1985 inline bool TaskIOUsage::_internal_has_ios() const {
1986 bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
1987 PROTOBUF_ASSUME(!value || _impl_.ios_ != nullptr);
1988 return value;
1989 }
has_ios()1990 inline bool TaskIOUsage::has_ios() const {
1991 return _internal_has_ios();
1992 }
clear_ios()1993 inline void TaskIOUsage::clear_ios() {
1994 if (_impl_.ios_ != nullptr) _impl_.ios_->Clear();
1995 _impl_._has_bits_[0] &= ~0x00000002u;
1996 }
_internal_ios()1997 inline const ::storaged_proto::IOUsage& TaskIOUsage::_internal_ios() const {
1998 const ::storaged_proto::IOUsage* p = _impl_.ios_;
1999 return p != nullptr ? *p : reinterpret_cast<const ::storaged_proto::IOUsage&>(
2000 ::storaged_proto::_IOUsage_default_instance_);
2001 }
ios()2002 inline const ::storaged_proto::IOUsage& TaskIOUsage::ios() const {
2003 // @@protoc_insertion_point(field_get:storaged_proto.TaskIOUsage.ios)
2004 return _internal_ios();
2005 }
unsafe_arena_set_allocated_ios(::storaged_proto::IOUsage * ios)2006 inline void TaskIOUsage::unsafe_arena_set_allocated_ios(
2007 ::storaged_proto::IOUsage* ios) {
2008 if (GetArenaForAllocation() == nullptr) {
2009 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.ios_);
2010 }
2011 _impl_.ios_ = ios;
2012 if (ios) {
2013 _impl_._has_bits_[0] |= 0x00000002u;
2014 } else {
2015 _impl_._has_bits_[0] &= ~0x00000002u;
2016 }
2017 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:storaged_proto.TaskIOUsage.ios)
2018 }
release_ios()2019 inline ::storaged_proto::IOUsage* TaskIOUsage::release_ios() {
2020 _impl_._has_bits_[0] &= ~0x00000002u;
2021 ::storaged_proto::IOUsage* temp = _impl_.ios_;
2022 _impl_.ios_ = nullptr;
2023 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
2024 auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
2025 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
2026 if (GetArenaForAllocation() == nullptr) { delete old; }
2027 #else // PROTOBUF_FORCE_COPY_IN_RELEASE
2028 if (GetArenaForAllocation() != nullptr) {
2029 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
2030 }
2031 #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
2032 return temp;
2033 }
unsafe_arena_release_ios()2034 inline ::storaged_proto::IOUsage* TaskIOUsage::unsafe_arena_release_ios() {
2035 // @@protoc_insertion_point(field_release:storaged_proto.TaskIOUsage.ios)
2036 _impl_._has_bits_[0] &= ~0x00000002u;
2037 ::storaged_proto::IOUsage* temp = _impl_.ios_;
2038 _impl_.ios_ = nullptr;
2039 return temp;
2040 }
_internal_mutable_ios()2041 inline ::storaged_proto::IOUsage* TaskIOUsage::_internal_mutable_ios() {
2042 _impl_._has_bits_[0] |= 0x00000002u;
2043 if (_impl_.ios_ == nullptr) {
2044 auto* p = CreateMaybeMessage<::storaged_proto::IOUsage>(GetArenaForAllocation());
2045 _impl_.ios_ = p;
2046 }
2047 return _impl_.ios_;
2048 }
mutable_ios()2049 inline ::storaged_proto::IOUsage* TaskIOUsage::mutable_ios() {
2050 ::storaged_proto::IOUsage* _msg = _internal_mutable_ios();
2051 // @@protoc_insertion_point(field_mutable:storaged_proto.TaskIOUsage.ios)
2052 return _msg;
2053 }
set_allocated_ios(::storaged_proto::IOUsage * ios)2054 inline void TaskIOUsage::set_allocated_ios(::storaged_proto::IOUsage* ios) {
2055 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
2056 if (message_arena == nullptr) {
2057 delete _impl_.ios_;
2058 }
2059 if (ios) {
2060 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
2061 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(ios);
2062 if (message_arena != submessage_arena) {
2063 ios = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
2064 message_arena, ios, submessage_arena);
2065 }
2066 _impl_._has_bits_[0] |= 0x00000002u;
2067 } else {
2068 _impl_._has_bits_[0] &= ~0x00000002u;
2069 }
2070 _impl_.ios_ = ios;
2071 // @@protoc_insertion_point(field_set_allocated:storaged_proto.TaskIOUsage.ios)
2072 }
2073
2074 // -------------------------------------------------------------------
2075
2076 // UidRecord
2077
2078 // optional string uid_name = 1;
_internal_has_uid_name()2079 inline bool UidRecord::_internal_has_uid_name() const {
2080 bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
2081 return value;
2082 }
has_uid_name()2083 inline bool UidRecord::has_uid_name() const {
2084 return _internal_has_uid_name();
2085 }
clear_uid_name()2086 inline void UidRecord::clear_uid_name() {
2087 _impl_.uid_name_.ClearToEmpty();
2088 _impl_._has_bits_[0] &= ~0x00000001u;
2089 }
uid_name()2090 inline const std::string& UidRecord::uid_name() const {
2091 // @@protoc_insertion_point(field_get:storaged_proto.UidRecord.uid_name)
2092 return _internal_uid_name();
2093 }
2094 template <typename ArgT0, typename... ArgT>
2095 inline PROTOBUF_ALWAYS_INLINE
set_uid_name(ArgT0 && arg0,ArgT...args)2096 void UidRecord::set_uid_name(ArgT0&& arg0, ArgT... args) {
2097 _impl_._has_bits_[0] |= 0x00000001u;
2098 _impl_.uid_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
2099 // @@protoc_insertion_point(field_set:storaged_proto.UidRecord.uid_name)
2100 }
mutable_uid_name()2101 inline std::string* UidRecord::mutable_uid_name() {
2102 std::string* _s = _internal_mutable_uid_name();
2103 // @@protoc_insertion_point(field_mutable:storaged_proto.UidRecord.uid_name)
2104 return _s;
2105 }
_internal_uid_name()2106 inline const std::string& UidRecord::_internal_uid_name() const {
2107 return _impl_.uid_name_.Get();
2108 }
_internal_set_uid_name(const std::string & value)2109 inline void UidRecord::_internal_set_uid_name(const std::string& value) {
2110 _impl_._has_bits_[0] |= 0x00000001u;
2111 _impl_.uid_name_.Set(value, GetArenaForAllocation());
2112 }
_internal_mutable_uid_name()2113 inline std::string* UidRecord::_internal_mutable_uid_name() {
2114 _impl_._has_bits_[0] |= 0x00000001u;
2115 return _impl_.uid_name_.Mutable(GetArenaForAllocation());
2116 }
release_uid_name()2117 inline std::string* UidRecord::release_uid_name() {
2118 // @@protoc_insertion_point(field_release:storaged_proto.UidRecord.uid_name)
2119 if (!_internal_has_uid_name()) {
2120 return nullptr;
2121 }
2122 _impl_._has_bits_[0] &= ~0x00000001u;
2123 auto* p = _impl_.uid_name_.Release();
2124 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2125 if (_impl_.uid_name_.IsDefault()) {
2126 _impl_.uid_name_.Set("", GetArenaForAllocation());
2127 }
2128 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2129 return p;
2130 }
set_allocated_uid_name(std::string * uid_name)2131 inline void UidRecord::set_allocated_uid_name(std::string* uid_name) {
2132 if (uid_name != nullptr) {
2133 _impl_._has_bits_[0] |= 0x00000001u;
2134 } else {
2135 _impl_._has_bits_[0] &= ~0x00000001u;
2136 }
2137 _impl_.uid_name_.SetAllocated(uid_name, GetArenaForAllocation());
2138 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2139 if (_impl_.uid_name_.IsDefault()) {
2140 _impl_.uid_name_.Set("", GetArenaForAllocation());
2141 }
2142 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2143 // @@protoc_insertion_point(field_set_allocated:storaged_proto.UidRecord.uid_name)
2144 }
2145
2146 // optional uint32 user_id = 2;
_internal_has_user_id()2147 inline bool UidRecord::_internal_has_user_id() const {
2148 bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
2149 return value;
2150 }
has_user_id()2151 inline bool UidRecord::has_user_id() const {
2152 return _internal_has_user_id();
2153 }
clear_user_id()2154 inline void UidRecord::clear_user_id() {
2155 _impl_.user_id_ = 0u;
2156 _impl_._has_bits_[0] &= ~0x00000004u;
2157 }
_internal_user_id()2158 inline ::uint32_t UidRecord::_internal_user_id() const {
2159 return _impl_.user_id_;
2160 }
user_id()2161 inline ::uint32_t UidRecord::user_id() const {
2162 // @@protoc_insertion_point(field_get:storaged_proto.UidRecord.user_id)
2163 return _internal_user_id();
2164 }
_internal_set_user_id(::uint32_t value)2165 inline void UidRecord::_internal_set_user_id(::uint32_t value) {
2166 _impl_._has_bits_[0] |= 0x00000004u;
2167 _impl_.user_id_ = value;
2168 }
set_user_id(::uint32_t value)2169 inline void UidRecord::set_user_id(::uint32_t value) {
2170 _internal_set_user_id(value);
2171 // @@protoc_insertion_point(field_set:storaged_proto.UidRecord.user_id)
2172 }
2173
2174 // optional .storaged_proto.IOUsage uid_io = 3;
_internal_has_uid_io()2175 inline bool UidRecord::_internal_has_uid_io() const {
2176 bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
2177 PROTOBUF_ASSUME(!value || _impl_.uid_io_ != nullptr);
2178 return value;
2179 }
has_uid_io()2180 inline bool UidRecord::has_uid_io() const {
2181 return _internal_has_uid_io();
2182 }
clear_uid_io()2183 inline void UidRecord::clear_uid_io() {
2184 if (_impl_.uid_io_ != nullptr) _impl_.uid_io_->Clear();
2185 _impl_._has_bits_[0] &= ~0x00000002u;
2186 }
_internal_uid_io()2187 inline const ::storaged_proto::IOUsage& UidRecord::_internal_uid_io() const {
2188 const ::storaged_proto::IOUsage* p = _impl_.uid_io_;
2189 return p != nullptr ? *p : reinterpret_cast<const ::storaged_proto::IOUsage&>(
2190 ::storaged_proto::_IOUsage_default_instance_);
2191 }
uid_io()2192 inline const ::storaged_proto::IOUsage& UidRecord::uid_io() const {
2193 // @@protoc_insertion_point(field_get:storaged_proto.UidRecord.uid_io)
2194 return _internal_uid_io();
2195 }
unsafe_arena_set_allocated_uid_io(::storaged_proto::IOUsage * uid_io)2196 inline void UidRecord::unsafe_arena_set_allocated_uid_io(
2197 ::storaged_proto::IOUsage* uid_io) {
2198 if (GetArenaForAllocation() == nullptr) {
2199 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.uid_io_);
2200 }
2201 _impl_.uid_io_ = uid_io;
2202 if (uid_io) {
2203 _impl_._has_bits_[0] |= 0x00000002u;
2204 } else {
2205 _impl_._has_bits_[0] &= ~0x00000002u;
2206 }
2207 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:storaged_proto.UidRecord.uid_io)
2208 }
release_uid_io()2209 inline ::storaged_proto::IOUsage* UidRecord::release_uid_io() {
2210 _impl_._has_bits_[0] &= ~0x00000002u;
2211 ::storaged_proto::IOUsage* temp = _impl_.uid_io_;
2212 _impl_.uid_io_ = nullptr;
2213 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
2214 auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
2215 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
2216 if (GetArenaForAllocation() == nullptr) { delete old; }
2217 #else // PROTOBUF_FORCE_COPY_IN_RELEASE
2218 if (GetArenaForAllocation() != nullptr) {
2219 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
2220 }
2221 #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
2222 return temp;
2223 }
unsafe_arena_release_uid_io()2224 inline ::storaged_proto::IOUsage* UidRecord::unsafe_arena_release_uid_io() {
2225 // @@protoc_insertion_point(field_release:storaged_proto.UidRecord.uid_io)
2226 _impl_._has_bits_[0] &= ~0x00000002u;
2227 ::storaged_proto::IOUsage* temp = _impl_.uid_io_;
2228 _impl_.uid_io_ = nullptr;
2229 return temp;
2230 }
_internal_mutable_uid_io()2231 inline ::storaged_proto::IOUsage* UidRecord::_internal_mutable_uid_io() {
2232 _impl_._has_bits_[0] |= 0x00000002u;
2233 if (_impl_.uid_io_ == nullptr) {
2234 auto* p = CreateMaybeMessage<::storaged_proto::IOUsage>(GetArenaForAllocation());
2235 _impl_.uid_io_ = p;
2236 }
2237 return _impl_.uid_io_;
2238 }
mutable_uid_io()2239 inline ::storaged_proto::IOUsage* UidRecord::mutable_uid_io() {
2240 ::storaged_proto::IOUsage* _msg = _internal_mutable_uid_io();
2241 // @@protoc_insertion_point(field_mutable:storaged_proto.UidRecord.uid_io)
2242 return _msg;
2243 }
set_allocated_uid_io(::storaged_proto::IOUsage * uid_io)2244 inline void UidRecord::set_allocated_uid_io(::storaged_proto::IOUsage* uid_io) {
2245 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
2246 if (message_arena == nullptr) {
2247 delete _impl_.uid_io_;
2248 }
2249 if (uid_io) {
2250 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
2251 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(uid_io);
2252 if (message_arena != submessage_arena) {
2253 uid_io = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
2254 message_arena, uid_io, submessage_arena);
2255 }
2256 _impl_._has_bits_[0] |= 0x00000002u;
2257 } else {
2258 _impl_._has_bits_[0] &= ~0x00000002u;
2259 }
2260 _impl_.uid_io_ = uid_io;
2261 // @@protoc_insertion_point(field_set_allocated:storaged_proto.UidRecord.uid_io)
2262 }
2263
2264 // repeated .storaged_proto.TaskIOUsage task_io = 4;
_internal_task_io_size()2265 inline int UidRecord::_internal_task_io_size() const {
2266 return _impl_.task_io_.size();
2267 }
task_io_size()2268 inline int UidRecord::task_io_size() const {
2269 return _internal_task_io_size();
2270 }
clear_task_io()2271 inline void UidRecord::clear_task_io() {
2272 _impl_.task_io_.Clear();
2273 }
mutable_task_io(int index)2274 inline ::storaged_proto::TaskIOUsage* UidRecord::mutable_task_io(int index) {
2275 // @@protoc_insertion_point(field_mutable:storaged_proto.UidRecord.task_io)
2276 return _impl_.task_io_.Mutable(index);
2277 }
2278 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::storaged_proto::TaskIOUsage >*
mutable_task_io()2279 UidRecord::mutable_task_io() {
2280 // @@protoc_insertion_point(field_mutable_list:storaged_proto.UidRecord.task_io)
2281 return &_impl_.task_io_;
2282 }
_internal_task_io(int index)2283 inline const ::storaged_proto::TaskIOUsage& UidRecord::_internal_task_io(int index) const {
2284 return _impl_.task_io_.Get(index);
2285 }
task_io(int index)2286 inline const ::storaged_proto::TaskIOUsage& UidRecord::task_io(int index) const {
2287 // @@protoc_insertion_point(field_get:storaged_proto.UidRecord.task_io)
2288 return _internal_task_io(index);
2289 }
_internal_add_task_io()2290 inline ::storaged_proto::TaskIOUsage* UidRecord::_internal_add_task_io() {
2291 return _impl_.task_io_.Add();
2292 }
add_task_io()2293 inline ::storaged_proto::TaskIOUsage* UidRecord::add_task_io() {
2294 ::storaged_proto::TaskIOUsage* _add = _internal_add_task_io();
2295 // @@protoc_insertion_point(field_add:storaged_proto.UidRecord.task_io)
2296 return _add;
2297 }
2298 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::storaged_proto::TaskIOUsage >&
task_io()2299 UidRecord::task_io() const {
2300 // @@protoc_insertion_point(field_list:storaged_proto.UidRecord.task_io)
2301 return _impl_.task_io_;
2302 }
2303
2304 // -------------------------------------------------------------------
2305
2306 // UidIORecords
2307
2308 // optional uint64 start_ts = 1;
_internal_has_start_ts()2309 inline bool UidIORecords::_internal_has_start_ts() const {
2310 bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
2311 return value;
2312 }
has_start_ts()2313 inline bool UidIORecords::has_start_ts() const {
2314 return _internal_has_start_ts();
2315 }
clear_start_ts()2316 inline void UidIORecords::clear_start_ts() {
2317 _impl_.start_ts_ = ::uint64_t{0u};
2318 _impl_._has_bits_[0] &= ~0x00000001u;
2319 }
_internal_start_ts()2320 inline ::uint64_t UidIORecords::_internal_start_ts() const {
2321 return _impl_.start_ts_;
2322 }
start_ts()2323 inline ::uint64_t UidIORecords::start_ts() const {
2324 // @@protoc_insertion_point(field_get:storaged_proto.UidIORecords.start_ts)
2325 return _internal_start_ts();
2326 }
_internal_set_start_ts(::uint64_t value)2327 inline void UidIORecords::_internal_set_start_ts(::uint64_t value) {
2328 _impl_._has_bits_[0] |= 0x00000001u;
2329 _impl_.start_ts_ = value;
2330 }
set_start_ts(::uint64_t value)2331 inline void UidIORecords::set_start_ts(::uint64_t value) {
2332 _internal_set_start_ts(value);
2333 // @@protoc_insertion_point(field_set:storaged_proto.UidIORecords.start_ts)
2334 }
2335
2336 // repeated .storaged_proto.UidRecord entries = 2;
_internal_entries_size()2337 inline int UidIORecords::_internal_entries_size() const {
2338 return _impl_.entries_.size();
2339 }
entries_size()2340 inline int UidIORecords::entries_size() const {
2341 return _internal_entries_size();
2342 }
clear_entries()2343 inline void UidIORecords::clear_entries() {
2344 _impl_.entries_.Clear();
2345 }
mutable_entries(int index)2346 inline ::storaged_proto::UidRecord* UidIORecords::mutable_entries(int index) {
2347 // @@protoc_insertion_point(field_mutable:storaged_proto.UidIORecords.entries)
2348 return _impl_.entries_.Mutable(index);
2349 }
2350 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::storaged_proto::UidRecord >*
mutable_entries()2351 UidIORecords::mutable_entries() {
2352 // @@protoc_insertion_point(field_mutable_list:storaged_proto.UidIORecords.entries)
2353 return &_impl_.entries_;
2354 }
_internal_entries(int index)2355 inline const ::storaged_proto::UidRecord& UidIORecords::_internal_entries(int index) const {
2356 return _impl_.entries_.Get(index);
2357 }
entries(int index)2358 inline const ::storaged_proto::UidRecord& UidIORecords::entries(int index) const {
2359 // @@protoc_insertion_point(field_get:storaged_proto.UidIORecords.entries)
2360 return _internal_entries(index);
2361 }
_internal_add_entries()2362 inline ::storaged_proto::UidRecord* UidIORecords::_internal_add_entries() {
2363 return _impl_.entries_.Add();
2364 }
add_entries()2365 inline ::storaged_proto::UidRecord* UidIORecords::add_entries() {
2366 ::storaged_proto::UidRecord* _add = _internal_add_entries();
2367 // @@protoc_insertion_point(field_add:storaged_proto.UidIORecords.entries)
2368 return _add;
2369 }
2370 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::storaged_proto::UidRecord >&
entries()2371 UidIORecords::entries() const {
2372 // @@protoc_insertion_point(field_list:storaged_proto.UidIORecords.entries)
2373 return _impl_.entries_;
2374 }
2375
2376 // -------------------------------------------------------------------
2377
2378 // UidIOItem
2379
2380 // optional uint64 end_ts = 1;
_internal_has_end_ts()2381 inline bool UidIOItem::_internal_has_end_ts() const {
2382 bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
2383 return value;
2384 }
has_end_ts()2385 inline bool UidIOItem::has_end_ts() const {
2386 return _internal_has_end_ts();
2387 }
clear_end_ts()2388 inline void UidIOItem::clear_end_ts() {
2389 _impl_.end_ts_ = ::uint64_t{0u};
2390 _impl_._has_bits_[0] &= ~0x00000002u;
2391 }
_internal_end_ts()2392 inline ::uint64_t UidIOItem::_internal_end_ts() const {
2393 return _impl_.end_ts_;
2394 }
end_ts()2395 inline ::uint64_t UidIOItem::end_ts() const {
2396 // @@protoc_insertion_point(field_get:storaged_proto.UidIOItem.end_ts)
2397 return _internal_end_ts();
2398 }
_internal_set_end_ts(::uint64_t value)2399 inline void UidIOItem::_internal_set_end_ts(::uint64_t value) {
2400 _impl_._has_bits_[0] |= 0x00000002u;
2401 _impl_.end_ts_ = value;
2402 }
set_end_ts(::uint64_t value)2403 inline void UidIOItem::set_end_ts(::uint64_t value) {
2404 _internal_set_end_ts(value);
2405 // @@protoc_insertion_point(field_set:storaged_proto.UidIOItem.end_ts)
2406 }
2407
2408 // optional .storaged_proto.UidIORecords records = 2;
_internal_has_records()2409 inline bool UidIOItem::_internal_has_records() const {
2410 bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
2411 PROTOBUF_ASSUME(!value || _impl_.records_ != nullptr);
2412 return value;
2413 }
has_records()2414 inline bool UidIOItem::has_records() const {
2415 return _internal_has_records();
2416 }
clear_records()2417 inline void UidIOItem::clear_records() {
2418 if (_impl_.records_ != nullptr) _impl_.records_->Clear();
2419 _impl_._has_bits_[0] &= ~0x00000001u;
2420 }
_internal_records()2421 inline const ::storaged_proto::UidIORecords& UidIOItem::_internal_records() const {
2422 const ::storaged_proto::UidIORecords* p = _impl_.records_;
2423 return p != nullptr ? *p : reinterpret_cast<const ::storaged_proto::UidIORecords&>(
2424 ::storaged_proto::_UidIORecords_default_instance_);
2425 }
records()2426 inline const ::storaged_proto::UidIORecords& UidIOItem::records() const {
2427 // @@protoc_insertion_point(field_get:storaged_proto.UidIOItem.records)
2428 return _internal_records();
2429 }
unsafe_arena_set_allocated_records(::storaged_proto::UidIORecords * records)2430 inline void UidIOItem::unsafe_arena_set_allocated_records(
2431 ::storaged_proto::UidIORecords* records) {
2432 if (GetArenaForAllocation() == nullptr) {
2433 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.records_);
2434 }
2435 _impl_.records_ = records;
2436 if (records) {
2437 _impl_._has_bits_[0] |= 0x00000001u;
2438 } else {
2439 _impl_._has_bits_[0] &= ~0x00000001u;
2440 }
2441 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:storaged_proto.UidIOItem.records)
2442 }
release_records()2443 inline ::storaged_proto::UidIORecords* UidIOItem::release_records() {
2444 _impl_._has_bits_[0] &= ~0x00000001u;
2445 ::storaged_proto::UidIORecords* temp = _impl_.records_;
2446 _impl_.records_ = nullptr;
2447 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
2448 auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
2449 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
2450 if (GetArenaForAllocation() == nullptr) { delete old; }
2451 #else // PROTOBUF_FORCE_COPY_IN_RELEASE
2452 if (GetArenaForAllocation() != nullptr) {
2453 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
2454 }
2455 #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
2456 return temp;
2457 }
unsafe_arena_release_records()2458 inline ::storaged_proto::UidIORecords* UidIOItem::unsafe_arena_release_records() {
2459 // @@protoc_insertion_point(field_release:storaged_proto.UidIOItem.records)
2460 _impl_._has_bits_[0] &= ~0x00000001u;
2461 ::storaged_proto::UidIORecords* temp = _impl_.records_;
2462 _impl_.records_ = nullptr;
2463 return temp;
2464 }
_internal_mutable_records()2465 inline ::storaged_proto::UidIORecords* UidIOItem::_internal_mutable_records() {
2466 _impl_._has_bits_[0] |= 0x00000001u;
2467 if (_impl_.records_ == nullptr) {
2468 auto* p = CreateMaybeMessage<::storaged_proto::UidIORecords>(GetArenaForAllocation());
2469 _impl_.records_ = p;
2470 }
2471 return _impl_.records_;
2472 }
mutable_records()2473 inline ::storaged_proto::UidIORecords* UidIOItem::mutable_records() {
2474 ::storaged_proto::UidIORecords* _msg = _internal_mutable_records();
2475 // @@protoc_insertion_point(field_mutable:storaged_proto.UidIOItem.records)
2476 return _msg;
2477 }
set_allocated_records(::storaged_proto::UidIORecords * records)2478 inline void UidIOItem::set_allocated_records(::storaged_proto::UidIORecords* records) {
2479 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
2480 if (message_arena == nullptr) {
2481 delete _impl_.records_;
2482 }
2483 if (records) {
2484 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
2485 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(records);
2486 if (message_arena != submessage_arena) {
2487 records = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
2488 message_arena, records, submessage_arena);
2489 }
2490 _impl_._has_bits_[0] |= 0x00000001u;
2491 } else {
2492 _impl_._has_bits_[0] &= ~0x00000001u;
2493 }
2494 _impl_.records_ = records;
2495 // @@protoc_insertion_point(field_set_allocated:storaged_proto.UidIOItem.records)
2496 }
2497
2498 // -------------------------------------------------------------------
2499
2500 // UidIOUsage
2501
2502 // repeated .storaged_proto.UidIOItem uid_io_items = 2;
_internal_uid_io_items_size()2503 inline int UidIOUsage::_internal_uid_io_items_size() const {
2504 return _impl_.uid_io_items_.size();
2505 }
uid_io_items_size()2506 inline int UidIOUsage::uid_io_items_size() const {
2507 return _internal_uid_io_items_size();
2508 }
clear_uid_io_items()2509 inline void UidIOUsage::clear_uid_io_items() {
2510 _impl_.uid_io_items_.Clear();
2511 }
mutable_uid_io_items(int index)2512 inline ::storaged_proto::UidIOItem* UidIOUsage::mutable_uid_io_items(int index) {
2513 // @@protoc_insertion_point(field_mutable:storaged_proto.UidIOUsage.uid_io_items)
2514 return _impl_.uid_io_items_.Mutable(index);
2515 }
2516 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::storaged_proto::UidIOItem >*
mutable_uid_io_items()2517 UidIOUsage::mutable_uid_io_items() {
2518 // @@protoc_insertion_point(field_mutable_list:storaged_proto.UidIOUsage.uid_io_items)
2519 return &_impl_.uid_io_items_;
2520 }
_internal_uid_io_items(int index)2521 inline const ::storaged_proto::UidIOItem& UidIOUsage::_internal_uid_io_items(int index) const {
2522 return _impl_.uid_io_items_.Get(index);
2523 }
uid_io_items(int index)2524 inline const ::storaged_proto::UidIOItem& UidIOUsage::uid_io_items(int index) const {
2525 // @@protoc_insertion_point(field_get:storaged_proto.UidIOUsage.uid_io_items)
2526 return _internal_uid_io_items(index);
2527 }
_internal_add_uid_io_items()2528 inline ::storaged_proto::UidIOItem* UidIOUsage::_internal_add_uid_io_items() {
2529 return _impl_.uid_io_items_.Add();
2530 }
add_uid_io_items()2531 inline ::storaged_proto::UidIOItem* UidIOUsage::add_uid_io_items() {
2532 ::storaged_proto::UidIOItem* _add = _internal_add_uid_io_items();
2533 // @@protoc_insertion_point(field_add:storaged_proto.UidIOUsage.uid_io_items)
2534 return _add;
2535 }
2536 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::storaged_proto::UidIOItem >&
uid_io_items()2537 UidIOUsage::uid_io_items() const {
2538 // @@protoc_insertion_point(field_list:storaged_proto.UidIOUsage.uid_io_items)
2539 return _impl_.uid_io_items_;
2540 }
2541
2542 // -------------------------------------------------------------------
2543
2544 // IOPerfHistory
2545
2546 // optional uint64 day_start_sec = 1;
_internal_has_day_start_sec()2547 inline bool IOPerfHistory::_internal_has_day_start_sec() const {
2548 bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
2549 return value;
2550 }
has_day_start_sec()2551 inline bool IOPerfHistory::has_day_start_sec() const {
2552 return _internal_has_day_start_sec();
2553 }
clear_day_start_sec()2554 inline void IOPerfHistory::clear_day_start_sec() {
2555 _impl_.day_start_sec_ = ::uint64_t{0u};
2556 _impl_._has_bits_[0] &= ~0x00000001u;
2557 }
_internal_day_start_sec()2558 inline ::uint64_t IOPerfHistory::_internal_day_start_sec() const {
2559 return _impl_.day_start_sec_;
2560 }
day_start_sec()2561 inline ::uint64_t IOPerfHistory::day_start_sec() const {
2562 // @@protoc_insertion_point(field_get:storaged_proto.IOPerfHistory.day_start_sec)
2563 return _internal_day_start_sec();
2564 }
_internal_set_day_start_sec(::uint64_t value)2565 inline void IOPerfHistory::_internal_set_day_start_sec(::uint64_t value) {
2566 _impl_._has_bits_[0] |= 0x00000001u;
2567 _impl_.day_start_sec_ = value;
2568 }
set_day_start_sec(::uint64_t value)2569 inline void IOPerfHistory::set_day_start_sec(::uint64_t value) {
2570 _internal_set_day_start_sec(value);
2571 // @@protoc_insertion_point(field_set:storaged_proto.IOPerfHistory.day_start_sec)
2572 }
2573
2574 // repeated uint32 recent_perf = 2;
_internal_recent_perf_size()2575 inline int IOPerfHistory::_internal_recent_perf_size() const {
2576 return _impl_.recent_perf_.size();
2577 }
recent_perf_size()2578 inline int IOPerfHistory::recent_perf_size() const {
2579 return _internal_recent_perf_size();
2580 }
clear_recent_perf()2581 inline void IOPerfHistory::clear_recent_perf() {
2582 _impl_.recent_perf_.Clear();
2583 }
_internal_recent_perf(int index)2584 inline ::uint32_t IOPerfHistory::_internal_recent_perf(int index) const {
2585 return _impl_.recent_perf_.Get(index);
2586 }
recent_perf(int index)2587 inline ::uint32_t IOPerfHistory::recent_perf(int index) const {
2588 // @@protoc_insertion_point(field_get:storaged_proto.IOPerfHistory.recent_perf)
2589 return _internal_recent_perf(index);
2590 }
set_recent_perf(int index,::uint32_t value)2591 inline void IOPerfHistory::set_recent_perf(int index, ::uint32_t value) {
2592 _impl_.recent_perf_.Set(index, value);
2593 // @@protoc_insertion_point(field_set:storaged_proto.IOPerfHistory.recent_perf)
2594 }
_internal_add_recent_perf(::uint32_t value)2595 inline void IOPerfHistory::_internal_add_recent_perf(::uint32_t value) {
2596 _impl_.recent_perf_.Add(value);
2597 }
add_recent_perf(::uint32_t value)2598 inline void IOPerfHistory::add_recent_perf(::uint32_t value) {
2599 _internal_add_recent_perf(value);
2600 // @@protoc_insertion_point(field_add:storaged_proto.IOPerfHistory.recent_perf)
2601 }
2602 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::uint32_t >&
_internal_recent_perf()2603 IOPerfHistory::_internal_recent_perf() const {
2604 return _impl_.recent_perf_;
2605 }
2606 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::uint32_t >&
recent_perf()2607 IOPerfHistory::recent_perf() const {
2608 // @@protoc_insertion_point(field_list:storaged_proto.IOPerfHistory.recent_perf)
2609 return _internal_recent_perf();
2610 }
2611 inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::uint32_t >*
_internal_mutable_recent_perf()2612 IOPerfHistory::_internal_mutable_recent_perf() {
2613 return &_impl_.recent_perf_;
2614 }
2615 inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::uint32_t >*
mutable_recent_perf()2616 IOPerfHistory::mutable_recent_perf() {
2617 // @@protoc_insertion_point(field_mutable_list:storaged_proto.IOPerfHistory.recent_perf)
2618 return _internal_mutable_recent_perf();
2619 }
2620
2621 // optional uint32 nr_samples = 3;
_internal_has_nr_samples()2622 inline bool IOPerfHistory::_internal_has_nr_samples() const {
2623 bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
2624 return value;
2625 }
has_nr_samples()2626 inline bool IOPerfHistory::has_nr_samples() const {
2627 return _internal_has_nr_samples();
2628 }
clear_nr_samples()2629 inline void IOPerfHistory::clear_nr_samples() {
2630 _impl_.nr_samples_ = 0u;
2631 _impl_._has_bits_[0] &= ~0x00000002u;
2632 }
_internal_nr_samples()2633 inline ::uint32_t IOPerfHistory::_internal_nr_samples() const {
2634 return _impl_.nr_samples_;
2635 }
nr_samples()2636 inline ::uint32_t IOPerfHistory::nr_samples() const {
2637 // @@protoc_insertion_point(field_get:storaged_proto.IOPerfHistory.nr_samples)
2638 return _internal_nr_samples();
2639 }
_internal_set_nr_samples(::uint32_t value)2640 inline void IOPerfHistory::_internal_set_nr_samples(::uint32_t value) {
2641 _impl_._has_bits_[0] |= 0x00000002u;
2642 _impl_.nr_samples_ = value;
2643 }
set_nr_samples(::uint32_t value)2644 inline void IOPerfHistory::set_nr_samples(::uint32_t value) {
2645 _internal_set_nr_samples(value);
2646 // @@protoc_insertion_point(field_set:storaged_proto.IOPerfHistory.nr_samples)
2647 }
2648
2649 // repeated uint32 daily_perf = 4;
_internal_daily_perf_size()2650 inline int IOPerfHistory::_internal_daily_perf_size() const {
2651 return _impl_.daily_perf_.size();
2652 }
daily_perf_size()2653 inline int IOPerfHistory::daily_perf_size() const {
2654 return _internal_daily_perf_size();
2655 }
clear_daily_perf()2656 inline void IOPerfHistory::clear_daily_perf() {
2657 _impl_.daily_perf_.Clear();
2658 }
_internal_daily_perf(int index)2659 inline ::uint32_t IOPerfHistory::_internal_daily_perf(int index) const {
2660 return _impl_.daily_perf_.Get(index);
2661 }
daily_perf(int index)2662 inline ::uint32_t IOPerfHistory::daily_perf(int index) const {
2663 // @@protoc_insertion_point(field_get:storaged_proto.IOPerfHistory.daily_perf)
2664 return _internal_daily_perf(index);
2665 }
set_daily_perf(int index,::uint32_t value)2666 inline void IOPerfHistory::set_daily_perf(int index, ::uint32_t value) {
2667 _impl_.daily_perf_.Set(index, value);
2668 // @@protoc_insertion_point(field_set:storaged_proto.IOPerfHistory.daily_perf)
2669 }
_internal_add_daily_perf(::uint32_t value)2670 inline void IOPerfHistory::_internal_add_daily_perf(::uint32_t value) {
2671 _impl_.daily_perf_.Add(value);
2672 }
add_daily_perf(::uint32_t value)2673 inline void IOPerfHistory::add_daily_perf(::uint32_t value) {
2674 _internal_add_daily_perf(value);
2675 // @@protoc_insertion_point(field_add:storaged_proto.IOPerfHistory.daily_perf)
2676 }
2677 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::uint32_t >&
_internal_daily_perf()2678 IOPerfHistory::_internal_daily_perf() const {
2679 return _impl_.daily_perf_;
2680 }
2681 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::uint32_t >&
daily_perf()2682 IOPerfHistory::daily_perf() const {
2683 // @@protoc_insertion_point(field_list:storaged_proto.IOPerfHistory.daily_perf)
2684 return _internal_daily_perf();
2685 }
2686 inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::uint32_t >*
_internal_mutable_daily_perf()2687 IOPerfHistory::_internal_mutable_daily_perf() {
2688 return &_impl_.daily_perf_;
2689 }
2690 inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::uint32_t >*
mutable_daily_perf()2691 IOPerfHistory::mutable_daily_perf() {
2692 // @@protoc_insertion_point(field_mutable_list:storaged_proto.IOPerfHistory.daily_perf)
2693 return _internal_mutable_daily_perf();
2694 }
2695
2696 // optional uint32 nr_days = 5;
_internal_has_nr_days()2697 inline bool IOPerfHistory::_internal_has_nr_days() const {
2698 bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
2699 return value;
2700 }
has_nr_days()2701 inline bool IOPerfHistory::has_nr_days() const {
2702 return _internal_has_nr_days();
2703 }
clear_nr_days()2704 inline void IOPerfHistory::clear_nr_days() {
2705 _impl_.nr_days_ = 0u;
2706 _impl_._has_bits_[0] &= ~0x00000004u;
2707 }
_internal_nr_days()2708 inline ::uint32_t IOPerfHistory::_internal_nr_days() const {
2709 return _impl_.nr_days_;
2710 }
nr_days()2711 inline ::uint32_t IOPerfHistory::nr_days() const {
2712 // @@protoc_insertion_point(field_get:storaged_proto.IOPerfHistory.nr_days)
2713 return _internal_nr_days();
2714 }
_internal_set_nr_days(::uint32_t value)2715 inline void IOPerfHistory::_internal_set_nr_days(::uint32_t value) {
2716 _impl_._has_bits_[0] |= 0x00000004u;
2717 _impl_.nr_days_ = value;
2718 }
set_nr_days(::uint32_t value)2719 inline void IOPerfHistory::set_nr_days(::uint32_t value) {
2720 _internal_set_nr_days(value);
2721 // @@protoc_insertion_point(field_set:storaged_proto.IOPerfHistory.nr_days)
2722 }
2723
2724 // repeated uint32 weekly_perf = 6;
_internal_weekly_perf_size()2725 inline int IOPerfHistory::_internal_weekly_perf_size() const {
2726 return _impl_.weekly_perf_.size();
2727 }
weekly_perf_size()2728 inline int IOPerfHistory::weekly_perf_size() const {
2729 return _internal_weekly_perf_size();
2730 }
clear_weekly_perf()2731 inline void IOPerfHistory::clear_weekly_perf() {
2732 _impl_.weekly_perf_.Clear();
2733 }
_internal_weekly_perf(int index)2734 inline ::uint32_t IOPerfHistory::_internal_weekly_perf(int index) const {
2735 return _impl_.weekly_perf_.Get(index);
2736 }
weekly_perf(int index)2737 inline ::uint32_t IOPerfHistory::weekly_perf(int index) const {
2738 // @@protoc_insertion_point(field_get:storaged_proto.IOPerfHistory.weekly_perf)
2739 return _internal_weekly_perf(index);
2740 }
set_weekly_perf(int index,::uint32_t value)2741 inline void IOPerfHistory::set_weekly_perf(int index, ::uint32_t value) {
2742 _impl_.weekly_perf_.Set(index, value);
2743 // @@protoc_insertion_point(field_set:storaged_proto.IOPerfHistory.weekly_perf)
2744 }
_internal_add_weekly_perf(::uint32_t value)2745 inline void IOPerfHistory::_internal_add_weekly_perf(::uint32_t value) {
2746 _impl_.weekly_perf_.Add(value);
2747 }
add_weekly_perf(::uint32_t value)2748 inline void IOPerfHistory::add_weekly_perf(::uint32_t value) {
2749 _internal_add_weekly_perf(value);
2750 // @@protoc_insertion_point(field_add:storaged_proto.IOPerfHistory.weekly_perf)
2751 }
2752 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::uint32_t >&
_internal_weekly_perf()2753 IOPerfHistory::_internal_weekly_perf() const {
2754 return _impl_.weekly_perf_;
2755 }
2756 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::uint32_t >&
weekly_perf()2757 IOPerfHistory::weekly_perf() const {
2758 // @@protoc_insertion_point(field_list:storaged_proto.IOPerfHistory.weekly_perf)
2759 return _internal_weekly_perf();
2760 }
2761 inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::uint32_t >*
_internal_mutable_weekly_perf()2762 IOPerfHistory::_internal_mutable_weekly_perf() {
2763 return &_impl_.weekly_perf_;
2764 }
2765 inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::uint32_t >*
mutable_weekly_perf()2766 IOPerfHistory::mutable_weekly_perf() {
2767 // @@protoc_insertion_point(field_mutable_list:storaged_proto.IOPerfHistory.weekly_perf)
2768 return _internal_mutable_weekly_perf();
2769 }
2770
2771 // optional uint32 nr_weeks = 7;
_internal_has_nr_weeks()2772 inline bool IOPerfHistory::_internal_has_nr_weeks() const {
2773 bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
2774 return value;
2775 }
has_nr_weeks()2776 inline bool IOPerfHistory::has_nr_weeks() const {
2777 return _internal_has_nr_weeks();
2778 }
clear_nr_weeks()2779 inline void IOPerfHistory::clear_nr_weeks() {
2780 _impl_.nr_weeks_ = 0u;
2781 _impl_._has_bits_[0] &= ~0x00000008u;
2782 }
_internal_nr_weeks()2783 inline ::uint32_t IOPerfHistory::_internal_nr_weeks() const {
2784 return _impl_.nr_weeks_;
2785 }
nr_weeks()2786 inline ::uint32_t IOPerfHistory::nr_weeks() const {
2787 // @@protoc_insertion_point(field_get:storaged_proto.IOPerfHistory.nr_weeks)
2788 return _internal_nr_weeks();
2789 }
_internal_set_nr_weeks(::uint32_t value)2790 inline void IOPerfHistory::_internal_set_nr_weeks(::uint32_t value) {
2791 _impl_._has_bits_[0] |= 0x00000008u;
2792 _impl_.nr_weeks_ = value;
2793 }
set_nr_weeks(::uint32_t value)2794 inline void IOPerfHistory::set_nr_weeks(::uint32_t value) {
2795 _internal_set_nr_weeks(value);
2796 // @@protoc_insertion_point(field_set:storaged_proto.IOPerfHistory.nr_weeks)
2797 }
2798
2799 // -------------------------------------------------------------------
2800
2801 // StoragedProto
2802
2803 // optional uint32 crc = 1;
_internal_has_crc()2804 inline bool StoragedProto::_internal_has_crc() const {
2805 bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
2806 return value;
2807 }
has_crc()2808 inline bool StoragedProto::has_crc() const {
2809 return _internal_has_crc();
2810 }
clear_crc()2811 inline void StoragedProto::clear_crc() {
2812 _impl_.crc_ = 0u;
2813 _impl_._has_bits_[0] &= ~0x00000008u;
2814 }
_internal_crc()2815 inline ::uint32_t StoragedProto::_internal_crc() const {
2816 return _impl_.crc_;
2817 }
crc()2818 inline ::uint32_t StoragedProto::crc() const {
2819 // @@protoc_insertion_point(field_get:storaged_proto.StoragedProto.crc)
2820 return _internal_crc();
2821 }
_internal_set_crc(::uint32_t value)2822 inline void StoragedProto::_internal_set_crc(::uint32_t value) {
2823 _impl_._has_bits_[0] |= 0x00000008u;
2824 _impl_.crc_ = value;
2825 }
set_crc(::uint32_t value)2826 inline void StoragedProto::set_crc(::uint32_t value) {
2827 _internal_set_crc(value);
2828 // @@protoc_insertion_point(field_set:storaged_proto.StoragedProto.crc)
2829 }
2830
2831 // optional uint32 version = 2;
_internal_has_version()2832 inline bool StoragedProto::_internal_has_version() const {
2833 bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
2834 return value;
2835 }
has_version()2836 inline bool StoragedProto::has_version() const {
2837 return _internal_has_version();
2838 }
clear_version()2839 inline void StoragedProto::clear_version() {
2840 _impl_.version_ = 0u;
2841 _impl_._has_bits_[0] &= ~0x00000010u;
2842 }
_internal_version()2843 inline ::uint32_t StoragedProto::_internal_version() const {
2844 return _impl_.version_;
2845 }
version()2846 inline ::uint32_t StoragedProto::version() const {
2847 // @@protoc_insertion_point(field_get:storaged_proto.StoragedProto.version)
2848 return _internal_version();
2849 }
_internal_set_version(::uint32_t value)2850 inline void StoragedProto::_internal_set_version(::uint32_t value) {
2851 _impl_._has_bits_[0] |= 0x00000010u;
2852 _impl_.version_ = value;
2853 }
set_version(::uint32_t value)2854 inline void StoragedProto::set_version(::uint32_t value) {
2855 _internal_set_version(value);
2856 // @@protoc_insertion_point(field_set:storaged_proto.StoragedProto.version)
2857 }
2858
2859 // optional .storaged_proto.UidIOUsage uid_io_usage = 3;
_internal_has_uid_io_usage()2860 inline bool StoragedProto::_internal_has_uid_io_usage() const {
2861 bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
2862 PROTOBUF_ASSUME(!value || _impl_.uid_io_usage_ != nullptr);
2863 return value;
2864 }
has_uid_io_usage()2865 inline bool StoragedProto::has_uid_io_usage() const {
2866 return _internal_has_uid_io_usage();
2867 }
clear_uid_io_usage()2868 inline void StoragedProto::clear_uid_io_usage() {
2869 if (_impl_.uid_io_usage_ != nullptr) _impl_.uid_io_usage_->Clear();
2870 _impl_._has_bits_[0] &= ~0x00000002u;
2871 }
_internal_uid_io_usage()2872 inline const ::storaged_proto::UidIOUsage& StoragedProto::_internal_uid_io_usage() const {
2873 const ::storaged_proto::UidIOUsage* p = _impl_.uid_io_usage_;
2874 return p != nullptr ? *p : reinterpret_cast<const ::storaged_proto::UidIOUsage&>(
2875 ::storaged_proto::_UidIOUsage_default_instance_);
2876 }
uid_io_usage()2877 inline const ::storaged_proto::UidIOUsage& StoragedProto::uid_io_usage() const {
2878 // @@protoc_insertion_point(field_get:storaged_proto.StoragedProto.uid_io_usage)
2879 return _internal_uid_io_usage();
2880 }
unsafe_arena_set_allocated_uid_io_usage(::storaged_proto::UidIOUsage * uid_io_usage)2881 inline void StoragedProto::unsafe_arena_set_allocated_uid_io_usage(
2882 ::storaged_proto::UidIOUsage* uid_io_usage) {
2883 if (GetArenaForAllocation() == nullptr) {
2884 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.uid_io_usage_);
2885 }
2886 _impl_.uid_io_usage_ = uid_io_usage;
2887 if (uid_io_usage) {
2888 _impl_._has_bits_[0] |= 0x00000002u;
2889 } else {
2890 _impl_._has_bits_[0] &= ~0x00000002u;
2891 }
2892 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:storaged_proto.StoragedProto.uid_io_usage)
2893 }
release_uid_io_usage()2894 inline ::storaged_proto::UidIOUsage* StoragedProto::release_uid_io_usage() {
2895 _impl_._has_bits_[0] &= ~0x00000002u;
2896 ::storaged_proto::UidIOUsage* temp = _impl_.uid_io_usage_;
2897 _impl_.uid_io_usage_ = nullptr;
2898 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
2899 auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
2900 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
2901 if (GetArenaForAllocation() == nullptr) { delete old; }
2902 #else // PROTOBUF_FORCE_COPY_IN_RELEASE
2903 if (GetArenaForAllocation() != nullptr) {
2904 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
2905 }
2906 #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
2907 return temp;
2908 }
unsafe_arena_release_uid_io_usage()2909 inline ::storaged_proto::UidIOUsage* StoragedProto::unsafe_arena_release_uid_io_usage() {
2910 // @@protoc_insertion_point(field_release:storaged_proto.StoragedProto.uid_io_usage)
2911 _impl_._has_bits_[0] &= ~0x00000002u;
2912 ::storaged_proto::UidIOUsage* temp = _impl_.uid_io_usage_;
2913 _impl_.uid_io_usage_ = nullptr;
2914 return temp;
2915 }
_internal_mutable_uid_io_usage()2916 inline ::storaged_proto::UidIOUsage* StoragedProto::_internal_mutable_uid_io_usage() {
2917 _impl_._has_bits_[0] |= 0x00000002u;
2918 if (_impl_.uid_io_usage_ == nullptr) {
2919 auto* p = CreateMaybeMessage<::storaged_proto::UidIOUsage>(GetArenaForAllocation());
2920 _impl_.uid_io_usage_ = p;
2921 }
2922 return _impl_.uid_io_usage_;
2923 }
mutable_uid_io_usage()2924 inline ::storaged_proto::UidIOUsage* StoragedProto::mutable_uid_io_usage() {
2925 ::storaged_proto::UidIOUsage* _msg = _internal_mutable_uid_io_usage();
2926 // @@protoc_insertion_point(field_mutable:storaged_proto.StoragedProto.uid_io_usage)
2927 return _msg;
2928 }
set_allocated_uid_io_usage(::storaged_proto::UidIOUsage * uid_io_usage)2929 inline void StoragedProto::set_allocated_uid_io_usage(::storaged_proto::UidIOUsage* uid_io_usage) {
2930 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
2931 if (message_arena == nullptr) {
2932 delete _impl_.uid_io_usage_;
2933 }
2934 if (uid_io_usage) {
2935 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
2936 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(uid_io_usage);
2937 if (message_arena != submessage_arena) {
2938 uid_io_usage = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
2939 message_arena, uid_io_usage, submessage_arena);
2940 }
2941 _impl_._has_bits_[0] |= 0x00000002u;
2942 } else {
2943 _impl_._has_bits_[0] &= ~0x00000002u;
2944 }
2945 _impl_.uid_io_usage_ = uid_io_usage;
2946 // @@protoc_insertion_point(field_set_allocated:storaged_proto.StoragedProto.uid_io_usage)
2947 }
2948
2949 // optional .storaged_proto.IOPerfHistory perf_history = 4;
_internal_has_perf_history()2950 inline bool StoragedProto::_internal_has_perf_history() const {
2951 bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
2952 PROTOBUF_ASSUME(!value || _impl_.perf_history_ != nullptr);
2953 return value;
2954 }
has_perf_history()2955 inline bool StoragedProto::has_perf_history() const {
2956 return _internal_has_perf_history();
2957 }
clear_perf_history()2958 inline void StoragedProto::clear_perf_history() {
2959 if (_impl_.perf_history_ != nullptr) _impl_.perf_history_->Clear();
2960 _impl_._has_bits_[0] &= ~0x00000004u;
2961 }
_internal_perf_history()2962 inline const ::storaged_proto::IOPerfHistory& StoragedProto::_internal_perf_history() const {
2963 const ::storaged_proto::IOPerfHistory* p = _impl_.perf_history_;
2964 return p != nullptr ? *p : reinterpret_cast<const ::storaged_proto::IOPerfHistory&>(
2965 ::storaged_proto::_IOPerfHistory_default_instance_);
2966 }
perf_history()2967 inline const ::storaged_proto::IOPerfHistory& StoragedProto::perf_history() const {
2968 // @@protoc_insertion_point(field_get:storaged_proto.StoragedProto.perf_history)
2969 return _internal_perf_history();
2970 }
unsafe_arena_set_allocated_perf_history(::storaged_proto::IOPerfHistory * perf_history)2971 inline void StoragedProto::unsafe_arena_set_allocated_perf_history(
2972 ::storaged_proto::IOPerfHistory* perf_history) {
2973 if (GetArenaForAllocation() == nullptr) {
2974 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.perf_history_);
2975 }
2976 _impl_.perf_history_ = perf_history;
2977 if (perf_history) {
2978 _impl_._has_bits_[0] |= 0x00000004u;
2979 } else {
2980 _impl_._has_bits_[0] &= ~0x00000004u;
2981 }
2982 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:storaged_proto.StoragedProto.perf_history)
2983 }
release_perf_history()2984 inline ::storaged_proto::IOPerfHistory* StoragedProto::release_perf_history() {
2985 _impl_._has_bits_[0] &= ~0x00000004u;
2986 ::storaged_proto::IOPerfHistory* temp = _impl_.perf_history_;
2987 _impl_.perf_history_ = nullptr;
2988 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
2989 auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
2990 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
2991 if (GetArenaForAllocation() == nullptr) { delete old; }
2992 #else // PROTOBUF_FORCE_COPY_IN_RELEASE
2993 if (GetArenaForAllocation() != nullptr) {
2994 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
2995 }
2996 #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
2997 return temp;
2998 }
unsafe_arena_release_perf_history()2999 inline ::storaged_proto::IOPerfHistory* StoragedProto::unsafe_arena_release_perf_history() {
3000 // @@protoc_insertion_point(field_release:storaged_proto.StoragedProto.perf_history)
3001 _impl_._has_bits_[0] &= ~0x00000004u;
3002 ::storaged_proto::IOPerfHistory* temp = _impl_.perf_history_;
3003 _impl_.perf_history_ = nullptr;
3004 return temp;
3005 }
_internal_mutable_perf_history()3006 inline ::storaged_proto::IOPerfHistory* StoragedProto::_internal_mutable_perf_history() {
3007 _impl_._has_bits_[0] |= 0x00000004u;
3008 if (_impl_.perf_history_ == nullptr) {
3009 auto* p = CreateMaybeMessage<::storaged_proto::IOPerfHistory>(GetArenaForAllocation());
3010 _impl_.perf_history_ = p;
3011 }
3012 return _impl_.perf_history_;
3013 }
mutable_perf_history()3014 inline ::storaged_proto::IOPerfHistory* StoragedProto::mutable_perf_history() {
3015 ::storaged_proto::IOPerfHistory* _msg = _internal_mutable_perf_history();
3016 // @@protoc_insertion_point(field_mutable:storaged_proto.StoragedProto.perf_history)
3017 return _msg;
3018 }
set_allocated_perf_history(::storaged_proto::IOPerfHistory * perf_history)3019 inline void StoragedProto::set_allocated_perf_history(::storaged_proto::IOPerfHistory* perf_history) {
3020 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
3021 if (message_arena == nullptr) {
3022 delete _impl_.perf_history_;
3023 }
3024 if (perf_history) {
3025 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
3026 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(perf_history);
3027 if (message_arena != submessage_arena) {
3028 perf_history = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
3029 message_arena, perf_history, submessage_arena);
3030 }
3031 _impl_._has_bits_[0] |= 0x00000004u;
3032 } else {
3033 _impl_._has_bits_[0] &= ~0x00000004u;
3034 }
3035 _impl_.perf_history_ = perf_history;
3036 // @@protoc_insertion_point(field_set_allocated:storaged_proto.StoragedProto.perf_history)
3037 }
3038
3039 // optional bytes padding = 5;
_internal_has_padding()3040 inline bool StoragedProto::_internal_has_padding() const {
3041 bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
3042 return value;
3043 }
has_padding()3044 inline bool StoragedProto::has_padding() const {
3045 return _internal_has_padding();
3046 }
clear_padding()3047 inline void StoragedProto::clear_padding() {
3048 _impl_.padding_.ClearToEmpty();
3049 _impl_._has_bits_[0] &= ~0x00000001u;
3050 }
padding()3051 inline const std::string& StoragedProto::padding() const {
3052 // @@protoc_insertion_point(field_get:storaged_proto.StoragedProto.padding)
3053 return _internal_padding();
3054 }
3055 template <typename ArgT0, typename... ArgT>
3056 inline PROTOBUF_ALWAYS_INLINE
set_padding(ArgT0 && arg0,ArgT...args)3057 void StoragedProto::set_padding(ArgT0&& arg0, ArgT... args) {
3058 _impl_._has_bits_[0] |= 0x00000001u;
3059 _impl_.padding_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
3060 // @@protoc_insertion_point(field_set:storaged_proto.StoragedProto.padding)
3061 }
mutable_padding()3062 inline std::string* StoragedProto::mutable_padding() {
3063 std::string* _s = _internal_mutable_padding();
3064 // @@protoc_insertion_point(field_mutable:storaged_proto.StoragedProto.padding)
3065 return _s;
3066 }
_internal_padding()3067 inline const std::string& StoragedProto::_internal_padding() const {
3068 return _impl_.padding_.Get();
3069 }
_internal_set_padding(const std::string & value)3070 inline void StoragedProto::_internal_set_padding(const std::string& value) {
3071 _impl_._has_bits_[0] |= 0x00000001u;
3072 _impl_.padding_.Set(value, GetArenaForAllocation());
3073 }
_internal_mutable_padding()3074 inline std::string* StoragedProto::_internal_mutable_padding() {
3075 _impl_._has_bits_[0] |= 0x00000001u;
3076 return _impl_.padding_.Mutable(GetArenaForAllocation());
3077 }
release_padding()3078 inline std::string* StoragedProto::release_padding() {
3079 // @@protoc_insertion_point(field_release:storaged_proto.StoragedProto.padding)
3080 if (!_internal_has_padding()) {
3081 return nullptr;
3082 }
3083 _impl_._has_bits_[0] &= ~0x00000001u;
3084 auto* p = _impl_.padding_.Release();
3085 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3086 if (_impl_.padding_.IsDefault()) {
3087 _impl_.padding_.Set("", GetArenaForAllocation());
3088 }
3089 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3090 return p;
3091 }
set_allocated_padding(std::string * padding)3092 inline void StoragedProto::set_allocated_padding(std::string* padding) {
3093 if (padding != nullptr) {
3094 _impl_._has_bits_[0] |= 0x00000001u;
3095 } else {
3096 _impl_._has_bits_[0] &= ~0x00000001u;
3097 }
3098 _impl_.padding_.SetAllocated(padding, GetArenaForAllocation());
3099 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3100 if (_impl_.padding_.IsDefault()) {
3101 _impl_.padding_.Set("", GetArenaForAllocation());
3102 }
3103 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3104 // @@protoc_insertion_point(field_set_allocated:storaged_proto.StoragedProto.padding)
3105 }
3106
3107 #ifdef __GNUC__
3108 #pragma GCC diagnostic pop
3109 #endif // __GNUC__
3110 // -------------------------------------------------------------------
3111
3112 // -------------------------------------------------------------------
3113
3114 // -------------------------------------------------------------------
3115
3116 // -------------------------------------------------------------------
3117
3118 // -------------------------------------------------------------------
3119
3120 // -------------------------------------------------------------------
3121
3122 // -------------------------------------------------------------------
3123
3124
3125 // @@protoc_insertion_point(namespace_scope)
3126
3127 } // namespace storaged_proto
3128
3129 // @@protoc_insertion_point(global_scope)
3130
3131 #include <google/protobuf/port_undef.inc>
3132 #endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_system_2fcore_2fstoraged_2fstoraged_2eproto
3133