1 // Generated by the protocol buffer compiler. DO NOT EDIT!
2 // source: system/core/storaged/storaged.proto
3
4 #include "system/core/storaged/storaged.pb.h"
5
6 #include <algorithm>
7 #include <cstdint>
8
9 #include <google/protobuf/io/coded_stream.h>
10 #include <google/protobuf/extension_set.h>
11 #include <google/protobuf/wire_format_lite.h>
12 #include <google/protobuf/io/zero_copy_stream_impl_lite.h>
13 // @@protoc_insertion_point(includes)
14 #include <google/protobuf/port_def.inc>
15
16 PROTOBUF_PRAGMA_INIT_SEG
17
18 namespace _pb = ::PROTOBUF_NAMESPACE_ID;
19 namespace _pbi = _pb::internal;
20
21 namespace storaged_proto {
IOUsage(::_pbi::ConstantInitialized)22 PROTOBUF_CONSTEXPR IOUsage::IOUsage(
23 ::_pbi::ConstantInitialized): _impl_{
24 /*decltype(_impl_._has_bits_)*/{}
25 , /*decltype(_impl_._cached_size_)*/{}
26 , /*decltype(_impl_.rd_fg_chg_on_)*/::uint64_t{0u}
27 , /*decltype(_impl_.rd_fg_chg_off_)*/::uint64_t{0u}
28 , /*decltype(_impl_.rd_bg_chg_on_)*/::uint64_t{0u}
29 , /*decltype(_impl_.rd_bg_chg_off_)*/::uint64_t{0u}
30 , /*decltype(_impl_.wr_fg_chg_on_)*/::uint64_t{0u}
31 , /*decltype(_impl_.wr_fg_chg_off_)*/::uint64_t{0u}
32 , /*decltype(_impl_.wr_bg_chg_on_)*/::uint64_t{0u}
33 , /*decltype(_impl_.wr_bg_chg_off_)*/::uint64_t{0u}} {}
34 struct IOUsageDefaultTypeInternal {
IOUsageDefaultTypeInternalstoraged_proto::IOUsageDefaultTypeInternal35 PROTOBUF_CONSTEXPR IOUsageDefaultTypeInternal()
36 : _instance(::_pbi::ConstantInitialized{}) {}
~IOUsageDefaultTypeInternalstoraged_proto::IOUsageDefaultTypeInternal37 ~IOUsageDefaultTypeInternal() {}
38 union { // NOLINT(misc-non-private-member-variables-in-classes)
39 IOUsage _instance;
40 };
41 };
42 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 IOUsageDefaultTypeInternal _IOUsage_default_instance_;
TaskIOUsage(::_pbi::ConstantInitialized)43 PROTOBUF_CONSTEXPR TaskIOUsage::TaskIOUsage(
44 ::_pbi::ConstantInitialized): _impl_{
45 /*decltype(_impl_._has_bits_)*/{}
46 , /*decltype(_impl_._cached_size_)*/{}
47 , /*decltype(_impl_.task_name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
48 , /*decltype(_impl_.ios_)*/nullptr} {}
49 struct TaskIOUsageDefaultTypeInternal {
TaskIOUsageDefaultTypeInternalstoraged_proto::TaskIOUsageDefaultTypeInternal50 PROTOBUF_CONSTEXPR TaskIOUsageDefaultTypeInternal()
51 : _instance(::_pbi::ConstantInitialized{}) {}
~TaskIOUsageDefaultTypeInternalstoraged_proto::TaskIOUsageDefaultTypeInternal52 ~TaskIOUsageDefaultTypeInternal() {}
53 union { // NOLINT(misc-non-private-member-variables-in-classes)
54 TaskIOUsage _instance;
55 };
56 };
57 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TaskIOUsageDefaultTypeInternal _TaskIOUsage_default_instance_;
UidRecord(::_pbi::ConstantInitialized)58 PROTOBUF_CONSTEXPR UidRecord::UidRecord(
59 ::_pbi::ConstantInitialized): _impl_{
60 /*decltype(_impl_._has_bits_)*/{}
61 , /*decltype(_impl_._cached_size_)*/{}
62 , /*decltype(_impl_.task_io_)*/{}
63 , /*decltype(_impl_.uid_name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
64 , /*decltype(_impl_.uid_io_)*/nullptr
65 , /*decltype(_impl_.user_id_)*/0u} {}
66 struct UidRecordDefaultTypeInternal {
UidRecordDefaultTypeInternalstoraged_proto::UidRecordDefaultTypeInternal67 PROTOBUF_CONSTEXPR UidRecordDefaultTypeInternal()
68 : _instance(::_pbi::ConstantInitialized{}) {}
~UidRecordDefaultTypeInternalstoraged_proto::UidRecordDefaultTypeInternal69 ~UidRecordDefaultTypeInternal() {}
70 union { // NOLINT(misc-non-private-member-variables-in-classes)
71 UidRecord _instance;
72 };
73 };
74 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 UidRecordDefaultTypeInternal _UidRecord_default_instance_;
UidIORecords(::_pbi::ConstantInitialized)75 PROTOBUF_CONSTEXPR UidIORecords::UidIORecords(
76 ::_pbi::ConstantInitialized): _impl_{
77 /*decltype(_impl_._has_bits_)*/{}
78 , /*decltype(_impl_._cached_size_)*/{}
79 , /*decltype(_impl_.entries_)*/{}
80 , /*decltype(_impl_.start_ts_)*/::uint64_t{0u}} {}
81 struct UidIORecordsDefaultTypeInternal {
UidIORecordsDefaultTypeInternalstoraged_proto::UidIORecordsDefaultTypeInternal82 PROTOBUF_CONSTEXPR UidIORecordsDefaultTypeInternal()
83 : _instance(::_pbi::ConstantInitialized{}) {}
~UidIORecordsDefaultTypeInternalstoraged_proto::UidIORecordsDefaultTypeInternal84 ~UidIORecordsDefaultTypeInternal() {}
85 union { // NOLINT(misc-non-private-member-variables-in-classes)
86 UidIORecords _instance;
87 };
88 };
89 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 UidIORecordsDefaultTypeInternal _UidIORecords_default_instance_;
UidIOItem(::_pbi::ConstantInitialized)90 PROTOBUF_CONSTEXPR UidIOItem::UidIOItem(
91 ::_pbi::ConstantInitialized): _impl_{
92 /*decltype(_impl_._has_bits_)*/{}
93 , /*decltype(_impl_._cached_size_)*/{}
94 , /*decltype(_impl_.records_)*/nullptr
95 , /*decltype(_impl_.end_ts_)*/::uint64_t{0u}} {}
96 struct UidIOItemDefaultTypeInternal {
UidIOItemDefaultTypeInternalstoraged_proto::UidIOItemDefaultTypeInternal97 PROTOBUF_CONSTEXPR UidIOItemDefaultTypeInternal()
98 : _instance(::_pbi::ConstantInitialized{}) {}
~UidIOItemDefaultTypeInternalstoraged_proto::UidIOItemDefaultTypeInternal99 ~UidIOItemDefaultTypeInternal() {}
100 union { // NOLINT(misc-non-private-member-variables-in-classes)
101 UidIOItem _instance;
102 };
103 };
104 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 UidIOItemDefaultTypeInternal _UidIOItem_default_instance_;
UidIOUsage(::_pbi::ConstantInitialized)105 PROTOBUF_CONSTEXPR UidIOUsage::UidIOUsage(
106 ::_pbi::ConstantInitialized): _impl_{
107 /*decltype(_impl_.uid_io_items_)*/{}
108 , /*decltype(_impl_._cached_size_)*/{}} {}
109 struct UidIOUsageDefaultTypeInternal {
UidIOUsageDefaultTypeInternalstoraged_proto::UidIOUsageDefaultTypeInternal110 PROTOBUF_CONSTEXPR UidIOUsageDefaultTypeInternal()
111 : _instance(::_pbi::ConstantInitialized{}) {}
~UidIOUsageDefaultTypeInternalstoraged_proto::UidIOUsageDefaultTypeInternal112 ~UidIOUsageDefaultTypeInternal() {}
113 union { // NOLINT(misc-non-private-member-variables-in-classes)
114 UidIOUsage _instance;
115 };
116 };
117 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 UidIOUsageDefaultTypeInternal _UidIOUsage_default_instance_;
IOPerfHistory(::_pbi::ConstantInitialized)118 PROTOBUF_CONSTEXPR IOPerfHistory::IOPerfHistory(
119 ::_pbi::ConstantInitialized): _impl_{
120 /*decltype(_impl_._has_bits_)*/{}
121 , /*decltype(_impl_._cached_size_)*/{}
122 , /*decltype(_impl_.recent_perf_)*/{}
123 , /*decltype(_impl_.daily_perf_)*/{}
124 , /*decltype(_impl_.weekly_perf_)*/{}
125 , /*decltype(_impl_.day_start_sec_)*/::uint64_t{0u}
126 , /*decltype(_impl_.nr_samples_)*/0u
127 , /*decltype(_impl_.nr_days_)*/0u
128 , /*decltype(_impl_.nr_weeks_)*/0u} {}
129 struct IOPerfHistoryDefaultTypeInternal {
IOPerfHistoryDefaultTypeInternalstoraged_proto::IOPerfHistoryDefaultTypeInternal130 PROTOBUF_CONSTEXPR IOPerfHistoryDefaultTypeInternal()
131 : _instance(::_pbi::ConstantInitialized{}) {}
~IOPerfHistoryDefaultTypeInternalstoraged_proto::IOPerfHistoryDefaultTypeInternal132 ~IOPerfHistoryDefaultTypeInternal() {}
133 union { // NOLINT(misc-non-private-member-variables-in-classes)
134 IOPerfHistory _instance;
135 };
136 };
137 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 IOPerfHistoryDefaultTypeInternal _IOPerfHistory_default_instance_;
StoragedProto(::_pbi::ConstantInitialized)138 PROTOBUF_CONSTEXPR StoragedProto::StoragedProto(
139 ::_pbi::ConstantInitialized): _impl_{
140 /*decltype(_impl_._has_bits_)*/{}
141 , /*decltype(_impl_._cached_size_)*/{}
142 , /*decltype(_impl_.padding_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
143 , /*decltype(_impl_.uid_io_usage_)*/nullptr
144 , /*decltype(_impl_.perf_history_)*/nullptr
145 , /*decltype(_impl_.crc_)*/0u
146 , /*decltype(_impl_.version_)*/0u} {}
147 struct StoragedProtoDefaultTypeInternal {
StoragedProtoDefaultTypeInternalstoraged_proto::StoragedProtoDefaultTypeInternal148 PROTOBUF_CONSTEXPR StoragedProtoDefaultTypeInternal()
149 : _instance(::_pbi::ConstantInitialized{}) {}
~StoragedProtoDefaultTypeInternalstoraged_proto::StoragedProtoDefaultTypeInternal150 ~StoragedProtoDefaultTypeInternal() {}
151 union { // NOLINT(misc-non-private-member-variables-in-classes)
152 StoragedProto _instance;
153 };
154 };
155 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 StoragedProtoDefaultTypeInternal _StoragedProto_default_instance_;
156 } // namespace storaged_proto
157 namespace storaged_proto {
158
159 // ===================================================================
160
161 class IOUsage::_Internal {
162 public:
163 using HasBits = decltype(std::declval<IOUsage>()._impl_._has_bits_);
set_has_rd_fg_chg_on(HasBits * has_bits)164 static void set_has_rd_fg_chg_on(HasBits* has_bits) {
165 (*has_bits)[0] |= 1u;
166 }
set_has_rd_fg_chg_off(HasBits * has_bits)167 static void set_has_rd_fg_chg_off(HasBits* has_bits) {
168 (*has_bits)[0] |= 2u;
169 }
set_has_rd_bg_chg_on(HasBits * has_bits)170 static void set_has_rd_bg_chg_on(HasBits* has_bits) {
171 (*has_bits)[0] |= 4u;
172 }
set_has_rd_bg_chg_off(HasBits * has_bits)173 static void set_has_rd_bg_chg_off(HasBits* has_bits) {
174 (*has_bits)[0] |= 8u;
175 }
set_has_wr_fg_chg_on(HasBits * has_bits)176 static void set_has_wr_fg_chg_on(HasBits* has_bits) {
177 (*has_bits)[0] |= 16u;
178 }
set_has_wr_fg_chg_off(HasBits * has_bits)179 static void set_has_wr_fg_chg_off(HasBits* has_bits) {
180 (*has_bits)[0] |= 32u;
181 }
set_has_wr_bg_chg_on(HasBits * has_bits)182 static void set_has_wr_bg_chg_on(HasBits* has_bits) {
183 (*has_bits)[0] |= 64u;
184 }
set_has_wr_bg_chg_off(HasBits * has_bits)185 static void set_has_wr_bg_chg_off(HasBits* has_bits) {
186 (*has_bits)[0] |= 128u;
187 }
188 };
189
IOUsage(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)190 IOUsage::IOUsage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
191 bool is_message_owned)
192 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
193 SharedCtor(arena, is_message_owned);
194 // @@protoc_insertion_point(arena_constructor:storaged_proto.IOUsage)
195 }
IOUsage(const IOUsage & from)196 IOUsage::IOUsage(const IOUsage& from)
197 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
198 IOUsage* const _this = this; (void)_this;
199 new (&_impl_) Impl_{
200 decltype(_impl_._has_bits_){from._impl_._has_bits_}
201 , /*decltype(_impl_._cached_size_)*/{}
202 , decltype(_impl_.rd_fg_chg_on_){}
203 , decltype(_impl_.rd_fg_chg_off_){}
204 , decltype(_impl_.rd_bg_chg_on_){}
205 , decltype(_impl_.rd_bg_chg_off_){}
206 , decltype(_impl_.wr_fg_chg_on_){}
207 , decltype(_impl_.wr_fg_chg_off_){}
208 , decltype(_impl_.wr_bg_chg_on_){}
209 , decltype(_impl_.wr_bg_chg_off_){}};
210
211 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
212 ::memcpy(&_impl_.rd_fg_chg_on_, &from._impl_.rd_fg_chg_on_,
213 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.wr_bg_chg_off_) -
214 reinterpret_cast<char*>(&_impl_.rd_fg_chg_on_)) + sizeof(_impl_.wr_bg_chg_off_));
215 // @@protoc_insertion_point(copy_constructor:storaged_proto.IOUsage)
216 }
217
SharedCtor(::_pb::Arena * arena,bool is_message_owned)218 inline void IOUsage::SharedCtor(
219 ::_pb::Arena* arena, bool is_message_owned) {
220 (void)arena;
221 (void)is_message_owned;
222 new (&_impl_) Impl_{
223 decltype(_impl_._has_bits_){}
224 , /*decltype(_impl_._cached_size_)*/{}
225 , decltype(_impl_.rd_fg_chg_on_){::uint64_t{0u}}
226 , decltype(_impl_.rd_fg_chg_off_){::uint64_t{0u}}
227 , decltype(_impl_.rd_bg_chg_on_){::uint64_t{0u}}
228 , decltype(_impl_.rd_bg_chg_off_){::uint64_t{0u}}
229 , decltype(_impl_.wr_fg_chg_on_){::uint64_t{0u}}
230 , decltype(_impl_.wr_fg_chg_off_){::uint64_t{0u}}
231 , decltype(_impl_.wr_bg_chg_on_){::uint64_t{0u}}
232 , decltype(_impl_.wr_bg_chg_off_){::uint64_t{0u}}
233 };
234 }
235
~IOUsage()236 IOUsage::~IOUsage() {
237 // @@protoc_insertion_point(destructor:storaged_proto.IOUsage)
238 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
239 (void)arena;
240 return;
241 }
242 SharedDtor();
243 }
244
SharedDtor()245 inline void IOUsage::SharedDtor() {
246 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
247 }
248
SetCachedSize(int size) const249 void IOUsage::SetCachedSize(int size) const {
250 _impl_._cached_size_.Set(size);
251 }
252
Clear()253 void IOUsage::Clear() {
254 // @@protoc_insertion_point(message_clear_start:storaged_proto.IOUsage)
255 ::uint32_t cached_has_bits = 0;
256 // Prevent compiler warnings about cached_has_bits being unused
257 (void) cached_has_bits;
258
259 cached_has_bits = _impl_._has_bits_[0];
260 if (cached_has_bits & 0x000000ffu) {
261 ::memset(&_impl_.rd_fg_chg_on_, 0, static_cast<size_t>(
262 reinterpret_cast<char*>(&_impl_.wr_bg_chg_off_) -
263 reinterpret_cast<char*>(&_impl_.rd_fg_chg_on_)) + sizeof(_impl_.wr_bg_chg_off_));
264 }
265 _impl_._has_bits_.Clear();
266 _internal_metadata_.Clear<std::string>();
267 }
268
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)269 const char* IOUsage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
270 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
271 _Internal::HasBits has_bits{};
272 while (!ctx->Done(&ptr)) {
273 ::uint32_t tag;
274 ptr = ::_pbi::ReadTag(ptr, &tag);
275 switch (tag >> 3) {
276 // optional uint64 rd_fg_chg_on = 1;
277 case 1:
278 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
279 _Internal::set_has_rd_fg_chg_on(&has_bits);
280 _impl_.rd_fg_chg_on_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
281 CHK_(ptr);
282 } else {
283 goto handle_unusual;
284 }
285 continue;
286 // optional uint64 rd_fg_chg_off = 2;
287 case 2:
288 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
289 _Internal::set_has_rd_fg_chg_off(&has_bits);
290 _impl_.rd_fg_chg_off_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
291 CHK_(ptr);
292 } else {
293 goto handle_unusual;
294 }
295 continue;
296 // optional uint64 rd_bg_chg_on = 3;
297 case 3:
298 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
299 _Internal::set_has_rd_bg_chg_on(&has_bits);
300 _impl_.rd_bg_chg_on_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
301 CHK_(ptr);
302 } else {
303 goto handle_unusual;
304 }
305 continue;
306 // optional uint64 rd_bg_chg_off = 4;
307 case 4:
308 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
309 _Internal::set_has_rd_bg_chg_off(&has_bits);
310 _impl_.rd_bg_chg_off_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
311 CHK_(ptr);
312 } else {
313 goto handle_unusual;
314 }
315 continue;
316 // optional uint64 wr_fg_chg_on = 5;
317 case 5:
318 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
319 _Internal::set_has_wr_fg_chg_on(&has_bits);
320 _impl_.wr_fg_chg_on_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
321 CHK_(ptr);
322 } else {
323 goto handle_unusual;
324 }
325 continue;
326 // optional uint64 wr_fg_chg_off = 6;
327 case 6:
328 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 48)) {
329 _Internal::set_has_wr_fg_chg_off(&has_bits);
330 _impl_.wr_fg_chg_off_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
331 CHK_(ptr);
332 } else {
333 goto handle_unusual;
334 }
335 continue;
336 // optional uint64 wr_bg_chg_on = 7;
337 case 7:
338 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 56)) {
339 _Internal::set_has_wr_bg_chg_on(&has_bits);
340 _impl_.wr_bg_chg_on_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
341 CHK_(ptr);
342 } else {
343 goto handle_unusual;
344 }
345 continue;
346 // optional uint64 wr_bg_chg_off = 8;
347 case 8:
348 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 64)) {
349 _Internal::set_has_wr_bg_chg_off(&has_bits);
350 _impl_.wr_bg_chg_off_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
351 CHK_(ptr);
352 } else {
353 goto handle_unusual;
354 }
355 continue;
356 default:
357 goto handle_unusual;
358 } // switch
359 handle_unusual:
360 if ((tag == 0) || ((tag & 7) == 4)) {
361 CHK_(ptr);
362 ctx->SetLastTag(tag);
363 goto message_done;
364 }
365 ptr = UnknownFieldParse(
366 tag,
367 _internal_metadata_.mutable_unknown_fields<std::string>(),
368 ptr, ctx);
369 CHK_(ptr != nullptr);
370 } // while
371 message_done:
372 _impl_._has_bits_.Or(has_bits);
373 return ptr;
374 failure:
375 ptr = nullptr;
376 goto message_done;
377 #undef CHK_
378 }
379
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const380 ::uint8_t* IOUsage::_InternalSerialize(
381 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
382 // @@protoc_insertion_point(serialize_to_array_start:storaged_proto.IOUsage)
383 ::uint32_t cached_has_bits = 0;
384 (void) cached_has_bits;
385
386 cached_has_bits = _impl_._has_bits_[0];
387 // optional uint64 rd_fg_chg_on = 1;
388 if (cached_has_bits & 0x00000001u) {
389 target = stream->EnsureSpace(target);
390 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_rd_fg_chg_on(), target);
391 }
392
393 // optional uint64 rd_fg_chg_off = 2;
394 if (cached_has_bits & 0x00000002u) {
395 target = stream->EnsureSpace(target);
396 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(2, this->_internal_rd_fg_chg_off(), target);
397 }
398
399 // optional uint64 rd_bg_chg_on = 3;
400 if (cached_has_bits & 0x00000004u) {
401 target = stream->EnsureSpace(target);
402 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(3, this->_internal_rd_bg_chg_on(), target);
403 }
404
405 // optional uint64 rd_bg_chg_off = 4;
406 if (cached_has_bits & 0x00000008u) {
407 target = stream->EnsureSpace(target);
408 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(4, this->_internal_rd_bg_chg_off(), target);
409 }
410
411 // optional uint64 wr_fg_chg_on = 5;
412 if (cached_has_bits & 0x00000010u) {
413 target = stream->EnsureSpace(target);
414 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(5, this->_internal_wr_fg_chg_on(), target);
415 }
416
417 // optional uint64 wr_fg_chg_off = 6;
418 if (cached_has_bits & 0x00000020u) {
419 target = stream->EnsureSpace(target);
420 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(6, this->_internal_wr_fg_chg_off(), target);
421 }
422
423 // optional uint64 wr_bg_chg_on = 7;
424 if (cached_has_bits & 0x00000040u) {
425 target = stream->EnsureSpace(target);
426 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(7, this->_internal_wr_bg_chg_on(), target);
427 }
428
429 // optional uint64 wr_bg_chg_off = 8;
430 if (cached_has_bits & 0x00000080u) {
431 target = stream->EnsureSpace(target);
432 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(8, this->_internal_wr_bg_chg_off(), target);
433 }
434
435 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
436 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
437 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
438 }
439 // @@protoc_insertion_point(serialize_to_array_end:storaged_proto.IOUsage)
440 return target;
441 }
442
ByteSizeLong() const443 size_t IOUsage::ByteSizeLong() const {
444 // @@protoc_insertion_point(message_byte_size_start:storaged_proto.IOUsage)
445 size_t total_size = 0;
446
447 ::uint32_t cached_has_bits = 0;
448 // Prevent compiler warnings about cached_has_bits being unused
449 (void) cached_has_bits;
450
451 cached_has_bits = _impl_._has_bits_[0];
452 if (cached_has_bits & 0x000000ffu) {
453 // optional uint64 rd_fg_chg_on = 1;
454 if (cached_has_bits & 0x00000001u) {
455 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_rd_fg_chg_on());
456 }
457
458 // optional uint64 rd_fg_chg_off = 2;
459 if (cached_has_bits & 0x00000002u) {
460 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_rd_fg_chg_off());
461 }
462
463 // optional uint64 rd_bg_chg_on = 3;
464 if (cached_has_bits & 0x00000004u) {
465 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_rd_bg_chg_on());
466 }
467
468 // optional uint64 rd_bg_chg_off = 4;
469 if (cached_has_bits & 0x00000008u) {
470 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_rd_bg_chg_off());
471 }
472
473 // optional uint64 wr_fg_chg_on = 5;
474 if (cached_has_bits & 0x00000010u) {
475 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_wr_fg_chg_on());
476 }
477
478 // optional uint64 wr_fg_chg_off = 6;
479 if (cached_has_bits & 0x00000020u) {
480 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_wr_fg_chg_off());
481 }
482
483 // optional uint64 wr_bg_chg_on = 7;
484 if (cached_has_bits & 0x00000040u) {
485 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_wr_bg_chg_on());
486 }
487
488 // optional uint64 wr_bg_chg_off = 8;
489 if (cached_has_bits & 0x00000080u) {
490 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_wr_bg_chg_off());
491 }
492
493 }
494 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
495 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
496 }
497 int cached_size = ::_pbi::ToCachedSize(total_size);
498 SetCachedSize(cached_size);
499 return total_size;
500 }
501
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)502 void IOUsage::CheckTypeAndMergeFrom(
503 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
504 MergeFrom(*::_pbi::DownCast<const IOUsage*>(
505 &from));
506 }
507
MergeFrom(const IOUsage & from)508 void IOUsage::MergeFrom(const IOUsage& from) {
509 IOUsage* const _this = this;
510 // @@protoc_insertion_point(class_specific_merge_from_start:storaged_proto.IOUsage)
511 GOOGLE_DCHECK_NE(&from, _this);
512 ::uint32_t cached_has_bits = 0;
513 (void) cached_has_bits;
514
515 cached_has_bits = from._impl_._has_bits_[0];
516 if (cached_has_bits & 0x000000ffu) {
517 if (cached_has_bits & 0x00000001u) {
518 _this->_impl_.rd_fg_chg_on_ = from._impl_.rd_fg_chg_on_;
519 }
520 if (cached_has_bits & 0x00000002u) {
521 _this->_impl_.rd_fg_chg_off_ = from._impl_.rd_fg_chg_off_;
522 }
523 if (cached_has_bits & 0x00000004u) {
524 _this->_impl_.rd_bg_chg_on_ = from._impl_.rd_bg_chg_on_;
525 }
526 if (cached_has_bits & 0x00000008u) {
527 _this->_impl_.rd_bg_chg_off_ = from._impl_.rd_bg_chg_off_;
528 }
529 if (cached_has_bits & 0x00000010u) {
530 _this->_impl_.wr_fg_chg_on_ = from._impl_.wr_fg_chg_on_;
531 }
532 if (cached_has_bits & 0x00000020u) {
533 _this->_impl_.wr_fg_chg_off_ = from._impl_.wr_fg_chg_off_;
534 }
535 if (cached_has_bits & 0x00000040u) {
536 _this->_impl_.wr_bg_chg_on_ = from._impl_.wr_bg_chg_on_;
537 }
538 if (cached_has_bits & 0x00000080u) {
539 _this->_impl_.wr_bg_chg_off_ = from._impl_.wr_bg_chg_off_;
540 }
541 _this->_impl_._has_bits_[0] |= cached_has_bits;
542 }
543 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
544 }
545
CopyFrom(const IOUsage & from)546 void IOUsage::CopyFrom(const IOUsage& from) {
547 // @@protoc_insertion_point(class_specific_copy_from_start:storaged_proto.IOUsage)
548 if (&from == this) return;
549 Clear();
550 MergeFrom(from);
551 }
552
IsInitialized() const553 bool IOUsage::IsInitialized() const {
554 return true;
555 }
556
InternalSwap(IOUsage * other)557 void IOUsage::InternalSwap(IOUsage* other) {
558 using std::swap;
559 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
560 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
561 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
562 PROTOBUF_FIELD_OFFSET(IOUsage, _impl_.wr_bg_chg_off_)
563 + sizeof(IOUsage::_impl_.wr_bg_chg_off_) // NOLINT
564 - PROTOBUF_FIELD_OFFSET(IOUsage, _impl_.rd_fg_chg_on_)>(
565 reinterpret_cast<char*>(&_impl_.rd_fg_chg_on_),
566 reinterpret_cast<char*>(&other->_impl_.rd_fg_chg_on_));
567 }
568
GetTypeName() const569 std::string IOUsage::GetTypeName() const {
570 return "storaged_proto.IOUsage";
571 }
572
573
574 // ===================================================================
575
576 class TaskIOUsage::_Internal {
577 public:
578 using HasBits = decltype(std::declval<TaskIOUsage>()._impl_._has_bits_);
set_has_task_name(HasBits * has_bits)579 static void set_has_task_name(HasBits* has_bits) {
580 (*has_bits)[0] |= 1u;
581 }
582 static const ::storaged_proto::IOUsage& ios(const TaskIOUsage* msg);
set_has_ios(HasBits * has_bits)583 static void set_has_ios(HasBits* has_bits) {
584 (*has_bits)[0] |= 2u;
585 }
586 };
587
588 const ::storaged_proto::IOUsage&
ios(const TaskIOUsage * msg)589 TaskIOUsage::_Internal::ios(const TaskIOUsage* msg) {
590 return *msg->_impl_.ios_;
591 }
TaskIOUsage(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)592 TaskIOUsage::TaskIOUsage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
593 bool is_message_owned)
594 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
595 SharedCtor(arena, is_message_owned);
596 // @@protoc_insertion_point(arena_constructor:storaged_proto.TaskIOUsage)
597 }
TaskIOUsage(const TaskIOUsage & from)598 TaskIOUsage::TaskIOUsage(const TaskIOUsage& from)
599 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
600 TaskIOUsage* const _this = this; (void)_this;
601 new (&_impl_) Impl_{
602 decltype(_impl_._has_bits_){from._impl_._has_bits_}
603 , /*decltype(_impl_._cached_size_)*/{}
604 , decltype(_impl_.task_name_){}
605 , decltype(_impl_.ios_){nullptr}};
606
607 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
608 _impl_.task_name_.InitDefault();
609 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
610 _impl_.task_name_.Set("", GetArenaForAllocation());
611 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
612 if (from._internal_has_task_name()) {
613 _this->_impl_.task_name_.Set(from._internal_task_name(),
614 _this->GetArenaForAllocation());
615 }
616 if (from._internal_has_ios()) {
617 _this->_impl_.ios_ = new ::storaged_proto::IOUsage(*from._impl_.ios_);
618 }
619 // @@protoc_insertion_point(copy_constructor:storaged_proto.TaskIOUsage)
620 }
621
SharedCtor(::_pb::Arena * arena,bool is_message_owned)622 inline void TaskIOUsage::SharedCtor(
623 ::_pb::Arena* arena, bool is_message_owned) {
624 (void)arena;
625 (void)is_message_owned;
626 new (&_impl_) Impl_{
627 decltype(_impl_._has_bits_){}
628 , /*decltype(_impl_._cached_size_)*/{}
629 , decltype(_impl_.task_name_){}
630 , decltype(_impl_.ios_){nullptr}
631 };
632 _impl_.task_name_.InitDefault();
633 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
634 _impl_.task_name_.Set("", GetArenaForAllocation());
635 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
636 }
637
~TaskIOUsage()638 TaskIOUsage::~TaskIOUsage() {
639 // @@protoc_insertion_point(destructor:storaged_proto.TaskIOUsage)
640 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
641 (void)arena;
642 return;
643 }
644 SharedDtor();
645 }
646
SharedDtor()647 inline void TaskIOUsage::SharedDtor() {
648 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
649 _impl_.task_name_.Destroy();
650 if (this != internal_default_instance()) delete _impl_.ios_;
651 }
652
SetCachedSize(int size) const653 void TaskIOUsage::SetCachedSize(int size) const {
654 _impl_._cached_size_.Set(size);
655 }
656
Clear()657 void TaskIOUsage::Clear() {
658 // @@protoc_insertion_point(message_clear_start:storaged_proto.TaskIOUsage)
659 ::uint32_t cached_has_bits = 0;
660 // Prevent compiler warnings about cached_has_bits being unused
661 (void) cached_has_bits;
662
663 cached_has_bits = _impl_._has_bits_[0];
664 if (cached_has_bits & 0x00000003u) {
665 if (cached_has_bits & 0x00000001u) {
666 _impl_.task_name_.ClearNonDefaultToEmpty();
667 }
668 if (cached_has_bits & 0x00000002u) {
669 GOOGLE_DCHECK(_impl_.ios_ != nullptr);
670 _impl_.ios_->Clear();
671 }
672 }
673 _impl_._has_bits_.Clear();
674 _internal_metadata_.Clear<std::string>();
675 }
676
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)677 const char* TaskIOUsage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
678 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
679 _Internal::HasBits has_bits{};
680 while (!ctx->Done(&ptr)) {
681 ::uint32_t tag;
682 ptr = ::_pbi::ReadTag(ptr, &tag);
683 switch (tag >> 3) {
684 // optional string task_name = 1;
685 case 1:
686 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
687 auto str = _internal_mutable_task_name();
688 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
689 CHK_(ptr);
690 } else {
691 goto handle_unusual;
692 }
693 continue;
694 // optional .storaged_proto.IOUsage ios = 2;
695 case 2:
696 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
697 ptr = ctx->ParseMessage(_internal_mutable_ios(), ptr);
698 CHK_(ptr);
699 } else {
700 goto handle_unusual;
701 }
702 continue;
703 default:
704 goto handle_unusual;
705 } // switch
706 handle_unusual:
707 if ((tag == 0) || ((tag & 7) == 4)) {
708 CHK_(ptr);
709 ctx->SetLastTag(tag);
710 goto message_done;
711 }
712 ptr = UnknownFieldParse(
713 tag,
714 _internal_metadata_.mutable_unknown_fields<std::string>(),
715 ptr, ctx);
716 CHK_(ptr != nullptr);
717 } // while
718 message_done:
719 _impl_._has_bits_.Or(has_bits);
720 return ptr;
721 failure:
722 ptr = nullptr;
723 goto message_done;
724 #undef CHK_
725 }
726
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const727 ::uint8_t* TaskIOUsage::_InternalSerialize(
728 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
729 // @@protoc_insertion_point(serialize_to_array_start:storaged_proto.TaskIOUsage)
730 ::uint32_t cached_has_bits = 0;
731 (void) cached_has_bits;
732
733 cached_has_bits = _impl_._has_bits_[0];
734 // optional string task_name = 1;
735 if (cached_has_bits & 0x00000001u) {
736 target = stream->WriteStringMaybeAliased(
737 1, this->_internal_task_name(), target);
738 }
739
740 // optional .storaged_proto.IOUsage ios = 2;
741 if (cached_has_bits & 0x00000002u) {
742 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
743 InternalWriteMessage(2, _Internal::ios(this),
744 _Internal::ios(this).GetCachedSize(), target, stream);
745 }
746
747 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
748 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
749 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
750 }
751 // @@protoc_insertion_point(serialize_to_array_end:storaged_proto.TaskIOUsage)
752 return target;
753 }
754
ByteSizeLong() const755 size_t TaskIOUsage::ByteSizeLong() const {
756 // @@protoc_insertion_point(message_byte_size_start:storaged_proto.TaskIOUsage)
757 size_t total_size = 0;
758
759 ::uint32_t cached_has_bits = 0;
760 // Prevent compiler warnings about cached_has_bits being unused
761 (void) cached_has_bits;
762
763 cached_has_bits = _impl_._has_bits_[0];
764 if (cached_has_bits & 0x00000003u) {
765 // optional string task_name = 1;
766 if (cached_has_bits & 0x00000001u) {
767 total_size += 1 +
768 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
769 this->_internal_task_name());
770 }
771
772 // optional .storaged_proto.IOUsage ios = 2;
773 if (cached_has_bits & 0x00000002u) {
774 total_size += 1 +
775 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
776 *_impl_.ios_);
777 }
778
779 }
780 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
781 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
782 }
783 int cached_size = ::_pbi::ToCachedSize(total_size);
784 SetCachedSize(cached_size);
785 return total_size;
786 }
787
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)788 void TaskIOUsage::CheckTypeAndMergeFrom(
789 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
790 MergeFrom(*::_pbi::DownCast<const TaskIOUsage*>(
791 &from));
792 }
793
MergeFrom(const TaskIOUsage & from)794 void TaskIOUsage::MergeFrom(const TaskIOUsage& from) {
795 TaskIOUsage* const _this = this;
796 // @@protoc_insertion_point(class_specific_merge_from_start:storaged_proto.TaskIOUsage)
797 GOOGLE_DCHECK_NE(&from, _this);
798 ::uint32_t cached_has_bits = 0;
799 (void) cached_has_bits;
800
801 cached_has_bits = from._impl_._has_bits_[0];
802 if (cached_has_bits & 0x00000003u) {
803 if (cached_has_bits & 0x00000001u) {
804 _this->_internal_set_task_name(from._internal_task_name());
805 }
806 if (cached_has_bits & 0x00000002u) {
807 _this->_internal_mutable_ios()->::storaged_proto::IOUsage::MergeFrom(
808 from._internal_ios());
809 }
810 }
811 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
812 }
813
CopyFrom(const TaskIOUsage & from)814 void TaskIOUsage::CopyFrom(const TaskIOUsage& from) {
815 // @@protoc_insertion_point(class_specific_copy_from_start:storaged_proto.TaskIOUsage)
816 if (&from == this) return;
817 Clear();
818 MergeFrom(from);
819 }
820
IsInitialized() const821 bool TaskIOUsage::IsInitialized() const {
822 return true;
823 }
824
InternalSwap(TaskIOUsage * other)825 void TaskIOUsage::InternalSwap(TaskIOUsage* other) {
826 using std::swap;
827 auto* lhs_arena = GetArenaForAllocation();
828 auto* rhs_arena = other->GetArenaForAllocation();
829 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
830 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
831 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
832 &_impl_.task_name_, lhs_arena,
833 &other->_impl_.task_name_, rhs_arena
834 );
835 swap(_impl_.ios_, other->_impl_.ios_);
836 }
837
GetTypeName() const838 std::string TaskIOUsage::GetTypeName() const {
839 return "storaged_proto.TaskIOUsage";
840 }
841
842
843 // ===================================================================
844
845 class UidRecord::_Internal {
846 public:
847 using HasBits = decltype(std::declval<UidRecord>()._impl_._has_bits_);
set_has_uid_name(HasBits * has_bits)848 static void set_has_uid_name(HasBits* has_bits) {
849 (*has_bits)[0] |= 1u;
850 }
set_has_user_id(HasBits * has_bits)851 static void set_has_user_id(HasBits* has_bits) {
852 (*has_bits)[0] |= 4u;
853 }
854 static const ::storaged_proto::IOUsage& uid_io(const UidRecord* msg);
set_has_uid_io(HasBits * has_bits)855 static void set_has_uid_io(HasBits* has_bits) {
856 (*has_bits)[0] |= 2u;
857 }
858 };
859
860 const ::storaged_proto::IOUsage&
uid_io(const UidRecord * msg)861 UidRecord::_Internal::uid_io(const UidRecord* msg) {
862 return *msg->_impl_.uid_io_;
863 }
UidRecord(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)864 UidRecord::UidRecord(::PROTOBUF_NAMESPACE_ID::Arena* arena,
865 bool is_message_owned)
866 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
867 SharedCtor(arena, is_message_owned);
868 // @@protoc_insertion_point(arena_constructor:storaged_proto.UidRecord)
869 }
UidRecord(const UidRecord & from)870 UidRecord::UidRecord(const UidRecord& from)
871 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
872 UidRecord* const _this = this; (void)_this;
873 new (&_impl_) Impl_{
874 decltype(_impl_._has_bits_){from._impl_._has_bits_}
875 , /*decltype(_impl_._cached_size_)*/{}
876 , decltype(_impl_.task_io_){from._impl_.task_io_}
877 , decltype(_impl_.uid_name_){}
878 , decltype(_impl_.uid_io_){nullptr}
879 , decltype(_impl_.user_id_){}};
880
881 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
882 _impl_.uid_name_.InitDefault();
883 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
884 _impl_.uid_name_.Set("", GetArenaForAllocation());
885 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
886 if (from._internal_has_uid_name()) {
887 _this->_impl_.uid_name_.Set(from._internal_uid_name(),
888 _this->GetArenaForAllocation());
889 }
890 if (from._internal_has_uid_io()) {
891 _this->_impl_.uid_io_ = new ::storaged_proto::IOUsage(*from._impl_.uid_io_);
892 }
893 _this->_impl_.user_id_ = from._impl_.user_id_;
894 // @@protoc_insertion_point(copy_constructor:storaged_proto.UidRecord)
895 }
896
SharedCtor(::_pb::Arena * arena,bool is_message_owned)897 inline void UidRecord::SharedCtor(
898 ::_pb::Arena* arena, bool is_message_owned) {
899 (void)arena;
900 (void)is_message_owned;
901 new (&_impl_) Impl_{
902 decltype(_impl_._has_bits_){}
903 , /*decltype(_impl_._cached_size_)*/{}
904 , decltype(_impl_.task_io_){arena}
905 , decltype(_impl_.uid_name_){}
906 , decltype(_impl_.uid_io_){nullptr}
907 , decltype(_impl_.user_id_){0u}
908 };
909 _impl_.uid_name_.InitDefault();
910 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
911 _impl_.uid_name_.Set("", GetArenaForAllocation());
912 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
913 }
914
~UidRecord()915 UidRecord::~UidRecord() {
916 // @@protoc_insertion_point(destructor:storaged_proto.UidRecord)
917 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
918 (void)arena;
919 return;
920 }
921 SharedDtor();
922 }
923
SharedDtor()924 inline void UidRecord::SharedDtor() {
925 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
926 _impl_.task_io_.~RepeatedPtrField();
927 _impl_.uid_name_.Destroy();
928 if (this != internal_default_instance()) delete _impl_.uid_io_;
929 }
930
SetCachedSize(int size) const931 void UidRecord::SetCachedSize(int size) const {
932 _impl_._cached_size_.Set(size);
933 }
934
Clear()935 void UidRecord::Clear() {
936 // @@protoc_insertion_point(message_clear_start:storaged_proto.UidRecord)
937 ::uint32_t cached_has_bits = 0;
938 // Prevent compiler warnings about cached_has_bits being unused
939 (void) cached_has_bits;
940
941 _impl_.task_io_.Clear();
942 cached_has_bits = _impl_._has_bits_[0];
943 if (cached_has_bits & 0x00000003u) {
944 if (cached_has_bits & 0x00000001u) {
945 _impl_.uid_name_.ClearNonDefaultToEmpty();
946 }
947 if (cached_has_bits & 0x00000002u) {
948 GOOGLE_DCHECK(_impl_.uid_io_ != nullptr);
949 _impl_.uid_io_->Clear();
950 }
951 }
952 _impl_.user_id_ = 0u;
953 _impl_._has_bits_.Clear();
954 _internal_metadata_.Clear<std::string>();
955 }
956
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)957 const char* UidRecord::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
958 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
959 _Internal::HasBits has_bits{};
960 while (!ctx->Done(&ptr)) {
961 ::uint32_t tag;
962 ptr = ::_pbi::ReadTag(ptr, &tag);
963 switch (tag >> 3) {
964 // optional string uid_name = 1;
965 case 1:
966 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
967 auto str = _internal_mutable_uid_name();
968 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
969 CHK_(ptr);
970 } else {
971 goto handle_unusual;
972 }
973 continue;
974 // optional uint32 user_id = 2;
975 case 2:
976 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
977 _Internal::set_has_user_id(&has_bits);
978 _impl_.user_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
979 CHK_(ptr);
980 } else {
981 goto handle_unusual;
982 }
983 continue;
984 // optional .storaged_proto.IOUsage uid_io = 3;
985 case 3:
986 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
987 ptr = ctx->ParseMessage(_internal_mutable_uid_io(), ptr);
988 CHK_(ptr);
989 } else {
990 goto handle_unusual;
991 }
992 continue;
993 // repeated .storaged_proto.TaskIOUsage task_io = 4;
994 case 4:
995 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
996 ptr -= 1;
997 do {
998 ptr += 1;
999 ptr = ctx->ParseMessage(_internal_add_task_io(), ptr);
1000 CHK_(ptr);
1001 if (!ctx->DataAvailable(ptr)) break;
1002 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr));
1003 } else {
1004 goto handle_unusual;
1005 }
1006 continue;
1007 default:
1008 goto handle_unusual;
1009 } // switch
1010 handle_unusual:
1011 if ((tag == 0) || ((tag & 7) == 4)) {
1012 CHK_(ptr);
1013 ctx->SetLastTag(tag);
1014 goto message_done;
1015 }
1016 ptr = UnknownFieldParse(
1017 tag,
1018 _internal_metadata_.mutable_unknown_fields<std::string>(),
1019 ptr, ctx);
1020 CHK_(ptr != nullptr);
1021 } // while
1022 message_done:
1023 _impl_._has_bits_.Or(has_bits);
1024 return ptr;
1025 failure:
1026 ptr = nullptr;
1027 goto message_done;
1028 #undef CHK_
1029 }
1030
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1031 ::uint8_t* UidRecord::_InternalSerialize(
1032 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1033 // @@protoc_insertion_point(serialize_to_array_start:storaged_proto.UidRecord)
1034 ::uint32_t cached_has_bits = 0;
1035 (void) cached_has_bits;
1036
1037 cached_has_bits = _impl_._has_bits_[0];
1038 // optional string uid_name = 1;
1039 if (cached_has_bits & 0x00000001u) {
1040 target = stream->WriteStringMaybeAliased(
1041 1, this->_internal_uid_name(), target);
1042 }
1043
1044 // optional uint32 user_id = 2;
1045 if (cached_has_bits & 0x00000004u) {
1046 target = stream->EnsureSpace(target);
1047 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_user_id(), target);
1048 }
1049
1050 // optional .storaged_proto.IOUsage uid_io = 3;
1051 if (cached_has_bits & 0x00000002u) {
1052 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
1053 InternalWriteMessage(3, _Internal::uid_io(this),
1054 _Internal::uid_io(this).GetCachedSize(), target, stream);
1055 }
1056
1057 // repeated .storaged_proto.TaskIOUsage task_io = 4;
1058 for (unsigned i = 0,
1059 n = static_cast<unsigned>(this->_internal_task_io_size()); i < n; i++) {
1060 const auto& repfield = this->_internal_task_io(i);
1061 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
1062 InternalWriteMessage(4, repfield, repfield.GetCachedSize(), target, stream);
1063 }
1064
1065 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1066 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1067 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1068 }
1069 // @@protoc_insertion_point(serialize_to_array_end:storaged_proto.UidRecord)
1070 return target;
1071 }
1072
ByteSizeLong() const1073 size_t UidRecord::ByteSizeLong() const {
1074 // @@protoc_insertion_point(message_byte_size_start:storaged_proto.UidRecord)
1075 size_t total_size = 0;
1076
1077 ::uint32_t cached_has_bits = 0;
1078 // Prevent compiler warnings about cached_has_bits being unused
1079 (void) cached_has_bits;
1080
1081 // repeated .storaged_proto.TaskIOUsage task_io = 4;
1082 total_size += 1UL * this->_internal_task_io_size();
1083 for (const auto& msg : this->_impl_.task_io_) {
1084 total_size +=
1085 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
1086 }
1087
1088 cached_has_bits = _impl_._has_bits_[0];
1089 if (cached_has_bits & 0x00000007u) {
1090 // optional string uid_name = 1;
1091 if (cached_has_bits & 0x00000001u) {
1092 total_size += 1 +
1093 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
1094 this->_internal_uid_name());
1095 }
1096
1097 // optional .storaged_proto.IOUsage uid_io = 3;
1098 if (cached_has_bits & 0x00000002u) {
1099 total_size += 1 +
1100 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
1101 *_impl_.uid_io_);
1102 }
1103
1104 // optional uint32 user_id = 2;
1105 if (cached_has_bits & 0x00000004u) {
1106 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_user_id());
1107 }
1108
1109 }
1110 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1111 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1112 }
1113 int cached_size = ::_pbi::ToCachedSize(total_size);
1114 SetCachedSize(cached_size);
1115 return total_size;
1116 }
1117
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1118 void UidRecord::CheckTypeAndMergeFrom(
1119 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1120 MergeFrom(*::_pbi::DownCast<const UidRecord*>(
1121 &from));
1122 }
1123
MergeFrom(const UidRecord & from)1124 void UidRecord::MergeFrom(const UidRecord& from) {
1125 UidRecord* const _this = this;
1126 // @@protoc_insertion_point(class_specific_merge_from_start:storaged_proto.UidRecord)
1127 GOOGLE_DCHECK_NE(&from, _this);
1128 ::uint32_t cached_has_bits = 0;
1129 (void) cached_has_bits;
1130
1131 _this->_impl_.task_io_.MergeFrom(from._impl_.task_io_);
1132 cached_has_bits = from._impl_._has_bits_[0];
1133 if (cached_has_bits & 0x00000007u) {
1134 if (cached_has_bits & 0x00000001u) {
1135 _this->_internal_set_uid_name(from._internal_uid_name());
1136 }
1137 if (cached_has_bits & 0x00000002u) {
1138 _this->_internal_mutable_uid_io()->::storaged_proto::IOUsage::MergeFrom(
1139 from._internal_uid_io());
1140 }
1141 if (cached_has_bits & 0x00000004u) {
1142 _this->_impl_.user_id_ = from._impl_.user_id_;
1143 }
1144 _this->_impl_._has_bits_[0] |= cached_has_bits;
1145 }
1146 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1147 }
1148
CopyFrom(const UidRecord & from)1149 void UidRecord::CopyFrom(const UidRecord& from) {
1150 // @@protoc_insertion_point(class_specific_copy_from_start:storaged_proto.UidRecord)
1151 if (&from == this) return;
1152 Clear();
1153 MergeFrom(from);
1154 }
1155
IsInitialized() const1156 bool UidRecord::IsInitialized() const {
1157 return true;
1158 }
1159
InternalSwap(UidRecord * other)1160 void UidRecord::InternalSwap(UidRecord* other) {
1161 using std::swap;
1162 auto* lhs_arena = GetArenaForAllocation();
1163 auto* rhs_arena = other->GetArenaForAllocation();
1164 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1165 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
1166 _impl_.task_io_.InternalSwap(&other->_impl_.task_io_);
1167 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1168 &_impl_.uid_name_, lhs_arena,
1169 &other->_impl_.uid_name_, rhs_arena
1170 );
1171 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
1172 PROTOBUF_FIELD_OFFSET(UidRecord, _impl_.user_id_)
1173 + sizeof(UidRecord::_impl_.user_id_) // NOLINT
1174 - PROTOBUF_FIELD_OFFSET(UidRecord, _impl_.uid_io_)>(
1175 reinterpret_cast<char*>(&_impl_.uid_io_),
1176 reinterpret_cast<char*>(&other->_impl_.uid_io_));
1177 }
1178
GetTypeName() const1179 std::string UidRecord::GetTypeName() const {
1180 return "storaged_proto.UidRecord";
1181 }
1182
1183
1184 // ===================================================================
1185
1186 class UidIORecords::_Internal {
1187 public:
1188 using HasBits = decltype(std::declval<UidIORecords>()._impl_._has_bits_);
set_has_start_ts(HasBits * has_bits)1189 static void set_has_start_ts(HasBits* has_bits) {
1190 (*has_bits)[0] |= 1u;
1191 }
1192 };
1193
UidIORecords(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1194 UidIORecords::UidIORecords(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1195 bool is_message_owned)
1196 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1197 SharedCtor(arena, is_message_owned);
1198 // @@protoc_insertion_point(arena_constructor:storaged_proto.UidIORecords)
1199 }
UidIORecords(const UidIORecords & from)1200 UidIORecords::UidIORecords(const UidIORecords& from)
1201 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1202 UidIORecords* const _this = this; (void)_this;
1203 new (&_impl_) Impl_{
1204 decltype(_impl_._has_bits_){from._impl_._has_bits_}
1205 , /*decltype(_impl_._cached_size_)*/{}
1206 , decltype(_impl_.entries_){from._impl_.entries_}
1207 , decltype(_impl_.start_ts_){}};
1208
1209 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1210 _this->_impl_.start_ts_ = from._impl_.start_ts_;
1211 // @@protoc_insertion_point(copy_constructor:storaged_proto.UidIORecords)
1212 }
1213
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1214 inline void UidIORecords::SharedCtor(
1215 ::_pb::Arena* arena, bool is_message_owned) {
1216 (void)arena;
1217 (void)is_message_owned;
1218 new (&_impl_) Impl_{
1219 decltype(_impl_._has_bits_){}
1220 , /*decltype(_impl_._cached_size_)*/{}
1221 , decltype(_impl_.entries_){arena}
1222 , decltype(_impl_.start_ts_){::uint64_t{0u}}
1223 };
1224 }
1225
~UidIORecords()1226 UidIORecords::~UidIORecords() {
1227 // @@protoc_insertion_point(destructor:storaged_proto.UidIORecords)
1228 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1229 (void)arena;
1230 return;
1231 }
1232 SharedDtor();
1233 }
1234
SharedDtor()1235 inline void UidIORecords::SharedDtor() {
1236 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1237 _impl_.entries_.~RepeatedPtrField();
1238 }
1239
SetCachedSize(int size) const1240 void UidIORecords::SetCachedSize(int size) const {
1241 _impl_._cached_size_.Set(size);
1242 }
1243
Clear()1244 void UidIORecords::Clear() {
1245 // @@protoc_insertion_point(message_clear_start:storaged_proto.UidIORecords)
1246 ::uint32_t cached_has_bits = 0;
1247 // Prevent compiler warnings about cached_has_bits being unused
1248 (void) cached_has_bits;
1249
1250 _impl_.entries_.Clear();
1251 _impl_.start_ts_ = ::uint64_t{0u};
1252 _impl_._has_bits_.Clear();
1253 _internal_metadata_.Clear<std::string>();
1254 }
1255
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1256 const char* UidIORecords::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1257 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1258 _Internal::HasBits has_bits{};
1259 while (!ctx->Done(&ptr)) {
1260 ::uint32_t tag;
1261 ptr = ::_pbi::ReadTag(ptr, &tag);
1262 switch (tag >> 3) {
1263 // optional uint64 start_ts = 1;
1264 case 1:
1265 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
1266 _Internal::set_has_start_ts(&has_bits);
1267 _impl_.start_ts_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1268 CHK_(ptr);
1269 } else {
1270 goto handle_unusual;
1271 }
1272 continue;
1273 // repeated .storaged_proto.UidRecord entries = 2;
1274 case 2:
1275 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
1276 ptr -= 1;
1277 do {
1278 ptr += 1;
1279 ptr = ctx->ParseMessage(_internal_add_entries(), ptr);
1280 CHK_(ptr);
1281 if (!ctx->DataAvailable(ptr)) break;
1282 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
1283 } else {
1284 goto handle_unusual;
1285 }
1286 continue;
1287 default:
1288 goto handle_unusual;
1289 } // switch
1290 handle_unusual:
1291 if ((tag == 0) || ((tag & 7) == 4)) {
1292 CHK_(ptr);
1293 ctx->SetLastTag(tag);
1294 goto message_done;
1295 }
1296 ptr = UnknownFieldParse(
1297 tag,
1298 _internal_metadata_.mutable_unknown_fields<std::string>(),
1299 ptr, ctx);
1300 CHK_(ptr != nullptr);
1301 } // while
1302 message_done:
1303 _impl_._has_bits_.Or(has_bits);
1304 return ptr;
1305 failure:
1306 ptr = nullptr;
1307 goto message_done;
1308 #undef CHK_
1309 }
1310
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1311 ::uint8_t* UidIORecords::_InternalSerialize(
1312 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1313 // @@protoc_insertion_point(serialize_to_array_start:storaged_proto.UidIORecords)
1314 ::uint32_t cached_has_bits = 0;
1315 (void) cached_has_bits;
1316
1317 cached_has_bits = _impl_._has_bits_[0];
1318 // optional uint64 start_ts = 1;
1319 if (cached_has_bits & 0x00000001u) {
1320 target = stream->EnsureSpace(target);
1321 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_start_ts(), target);
1322 }
1323
1324 // repeated .storaged_proto.UidRecord entries = 2;
1325 for (unsigned i = 0,
1326 n = static_cast<unsigned>(this->_internal_entries_size()); i < n; i++) {
1327 const auto& repfield = this->_internal_entries(i);
1328 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
1329 InternalWriteMessage(2, repfield, repfield.GetCachedSize(), target, stream);
1330 }
1331
1332 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1333 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1334 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1335 }
1336 // @@protoc_insertion_point(serialize_to_array_end:storaged_proto.UidIORecords)
1337 return target;
1338 }
1339
ByteSizeLong() const1340 size_t UidIORecords::ByteSizeLong() const {
1341 // @@protoc_insertion_point(message_byte_size_start:storaged_proto.UidIORecords)
1342 size_t total_size = 0;
1343
1344 ::uint32_t cached_has_bits = 0;
1345 // Prevent compiler warnings about cached_has_bits being unused
1346 (void) cached_has_bits;
1347
1348 // repeated .storaged_proto.UidRecord entries = 2;
1349 total_size += 1UL * this->_internal_entries_size();
1350 for (const auto& msg : this->_impl_.entries_) {
1351 total_size +=
1352 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
1353 }
1354
1355 // optional uint64 start_ts = 1;
1356 cached_has_bits = _impl_._has_bits_[0];
1357 if (cached_has_bits & 0x00000001u) {
1358 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_start_ts());
1359 }
1360
1361 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1362 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1363 }
1364 int cached_size = ::_pbi::ToCachedSize(total_size);
1365 SetCachedSize(cached_size);
1366 return total_size;
1367 }
1368
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1369 void UidIORecords::CheckTypeAndMergeFrom(
1370 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1371 MergeFrom(*::_pbi::DownCast<const UidIORecords*>(
1372 &from));
1373 }
1374
MergeFrom(const UidIORecords & from)1375 void UidIORecords::MergeFrom(const UidIORecords& from) {
1376 UidIORecords* const _this = this;
1377 // @@protoc_insertion_point(class_specific_merge_from_start:storaged_proto.UidIORecords)
1378 GOOGLE_DCHECK_NE(&from, _this);
1379 ::uint32_t cached_has_bits = 0;
1380 (void) cached_has_bits;
1381
1382 _this->_impl_.entries_.MergeFrom(from._impl_.entries_);
1383 if (from._internal_has_start_ts()) {
1384 _this->_internal_set_start_ts(from._internal_start_ts());
1385 }
1386 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1387 }
1388
CopyFrom(const UidIORecords & from)1389 void UidIORecords::CopyFrom(const UidIORecords& from) {
1390 // @@protoc_insertion_point(class_specific_copy_from_start:storaged_proto.UidIORecords)
1391 if (&from == this) return;
1392 Clear();
1393 MergeFrom(from);
1394 }
1395
IsInitialized() const1396 bool UidIORecords::IsInitialized() const {
1397 return true;
1398 }
1399
InternalSwap(UidIORecords * other)1400 void UidIORecords::InternalSwap(UidIORecords* other) {
1401 using std::swap;
1402 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1403 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
1404 _impl_.entries_.InternalSwap(&other->_impl_.entries_);
1405 swap(_impl_.start_ts_, other->_impl_.start_ts_);
1406 }
1407
GetTypeName() const1408 std::string UidIORecords::GetTypeName() const {
1409 return "storaged_proto.UidIORecords";
1410 }
1411
1412
1413 // ===================================================================
1414
1415 class UidIOItem::_Internal {
1416 public:
1417 using HasBits = decltype(std::declval<UidIOItem>()._impl_._has_bits_);
set_has_end_ts(HasBits * has_bits)1418 static void set_has_end_ts(HasBits* has_bits) {
1419 (*has_bits)[0] |= 2u;
1420 }
1421 static const ::storaged_proto::UidIORecords& records(const UidIOItem* msg);
set_has_records(HasBits * has_bits)1422 static void set_has_records(HasBits* has_bits) {
1423 (*has_bits)[0] |= 1u;
1424 }
1425 };
1426
1427 const ::storaged_proto::UidIORecords&
records(const UidIOItem * msg)1428 UidIOItem::_Internal::records(const UidIOItem* msg) {
1429 return *msg->_impl_.records_;
1430 }
UidIOItem(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1431 UidIOItem::UidIOItem(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1432 bool is_message_owned)
1433 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1434 SharedCtor(arena, is_message_owned);
1435 // @@protoc_insertion_point(arena_constructor:storaged_proto.UidIOItem)
1436 }
UidIOItem(const UidIOItem & from)1437 UidIOItem::UidIOItem(const UidIOItem& from)
1438 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1439 UidIOItem* const _this = this; (void)_this;
1440 new (&_impl_) Impl_{
1441 decltype(_impl_._has_bits_){from._impl_._has_bits_}
1442 , /*decltype(_impl_._cached_size_)*/{}
1443 , decltype(_impl_.records_){nullptr}
1444 , decltype(_impl_.end_ts_){}};
1445
1446 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1447 if (from._internal_has_records()) {
1448 _this->_impl_.records_ = new ::storaged_proto::UidIORecords(*from._impl_.records_);
1449 }
1450 _this->_impl_.end_ts_ = from._impl_.end_ts_;
1451 // @@protoc_insertion_point(copy_constructor:storaged_proto.UidIOItem)
1452 }
1453
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1454 inline void UidIOItem::SharedCtor(
1455 ::_pb::Arena* arena, bool is_message_owned) {
1456 (void)arena;
1457 (void)is_message_owned;
1458 new (&_impl_) Impl_{
1459 decltype(_impl_._has_bits_){}
1460 , /*decltype(_impl_._cached_size_)*/{}
1461 , decltype(_impl_.records_){nullptr}
1462 , decltype(_impl_.end_ts_){::uint64_t{0u}}
1463 };
1464 }
1465
~UidIOItem()1466 UidIOItem::~UidIOItem() {
1467 // @@protoc_insertion_point(destructor:storaged_proto.UidIOItem)
1468 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1469 (void)arena;
1470 return;
1471 }
1472 SharedDtor();
1473 }
1474
SharedDtor()1475 inline void UidIOItem::SharedDtor() {
1476 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1477 if (this != internal_default_instance()) delete _impl_.records_;
1478 }
1479
SetCachedSize(int size) const1480 void UidIOItem::SetCachedSize(int size) const {
1481 _impl_._cached_size_.Set(size);
1482 }
1483
Clear()1484 void UidIOItem::Clear() {
1485 // @@protoc_insertion_point(message_clear_start:storaged_proto.UidIOItem)
1486 ::uint32_t cached_has_bits = 0;
1487 // Prevent compiler warnings about cached_has_bits being unused
1488 (void) cached_has_bits;
1489
1490 cached_has_bits = _impl_._has_bits_[0];
1491 if (cached_has_bits & 0x00000001u) {
1492 GOOGLE_DCHECK(_impl_.records_ != nullptr);
1493 _impl_.records_->Clear();
1494 }
1495 _impl_.end_ts_ = ::uint64_t{0u};
1496 _impl_._has_bits_.Clear();
1497 _internal_metadata_.Clear<std::string>();
1498 }
1499
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1500 const char* UidIOItem::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1501 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1502 _Internal::HasBits has_bits{};
1503 while (!ctx->Done(&ptr)) {
1504 ::uint32_t tag;
1505 ptr = ::_pbi::ReadTag(ptr, &tag);
1506 switch (tag >> 3) {
1507 // optional uint64 end_ts = 1;
1508 case 1:
1509 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
1510 _Internal::set_has_end_ts(&has_bits);
1511 _impl_.end_ts_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1512 CHK_(ptr);
1513 } else {
1514 goto handle_unusual;
1515 }
1516 continue;
1517 // optional .storaged_proto.UidIORecords records = 2;
1518 case 2:
1519 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
1520 ptr = ctx->ParseMessage(_internal_mutable_records(), ptr);
1521 CHK_(ptr);
1522 } else {
1523 goto handle_unusual;
1524 }
1525 continue;
1526 default:
1527 goto handle_unusual;
1528 } // switch
1529 handle_unusual:
1530 if ((tag == 0) || ((tag & 7) == 4)) {
1531 CHK_(ptr);
1532 ctx->SetLastTag(tag);
1533 goto message_done;
1534 }
1535 ptr = UnknownFieldParse(
1536 tag,
1537 _internal_metadata_.mutable_unknown_fields<std::string>(),
1538 ptr, ctx);
1539 CHK_(ptr != nullptr);
1540 } // while
1541 message_done:
1542 _impl_._has_bits_.Or(has_bits);
1543 return ptr;
1544 failure:
1545 ptr = nullptr;
1546 goto message_done;
1547 #undef CHK_
1548 }
1549
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1550 ::uint8_t* UidIOItem::_InternalSerialize(
1551 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1552 // @@protoc_insertion_point(serialize_to_array_start:storaged_proto.UidIOItem)
1553 ::uint32_t cached_has_bits = 0;
1554 (void) cached_has_bits;
1555
1556 cached_has_bits = _impl_._has_bits_[0];
1557 // optional uint64 end_ts = 1;
1558 if (cached_has_bits & 0x00000002u) {
1559 target = stream->EnsureSpace(target);
1560 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_end_ts(), target);
1561 }
1562
1563 // optional .storaged_proto.UidIORecords records = 2;
1564 if (cached_has_bits & 0x00000001u) {
1565 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
1566 InternalWriteMessage(2, _Internal::records(this),
1567 _Internal::records(this).GetCachedSize(), target, stream);
1568 }
1569
1570 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1571 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1572 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1573 }
1574 // @@protoc_insertion_point(serialize_to_array_end:storaged_proto.UidIOItem)
1575 return target;
1576 }
1577
ByteSizeLong() const1578 size_t UidIOItem::ByteSizeLong() const {
1579 // @@protoc_insertion_point(message_byte_size_start:storaged_proto.UidIOItem)
1580 size_t total_size = 0;
1581
1582 ::uint32_t cached_has_bits = 0;
1583 // Prevent compiler warnings about cached_has_bits being unused
1584 (void) cached_has_bits;
1585
1586 cached_has_bits = _impl_._has_bits_[0];
1587 if (cached_has_bits & 0x00000003u) {
1588 // optional .storaged_proto.UidIORecords records = 2;
1589 if (cached_has_bits & 0x00000001u) {
1590 total_size += 1 +
1591 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
1592 *_impl_.records_);
1593 }
1594
1595 // optional uint64 end_ts = 1;
1596 if (cached_has_bits & 0x00000002u) {
1597 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_end_ts());
1598 }
1599
1600 }
1601 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1602 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1603 }
1604 int cached_size = ::_pbi::ToCachedSize(total_size);
1605 SetCachedSize(cached_size);
1606 return total_size;
1607 }
1608
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1609 void UidIOItem::CheckTypeAndMergeFrom(
1610 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1611 MergeFrom(*::_pbi::DownCast<const UidIOItem*>(
1612 &from));
1613 }
1614
MergeFrom(const UidIOItem & from)1615 void UidIOItem::MergeFrom(const UidIOItem& from) {
1616 UidIOItem* const _this = this;
1617 // @@protoc_insertion_point(class_specific_merge_from_start:storaged_proto.UidIOItem)
1618 GOOGLE_DCHECK_NE(&from, _this);
1619 ::uint32_t cached_has_bits = 0;
1620 (void) cached_has_bits;
1621
1622 cached_has_bits = from._impl_._has_bits_[0];
1623 if (cached_has_bits & 0x00000003u) {
1624 if (cached_has_bits & 0x00000001u) {
1625 _this->_internal_mutable_records()->::storaged_proto::UidIORecords::MergeFrom(
1626 from._internal_records());
1627 }
1628 if (cached_has_bits & 0x00000002u) {
1629 _this->_impl_.end_ts_ = from._impl_.end_ts_;
1630 }
1631 _this->_impl_._has_bits_[0] |= cached_has_bits;
1632 }
1633 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1634 }
1635
CopyFrom(const UidIOItem & from)1636 void UidIOItem::CopyFrom(const UidIOItem& from) {
1637 // @@protoc_insertion_point(class_specific_copy_from_start:storaged_proto.UidIOItem)
1638 if (&from == this) return;
1639 Clear();
1640 MergeFrom(from);
1641 }
1642
IsInitialized() const1643 bool UidIOItem::IsInitialized() const {
1644 return true;
1645 }
1646
InternalSwap(UidIOItem * other)1647 void UidIOItem::InternalSwap(UidIOItem* other) {
1648 using std::swap;
1649 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1650 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
1651 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
1652 PROTOBUF_FIELD_OFFSET(UidIOItem, _impl_.end_ts_)
1653 + sizeof(UidIOItem::_impl_.end_ts_) // NOLINT
1654 - PROTOBUF_FIELD_OFFSET(UidIOItem, _impl_.records_)>(
1655 reinterpret_cast<char*>(&_impl_.records_),
1656 reinterpret_cast<char*>(&other->_impl_.records_));
1657 }
1658
GetTypeName() const1659 std::string UidIOItem::GetTypeName() const {
1660 return "storaged_proto.UidIOItem";
1661 }
1662
1663
1664 // ===================================================================
1665
1666 class UidIOUsage::_Internal {
1667 public:
1668 };
1669
UidIOUsage(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1670 UidIOUsage::UidIOUsage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1671 bool is_message_owned)
1672 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1673 SharedCtor(arena, is_message_owned);
1674 // @@protoc_insertion_point(arena_constructor:storaged_proto.UidIOUsage)
1675 }
UidIOUsage(const UidIOUsage & from)1676 UidIOUsage::UidIOUsage(const UidIOUsage& from)
1677 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1678 UidIOUsage* const _this = this; (void)_this;
1679 new (&_impl_) Impl_{
1680 decltype(_impl_.uid_io_items_){from._impl_.uid_io_items_}
1681 , /*decltype(_impl_._cached_size_)*/{}};
1682
1683 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1684 // @@protoc_insertion_point(copy_constructor:storaged_proto.UidIOUsage)
1685 }
1686
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1687 inline void UidIOUsage::SharedCtor(
1688 ::_pb::Arena* arena, bool is_message_owned) {
1689 (void)arena;
1690 (void)is_message_owned;
1691 new (&_impl_) Impl_{
1692 decltype(_impl_.uid_io_items_){arena}
1693 , /*decltype(_impl_._cached_size_)*/{}
1694 };
1695 }
1696
~UidIOUsage()1697 UidIOUsage::~UidIOUsage() {
1698 // @@protoc_insertion_point(destructor:storaged_proto.UidIOUsage)
1699 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1700 (void)arena;
1701 return;
1702 }
1703 SharedDtor();
1704 }
1705
SharedDtor()1706 inline void UidIOUsage::SharedDtor() {
1707 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1708 _impl_.uid_io_items_.~RepeatedPtrField();
1709 }
1710
SetCachedSize(int size) const1711 void UidIOUsage::SetCachedSize(int size) const {
1712 _impl_._cached_size_.Set(size);
1713 }
1714
Clear()1715 void UidIOUsage::Clear() {
1716 // @@protoc_insertion_point(message_clear_start:storaged_proto.UidIOUsage)
1717 ::uint32_t cached_has_bits = 0;
1718 // Prevent compiler warnings about cached_has_bits being unused
1719 (void) cached_has_bits;
1720
1721 _impl_.uid_io_items_.Clear();
1722 _internal_metadata_.Clear<std::string>();
1723 }
1724
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1725 const char* UidIOUsage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1726 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1727 while (!ctx->Done(&ptr)) {
1728 ::uint32_t tag;
1729 ptr = ::_pbi::ReadTag(ptr, &tag);
1730 switch (tag >> 3) {
1731 // repeated .storaged_proto.UidIOItem uid_io_items = 2;
1732 case 2:
1733 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
1734 ptr -= 1;
1735 do {
1736 ptr += 1;
1737 ptr = ctx->ParseMessage(_internal_add_uid_io_items(), ptr);
1738 CHK_(ptr);
1739 if (!ctx->DataAvailable(ptr)) break;
1740 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
1741 } else {
1742 goto handle_unusual;
1743 }
1744 continue;
1745 default:
1746 goto handle_unusual;
1747 } // switch
1748 handle_unusual:
1749 if ((tag == 0) || ((tag & 7) == 4)) {
1750 CHK_(ptr);
1751 ctx->SetLastTag(tag);
1752 goto message_done;
1753 }
1754 ptr = UnknownFieldParse(
1755 tag,
1756 _internal_metadata_.mutable_unknown_fields<std::string>(),
1757 ptr, ctx);
1758 CHK_(ptr != nullptr);
1759 } // while
1760 message_done:
1761 return ptr;
1762 failure:
1763 ptr = nullptr;
1764 goto message_done;
1765 #undef CHK_
1766 }
1767
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1768 ::uint8_t* UidIOUsage::_InternalSerialize(
1769 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1770 // @@protoc_insertion_point(serialize_to_array_start:storaged_proto.UidIOUsage)
1771 ::uint32_t cached_has_bits = 0;
1772 (void) cached_has_bits;
1773
1774 // repeated .storaged_proto.UidIOItem uid_io_items = 2;
1775 for (unsigned i = 0,
1776 n = static_cast<unsigned>(this->_internal_uid_io_items_size()); i < n; i++) {
1777 const auto& repfield = this->_internal_uid_io_items(i);
1778 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
1779 InternalWriteMessage(2, repfield, repfield.GetCachedSize(), target, stream);
1780 }
1781
1782 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1783 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1784 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1785 }
1786 // @@protoc_insertion_point(serialize_to_array_end:storaged_proto.UidIOUsage)
1787 return target;
1788 }
1789
ByteSizeLong() const1790 size_t UidIOUsage::ByteSizeLong() const {
1791 // @@protoc_insertion_point(message_byte_size_start:storaged_proto.UidIOUsage)
1792 size_t total_size = 0;
1793
1794 ::uint32_t cached_has_bits = 0;
1795 // Prevent compiler warnings about cached_has_bits being unused
1796 (void) cached_has_bits;
1797
1798 // repeated .storaged_proto.UidIOItem uid_io_items = 2;
1799 total_size += 1UL * this->_internal_uid_io_items_size();
1800 for (const auto& msg : this->_impl_.uid_io_items_) {
1801 total_size +=
1802 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
1803 }
1804
1805 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1806 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1807 }
1808 int cached_size = ::_pbi::ToCachedSize(total_size);
1809 SetCachedSize(cached_size);
1810 return total_size;
1811 }
1812
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1813 void UidIOUsage::CheckTypeAndMergeFrom(
1814 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1815 MergeFrom(*::_pbi::DownCast<const UidIOUsage*>(
1816 &from));
1817 }
1818
MergeFrom(const UidIOUsage & from)1819 void UidIOUsage::MergeFrom(const UidIOUsage& from) {
1820 UidIOUsage* const _this = this;
1821 // @@protoc_insertion_point(class_specific_merge_from_start:storaged_proto.UidIOUsage)
1822 GOOGLE_DCHECK_NE(&from, _this);
1823 ::uint32_t cached_has_bits = 0;
1824 (void) cached_has_bits;
1825
1826 _this->_impl_.uid_io_items_.MergeFrom(from._impl_.uid_io_items_);
1827 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1828 }
1829
CopyFrom(const UidIOUsage & from)1830 void UidIOUsage::CopyFrom(const UidIOUsage& from) {
1831 // @@protoc_insertion_point(class_specific_copy_from_start:storaged_proto.UidIOUsage)
1832 if (&from == this) return;
1833 Clear();
1834 MergeFrom(from);
1835 }
1836
IsInitialized() const1837 bool UidIOUsage::IsInitialized() const {
1838 return true;
1839 }
1840
InternalSwap(UidIOUsage * other)1841 void UidIOUsage::InternalSwap(UidIOUsage* other) {
1842 using std::swap;
1843 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1844 _impl_.uid_io_items_.InternalSwap(&other->_impl_.uid_io_items_);
1845 }
1846
GetTypeName() const1847 std::string UidIOUsage::GetTypeName() const {
1848 return "storaged_proto.UidIOUsage";
1849 }
1850
1851
1852 // ===================================================================
1853
1854 class IOPerfHistory::_Internal {
1855 public:
1856 using HasBits = decltype(std::declval<IOPerfHistory>()._impl_._has_bits_);
set_has_day_start_sec(HasBits * has_bits)1857 static void set_has_day_start_sec(HasBits* has_bits) {
1858 (*has_bits)[0] |= 1u;
1859 }
set_has_nr_samples(HasBits * has_bits)1860 static void set_has_nr_samples(HasBits* has_bits) {
1861 (*has_bits)[0] |= 2u;
1862 }
set_has_nr_days(HasBits * has_bits)1863 static void set_has_nr_days(HasBits* has_bits) {
1864 (*has_bits)[0] |= 4u;
1865 }
set_has_nr_weeks(HasBits * has_bits)1866 static void set_has_nr_weeks(HasBits* has_bits) {
1867 (*has_bits)[0] |= 8u;
1868 }
1869 };
1870
IOPerfHistory(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1871 IOPerfHistory::IOPerfHistory(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1872 bool is_message_owned)
1873 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1874 SharedCtor(arena, is_message_owned);
1875 // @@protoc_insertion_point(arena_constructor:storaged_proto.IOPerfHistory)
1876 }
IOPerfHistory(const IOPerfHistory & from)1877 IOPerfHistory::IOPerfHistory(const IOPerfHistory& from)
1878 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1879 IOPerfHistory* const _this = this; (void)_this;
1880 new (&_impl_) Impl_{
1881 decltype(_impl_._has_bits_){from._impl_._has_bits_}
1882 , /*decltype(_impl_._cached_size_)*/{}
1883 , decltype(_impl_.recent_perf_){from._impl_.recent_perf_}
1884 , decltype(_impl_.daily_perf_){from._impl_.daily_perf_}
1885 , decltype(_impl_.weekly_perf_){from._impl_.weekly_perf_}
1886 , decltype(_impl_.day_start_sec_){}
1887 , decltype(_impl_.nr_samples_){}
1888 , decltype(_impl_.nr_days_){}
1889 , decltype(_impl_.nr_weeks_){}};
1890
1891 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1892 ::memcpy(&_impl_.day_start_sec_, &from._impl_.day_start_sec_,
1893 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.nr_weeks_) -
1894 reinterpret_cast<char*>(&_impl_.day_start_sec_)) + sizeof(_impl_.nr_weeks_));
1895 // @@protoc_insertion_point(copy_constructor:storaged_proto.IOPerfHistory)
1896 }
1897
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1898 inline void IOPerfHistory::SharedCtor(
1899 ::_pb::Arena* arena, bool is_message_owned) {
1900 (void)arena;
1901 (void)is_message_owned;
1902 new (&_impl_) Impl_{
1903 decltype(_impl_._has_bits_){}
1904 , /*decltype(_impl_._cached_size_)*/{}
1905 , decltype(_impl_.recent_perf_){arena}
1906 , decltype(_impl_.daily_perf_){arena}
1907 , decltype(_impl_.weekly_perf_){arena}
1908 , decltype(_impl_.day_start_sec_){::uint64_t{0u}}
1909 , decltype(_impl_.nr_samples_){0u}
1910 , decltype(_impl_.nr_days_){0u}
1911 , decltype(_impl_.nr_weeks_){0u}
1912 };
1913 }
1914
~IOPerfHistory()1915 IOPerfHistory::~IOPerfHistory() {
1916 // @@protoc_insertion_point(destructor:storaged_proto.IOPerfHistory)
1917 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1918 (void)arena;
1919 return;
1920 }
1921 SharedDtor();
1922 }
1923
SharedDtor()1924 inline void IOPerfHistory::SharedDtor() {
1925 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1926 _impl_.recent_perf_.~RepeatedField();
1927 _impl_.daily_perf_.~RepeatedField();
1928 _impl_.weekly_perf_.~RepeatedField();
1929 }
1930
SetCachedSize(int size) const1931 void IOPerfHistory::SetCachedSize(int size) const {
1932 _impl_._cached_size_.Set(size);
1933 }
1934
Clear()1935 void IOPerfHistory::Clear() {
1936 // @@protoc_insertion_point(message_clear_start:storaged_proto.IOPerfHistory)
1937 ::uint32_t cached_has_bits = 0;
1938 // Prevent compiler warnings about cached_has_bits being unused
1939 (void) cached_has_bits;
1940
1941 _impl_.recent_perf_.Clear();
1942 _impl_.daily_perf_.Clear();
1943 _impl_.weekly_perf_.Clear();
1944 cached_has_bits = _impl_._has_bits_[0];
1945 if (cached_has_bits & 0x0000000fu) {
1946 ::memset(&_impl_.day_start_sec_, 0, static_cast<size_t>(
1947 reinterpret_cast<char*>(&_impl_.nr_weeks_) -
1948 reinterpret_cast<char*>(&_impl_.day_start_sec_)) + sizeof(_impl_.nr_weeks_));
1949 }
1950 _impl_._has_bits_.Clear();
1951 _internal_metadata_.Clear<std::string>();
1952 }
1953
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1954 const char* IOPerfHistory::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1955 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1956 _Internal::HasBits has_bits{};
1957 while (!ctx->Done(&ptr)) {
1958 ::uint32_t tag;
1959 ptr = ::_pbi::ReadTag(ptr, &tag);
1960 switch (tag >> 3) {
1961 // optional uint64 day_start_sec = 1;
1962 case 1:
1963 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
1964 _Internal::set_has_day_start_sec(&has_bits);
1965 _impl_.day_start_sec_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1966 CHK_(ptr);
1967 } else {
1968 goto handle_unusual;
1969 }
1970 continue;
1971 // repeated uint32 recent_perf = 2;
1972 case 2:
1973 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
1974 ptr -= 1;
1975 do {
1976 ptr += 1;
1977 _internal_add_recent_perf(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr));
1978 CHK_(ptr);
1979 if (!ctx->DataAvailable(ptr)) break;
1980 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<16>(ptr));
1981 } else if (static_cast<::uint8_t>(tag) == 18) {
1982 ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedUInt32Parser(_internal_mutable_recent_perf(), ptr, ctx);
1983 CHK_(ptr);
1984 } else {
1985 goto handle_unusual;
1986 }
1987 continue;
1988 // optional uint32 nr_samples = 3;
1989 case 3:
1990 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
1991 _Internal::set_has_nr_samples(&has_bits);
1992 _impl_.nr_samples_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1993 CHK_(ptr);
1994 } else {
1995 goto handle_unusual;
1996 }
1997 continue;
1998 // repeated uint32 daily_perf = 4;
1999 case 4:
2000 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
2001 ptr -= 1;
2002 do {
2003 ptr += 1;
2004 _internal_add_daily_perf(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr));
2005 CHK_(ptr);
2006 if (!ctx->DataAvailable(ptr)) break;
2007 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<32>(ptr));
2008 } else if (static_cast<::uint8_t>(tag) == 34) {
2009 ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedUInt32Parser(_internal_mutable_daily_perf(), ptr, ctx);
2010 CHK_(ptr);
2011 } else {
2012 goto handle_unusual;
2013 }
2014 continue;
2015 // optional uint32 nr_days = 5;
2016 case 5:
2017 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
2018 _Internal::set_has_nr_days(&has_bits);
2019 _impl_.nr_days_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
2020 CHK_(ptr);
2021 } else {
2022 goto handle_unusual;
2023 }
2024 continue;
2025 // repeated uint32 weekly_perf = 6;
2026 case 6:
2027 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 48)) {
2028 ptr -= 1;
2029 do {
2030 ptr += 1;
2031 _internal_add_weekly_perf(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr));
2032 CHK_(ptr);
2033 if (!ctx->DataAvailable(ptr)) break;
2034 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<48>(ptr));
2035 } else if (static_cast<::uint8_t>(tag) == 50) {
2036 ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedUInt32Parser(_internal_mutable_weekly_perf(), ptr, ctx);
2037 CHK_(ptr);
2038 } else {
2039 goto handle_unusual;
2040 }
2041 continue;
2042 // optional uint32 nr_weeks = 7;
2043 case 7:
2044 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 56)) {
2045 _Internal::set_has_nr_weeks(&has_bits);
2046 _impl_.nr_weeks_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
2047 CHK_(ptr);
2048 } else {
2049 goto handle_unusual;
2050 }
2051 continue;
2052 default:
2053 goto handle_unusual;
2054 } // switch
2055 handle_unusual:
2056 if ((tag == 0) || ((tag & 7) == 4)) {
2057 CHK_(ptr);
2058 ctx->SetLastTag(tag);
2059 goto message_done;
2060 }
2061 ptr = UnknownFieldParse(
2062 tag,
2063 _internal_metadata_.mutable_unknown_fields<std::string>(),
2064 ptr, ctx);
2065 CHK_(ptr != nullptr);
2066 } // while
2067 message_done:
2068 _impl_._has_bits_.Or(has_bits);
2069 return ptr;
2070 failure:
2071 ptr = nullptr;
2072 goto message_done;
2073 #undef CHK_
2074 }
2075
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const2076 ::uint8_t* IOPerfHistory::_InternalSerialize(
2077 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
2078 // @@protoc_insertion_point(serialize_to_array_start:storaged_proto.IOPerfHistory)
2079 ::uint32_t cached_has_bits = 0;
2080 (void) cached_has_bits;
2081
2082 cached_has_bits = _impl_._has_bits_[0];
2083 // optional uint64 day_start_sec = 1;
2084 if (cached_has_bits & 0x00000001u) {
2085 target = stream->EnsureSpace(target);
2086 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_day_start_sec(), target);
2087 }
2088
2089 // repeated uint32 recent_perf = 2;
2090 for (int i = 0, n = this->_internal_recent_perf_size(); i < n; i++) {
2091 target = stream->EnsureSpace(target);
2092 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_recent_perf(i), target);
2093 }
2094
2095 // optional uint32 nr_samples = 3;
2096 if (cached_has_bits & 0x00000002u) {
2097 target = stream->EnsureSpace(target);
2098 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_nr_samples(), target);
2099 }
2100
2101 // repeated uint32 daily_perf = 4;
2102 for (int i = 0, n = this->_internal_daily_perf_size(); i < n; i++) {
2103 target = stream->EnsureSpace(target);
2104 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(4, this->_internal_daily_perf(i), target);
2105 }
2106
2107 // optional uint32 nr_days = 5;
2108 if (cached_has_bits & 0x00000004u) {
2109 target = stream->EnsureSpace(target);
2110 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(5, this->_internal_nr_days(), target);
2111 }
2112
2113 // repeated uint32 weekly_perf = 6;
2114 for (int i = 0, n = this->_internal_weekly_perf_size(); i < n; i++) {
2115 target = stream->EnsureSpace(target);
2116 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(6, this->_internal_weekly_perf(i), target);
2117 }
2118
2119 // optional uint32 nr_weeks = 7;
2120 if (cached_has_bits & 0x00000008u) {
2121 target = stream->EnsureSpace(target);
2122 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(7, this->_internal_nr_weeks(), target);
2123 }
2124
2125 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2126 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
2127 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
2128 }
2129 // @@protoc_insertion_point(serialize_to_array_end:storaged_proto.IOPerfHistory)
2130 return target;
2131 }
2132
ByteSizeLong() const2133 size_t IOPerfHistory::ByteSizeLong() const {
2134 // @@protoc_insertion_point(message_byte_size_start:storaged_proto.IOPerfHistory)
2135 size_t total_size = 0;
2136
2137 ::uint32_t cached_has_bits = 0;
2138 // Prevent compiler warnings about cached_has_bits being unused
2139 (void) cached_has_bits;
2140
2141 // repeated uint32 recent_perf = 2;
2142 {
2143 size_t data_size = ::_pbi::WireFormatLite::
2144 UInt32Size(this->_impl_.recent_perf_);
2145 total_size += 1 *
2146 ::_pbi::FromIntSize(this->_internal_recent_perf_size());
2147 total_size += data_size;
2148 }
2149
2150 // repeated uint32 daily_perf = 4;
2151 {
2152 size_t data_size = ::_pbi::WireFormatLite::
2153 UInt32Size(this->_impl_.daily_perf_);
2154 total_size += 1 *
2155 ::_pbi::FromIntSize(this->_internal_daily_perf_size());
2156 total_size += data_size;
2157 }
2158
2159 // repeated uint32 weekly_perf = 6;
2160 {
2161 size_t data_size = ::_pbi::WireFormatLite::
2162 UInt32Size(this->_impl_.weekly_perf_);
2163 total_size += 1 *
2164 ::_pbi::FromIntSize(this->_internal_weekly_perf_size());
2165 total_size += data_size;
2166 }
2167
2168 cached_has_bits = _impl_._has_bits_[0];
2169 if (cached_has_bits & 0x0000000fu) {
2170 // optional uint64 day_start_sec = 1;
2171 if (cached_has_bits & 0x00000001u) {
2172 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_day_start_sec());
2173 }
2174
2175 // optional uint32 nr_samples = 3;
2176 if (cached_has_bits & 0x00000002u) {
2177 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_nr_samples());
2178 }
2179
2180 // optional uint32 nr_days = 5;
2181 if (cached_has_bits & 0x00000004u) {
2182 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_nr_days());
2183 }
2184
2185 // optional uint32 nr_weeks = 7;
2186 if (cached_has_bits & 0x00000008u) {
2187 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_nr_weeks());
2188 }
2189
2190 }
2191 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2192 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
2193 }
2194 int cached_size = ::_pbi::ToCachedSize(total_size);
2195 SetCachedSize(cached_size);
2196 return total_size;
2197 }
2198
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)2199 void IOPerfHistory::CheckTypeAndMergeFrom(
2200 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
2201 MergeFrom(*::_pbi::DownCast<const IOPerfHistory*>(
2202 &from));
2203 }
2204
MergeFrom(const IOPerfHistory & from)2205 void IOPerfHistory::MergeFrom(const IOPerfHistory& from) {
2206 IOPerfHistory* const _this = this;
2207 // @@protoc_insertion_point(class_specific_merge_from_start:storaged_proto.IOPerfHistory)
2208 GOOGLE_DCHECK_NE(&from, _this);
2209 ::uint32_t cached_has_bits = 0;
2210 (void) cached_has_bits;
2211
2212 _this->_impl_.recent_perf_.MergeFrom(from._impl_.recent_perf_);
2213 _this->_impl_.daily_perf_.MergeFrom(from._impl_.daily_perf_);
2214 _this->_impl_.weekly_perf_.MergeFrom(from._impl_.weekly_perf_);
2215 cached_has_bits = from._impl_._has_bits_[0];
2216 if (cached_has_bits & 0x0000000fu) {
2217 if (cached_has_bits & 0x00000001u) {
2218 _this->_impl_.day_start_sec_ = from._impl_.day_start_sec_;
2219 }
2220 if (cached_has_bits & 0x00000002u) {
2221 _this->_impl_.nr_samples_ = from._impl_.nr_samples_;
2222 }
2223 if (cached_has_bits & 0x00000004u) {
2224 _this->_impl_.nr_days_ = from._impl_.nr_days_;
2225 }
2226 if (cached_has_bits & 0x00000008u) {
2227 _this->_impl_.nr_weeks_ = from._impl_.nr_weeks_;
2228 }
2229 _this->_impl_._has_bits_[0] |= cached_has_bits;
2230 }
2231 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2232 }
2233
CopyFrom(const IOPerfHistory & from)2234 void IOPerfHistory::CopyFrom(const IOPerfHistory& from) {
2235 // @@protoc_insertion_point(class_specific_copy_from_start:storaged_proto.IOPerfHistory)
2236 if (&from == this) return;
2237 Clear();
2238 MergeFrom(from);
2239 }
2240
IsInitialized() const2241 bool IOPerfHistory::IsInitialized() const {
2242 return true;
2243 }
2244
InternalSwap(IOPerfHistory * other)2245 void IOPerfHistory::InternalSwap(IOPerfHistory* other) {
2246 using std::swap;
2247 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2248 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
2249 _impl_.recent_perf_.InternalSwap(&other->_impl_.recent_perf_);
2250 _impl_.daily_perf_.InternalSwap(&other->_impl_.daily_perf_);
2251 _impl_.weekly_perf_.InternalSwap(&other->_impl_.weekly_perf_);
2252 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
2253 PROTOBUF_FIELD_OFFSET(IOPerfHistory, _impl_.nr_weeks_)
2254 + sizeof(IOPerfHistory::_impl_.nr_weeks_) // NOLINT
2255 - PROTOBUF_FIELD_OFFSET(IOPerfHistory, _impl_.day_start_sec_)>(
2256 reinterpret_cast<char*>(&_impl_.day_start_sec_),
2257 reinterpret_cast<char*>(&other->_impl_.day_start_sec_));
2258 }
2259
GetTypeName() const2260 std::string IOPerfHistory::GetTypeName() const {
2261 return "storaged_proto.IOPerfHistory";
2262 }
2263
2264
2265 // ===================================================================
2266
2267 class StoragedProto::_Internal {
2268 public:
2269 using HasBits = decltype(std::declval<StoragedProto>()._impl_._has_bits_);
set_has_crc(HasBits * has_bits)2270 static void set_has_crc(HasBits* has_bits) {
2271 (*has_bits)[0] |= 8u;
2272 }
set_has_version(HasBits * has_bits)2273 static void set_has_version(HasBits* has_bits) {
2274 (*has_bits)[0] |= 16u;
2275 }
2276 static const ::storaged_proto::UidIOUsage& uid_io_usage(const StoragedProto* msg);
set_has_uid_io_usage(HasBits * has_bits)2277 static void set_has_uid_io_usage(HasBits* has_bits) {
2278 (*has_bits)[0] |= 2u;
2279 }
2280 static const ::storaged_proto::IOPerfHistory& perf_history(const StoragedProto* msg);
set_has_perf_history(HasBits * has_bits)2281 static void set_has_perf_history(HasBits* has_bits) {
2282 (*has_bits)[0] |= 4u;
2283 }
set_has_padding(HasBits * has_bits)2284 static void set_has_padding(HasBits* has_bits) {
2285 (*has_bits)[0] |= 1u;
2286 }
2287 };
2288
2289 const ::storaged_proto::UidIOUsage&
uid_io_usage(const StoragedProto * msg)2290 StoragedProto::_Internal::uid_io_usage(const StoragedProto* msg) {
2291 return *msg->_impl_.uid_io_usage_;
2292 }
2293 const ::storaged_proto::IOPerfHistory&
perf_history(const StoragedProto * msg)2294 StoragedProto::_Internal::perf_history(const StoragedProto* msg) {
2295 return *msg->_impl_.perf_history_;
2296 }
StoragedProto(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)2297 StoragedProto::StoragedProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2298 bool is_message_owned)
2299 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
2300 SharedCtor(arena, is_message_owned);
2301 // @@protoc_insertion_point(arena_constructor:storaged_proto.StoragedProto)
2302 }
StoragedProto(const StoragedProto & from)2303 StoragedProto::StoragedProto(const StoragedProto& from)
2304 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
2305 StoragedProto* const _this = this; (void)_this;
2306 new (&_impl_) Impl_{
2307 decltype(_impl_._has_bits_){from._impl_._has_bits_}
2308 , /*decltype(_impl_._cached_size_)*/{}
2309 , decltype(_impl_.padding_){}
2310 , decltype(_impl_.uid_io_usage_){nullptr}
2311 , decltype(_impl_.perf_history_){nullptr}
2312 , decltype(_impl_.crc_){}
2313 , decltype(_impl_.version_){}};
2314
2315 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2316 _impl_.padding_.InitDefault();
2317 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2318 _impl_.padding_.Set("", GetArenaForAllocation());
2319 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2320 if (from._internal_has_padding()) {
2321 _this->_impl_.padding_.Set(from._internal_padding(),
2322 _this->GetArenaForAllocation());
2323 }
2324 if (from._internal_has_uid_io_usage()) {
2325 _this->_impl_.uid_io_usage_ = new ::storaged_proto::UidIOUsage(*from._impl_.uid_io_usage_);
2326 }
2327 if (from._internal_has_perf_history()) {
2328 _this->_impl_.perf_history_ = new ::storaged_proto::IOPerfHistory(*from._impl_.perf_history_);
2329 }
2330 ::memcpy(&_impl_.crc_, &from._impl_.crc_,
2331 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.version_) -
2332 reinterpret_cast<char*>(&_impl_.crc_)) + sizeof(_impl_.version_));
2333 // @@protoc_insertion_point(copy_constructor:storaged_proto.StoragedProto)
2334 }
2335
SharedCtor(::_pb::Arena * arena,bool is_message_owned)2336 inline void StoragedProto::SharedCtor(
2337 ::_pb::Arena* arena, bool is_message_owned) {
2338 (void)arena;
2339 (void)is_message_owned;
2340 new (&_impl_) Impl_{
2341 decltype(_impl_._has_bits_){}
2342 , /*decltype(_impl_._cached_size_)*/{}
2343 , decltype(_impl_.padding_){}
2344 , decltype(_impl_.uid_io_usage_){nullptr}
2345 , decltype(_impl_.perf_history_){nullptr}
2346 , decltype(_impl_.crc_){0u}
2347 , decltype(_impl_.version_){0u}
2348 };
2349 _impl_.padding_.InitDefault();
2350 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2351 _impl_.padding_.Set("", GetArenaForAllocation());
2352 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2353 }
2354
~StoragedProto()2355 StoragedProto::~StoragedProto() {
2356 // @@protoc_insertion_point(destructor:storaged_proto.StoragedProto)
2357 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
2358 (void)arena;
2359 return;
2360 }
2361 SharedDtor();
2362 }
2363
SharedDtor()2364 inline void StoragedProto::SharedDtor() {
2365 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
2366 _impl_.padding_.Destroy();
2367 if (this != internal_default_instance()) delete _impl_.uid_io_usage_;
2368 if (this != internal_default_instance()) delete _impl_.perf_history_;
2369 }
2370
SetCachedSize(int size) const2371 void StoragedProto::SetCachedSize(int size) const {
2372 _impl_._cached_size_.Set(size);
2373 }
2374
Clear()2375 void StoragedProto::Clear() {
2376 // @@protoc_insertion_point(message_clear_start:storaged_proto.StoragedProto)
2377 ::uint32_t cached_has_bits = 0;
2378 // Prevent compiler warnings about cached_has_bits being unused
2379 (void) cached_has_bits;
2380
2381 cached_has_bits = _impl_._has_bits_[0];
2382 if (cached_has_bits & 0x00000007u) {
2383 if (cached_has_bits & 0x00000001u) {
2384 _impl_.padding_.ClearNonDefaultToEmpty();
2385 }
2386 if (cached_has_bits & 0x00000002u) {
2387 GOOGLE_DCHECK(_impl_.uid_io_usage_ != nullptr);
2388 _impl_.uid_io_usage_->Clear();
2389 }
2390 if (cached_has_bits & 0x00000004u) {
2391 GOOGLE_DCHECK(_impl_.perf_history_ != nullptr);
2392 _impl_.perf_history_->Clear();
2393 }
2394 }
2395 if (cached_has_bits & 0x00000018u) {
2396 ::memset(&_impl_.crc_, 0, static_cast<size_t>(
2397 reinterpret_cast<char*>(&_impl_.version_) -
2398 reinterpret_cast<char*>(&_impl_.crc_)) + sizeof(_impl_.version_));
2399 }
2400 _impl_._has_bits_.Clear();
2401 _internal_metadata_.Clear<std::string>();
2402 }
2403
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)2404 const char* StoragedProto::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
2405 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
2406 _Internal::HasBits has_bits{};
2407 while (!ctx->Done(&ptr)) {
2408 ::uint32_t tag;
2409 ptr = ::_pbi::ReadTag(ptr, &tag);
2410 switch (tag >> 3) {
2411 // optional uint32 crc = 1;
2412 case 1:
2413 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
2414 _Internal::set_has_crc(&has_bits);
2415 _impl_.crc_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
2416 CHK_(ptr);
2417 } else {
2418 goto handle_unusual;
2419 }
2420 continue;
2421 // optional uint32 version = 2;
2422 case 2:
2423 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
2424 _Internal::set_has_version(&has_bits);
2425 _impl_.version_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
2426 CHK_(ptr);
2427 } else {
2428 goto handle_unusual;
2429 }
2430 continue;
2431 // optional .storaged_proto.UidIOUsage uid_io_usage = 3;
2432 case 3:
2433 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
2434 ptr = ctx->ParseMessage(_internal_mutable_uid_io_usage(), ptr);
2435 CHK_(ptr);
2436 } else {
2437 goto handle_unusual;
2438 }
2439 continue;
2440 // optional .storaged_proto.IOPerfHistory perf_history = 4;
2441 case 4:
2442 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
2443 ptr = ctx->ParseMessage(_internal_mutable_perf_history(), ptr);
2444 CHK_(ptr);
2445 } else {
2446 goto handle_unusual;
2447 }
2448 continue;
2449 // optional bytes padding = 5;
2450 case 5:
2451 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 42)) {
2452 auto str = _internal_mutable_padding();
2453 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
2454 CHK_(ptr);
2455 } else {
2456 goto handle_unusual;
2457 }
2458 continue;
2459 default:
2460 goto handle_unusual;
2461 } // switch
2462 handle_unusual:
2463 if ((tag == 0) || ((tag & 7) == 4)) {
2464 CHK_(ptr);
2465 ctx->SetLastTag(tag);
2466 goto message_done;
2467 }
2468 ptr = UnknownFieldParse(
2469 tag,
2470 _internal_metadata_.mutable_unknown_fields<std::string>(),
2471 ptr, ctx);
2472 CHK_(ptr != nullptr);
2473 } // while
2474 message_done:
2475 _impl_._has_bits_.Or(has_bits);
2476 return ptr;
2477 failure:
2478 ptr = nullptr;
2479 goto message_done;
2480 #undef CHK_
2481 }
2482
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const2483 ::uint8_t* StoragedProto::_InternalSerialize(
2484 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
2485 // @@protoc_insertion_point(serialize_to_array_start:storaged_proto.StoragedProto)
2486 ::uint32_t cached_has_bits = 0;
2487 (void) cached_has_bits;
2488
2489 cached_has_bits = _impl_._has_bits_[0];
2490 // optional uint32 crc = 1;
2491 if (cached_has_bits & 0x00000008u) {
2492 target = stream->EnsureSpace(target);
2493 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_crc(), target);
2494 }
2495
2496 // optional uint32 version = 2;
2497 if (cached_has_bits & 0x00000010u) {
2498 target = stream->EnsureSpace(target);
2499 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_version(), target);
2500 }
2501
2502 // optional .storaged_proto.UidIOUsage uid_io_usage = 3;
2503 if (cached_has_bits & 0x00000002u) {
2504 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
2505 InternalWriteMessage(3, _Internal::uid_io_usage(this),
2506 _Internal::uid_io_usage(this).GetCachedSize(), target, stream);
2507 }
2508
2509 // optional .storaged_proto.IOPerfHistory perf_history = 4;
2510 if (cached_has_bits & 0x00000004u) {
2511 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
2512 InternalWriteMessage(4, _Internal::perf_history(this),
2513 _Internal::perf_history(this).GetCachedSize(), target, stream);
2514 }
2515
2516 // optional bytes padding = 5;
2517 if (cached_has_bits & 0x00000001u) {
2518 target = stream->WriteBytesMaybeAliased(
2519 5, this->_internal_padding(), target);
2520 }
2521
2522 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2523 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
2524 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
2525 }
2526 // @@protoc_insertion_point(serialize_to_array_end:storaged_proto.StoragedProto)
2527 return target;
2528 }
2529
ByteSizeLong() const2530 size_t StoragedProto::ByteSizeLong() const {
2531 // @@protoc_insertion_point(message_byte_size_start:storaged_proto.StoragedProto)
2532 size_t total_size = 0;
2533
2534 ::uint32_t cached_has_bits = 0;
2535 // Prevent compiler warnings about cached_has_bits being unused
2536 (void) cached_has_bits;
2537
2538 cached_has_bits = _impl_._has_bits_[0];
2539 if (cached_has_bits & 0x0000001fu) {
2540 // optional bytes padding = 5;
2541 if (cached_has_bits & 0x00000001u) {
2542 total_size += 1 +
2543 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
2544 this->_internal_padding());
2545 }
2546
2547 // optional .storaged_proto.UidIOUsage uid_io_usage = 3;
2548 if (cached_has_bits & 0x00000002u) {
2549 total_size += 1 +
2550 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
2551 *_impl_.uid_io_usage_);
2552 }
2553
2554 // optional .storaged_proto.IOPerfHistory perf_history = 4;
2555 if (cached_has_bits & 0x00000004u) {
2556 total_size += 1 +
2557 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
2558 *_impl_.perf_history_);
2559 }
2560
2561 // optional uint32 crc = 1;
2562 if (cached_has_bits & 0x00000008u) {
2563 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_crc());
2564 }
2565
2566 // optional uint32 version = 2;
2567 if (cached_has_bits & 0x00000010u) {
2568 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_version());
2569 }
2570
2571 }
2572 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2573 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
2574 }
2575 int cached_size = ::_pbi::ToCachedSize(total_size);
2576 SetCachedSize(cached_size);
2577 return total_size;
2578 }
2579
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)2580 void StoragedProto::CheckTypeAndMergeFrom(
2581 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
2582 MergeFrom(*::_pbi::DownCast<const StoragedProto*>(
2583 &from));
2584 }
2585
MergeFrom(const StoragedProto & from)2586 void StoragedProto::MergeFrom(const StoragedProto& from) {
2587 StoragedProto* const _this = this;
2588 // @@protoc_insertion_point(class_specific_merge_from_start:storaged_proto.StoragedProto)
2589 GOOGLE_DCHECK_NE(&from, _this);
2590 ::uint32_t cached_has_bits = 0;
2591 (void) cached_has_bits;
2592
2593 cached_has_bits = from._impl_._has_bits_[0];
2594 if (cached_has_bits & 0x0000001fu) {
2595 if (cached_has_bits & 0x00000001u) {
2596 _this->_internal_set_padding(from._internal_padding());
2597 }
2598 if (cached_has_bits & 0x00000002u) {
2599 _this->_internal_mutable_uid_io_usage()->::storaged_proto::UidIOUsage::MergeFrom(
2600 from._internal_uid_io_usage());
2601 }
2602 if (cached_has_bits & 0x00000004u) {
2603 _this->_internal_mutable_perf_history()->::storaged_proto::IOPerfHistory::MergeFrom(
2604 from._internal_perf_history());
2605 }
2606 if (cached_has_bits & 0x00000008u) {
2607 _this->_impl_.crc_ = from._impl_.crc_;
2608 }
2609 if (cached_has_bits & 0x00000010u) {
2610 _this->_impl_.version_ = from._impl_.version_;
2611 }
2612 _this->_impl_._has_bits_[0] |= cached_has_bits;
2613 }
2614 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2615 }
2616
CopyFrom(const StoragedProto & from)2617 void StoragedProto::CopyFrom(const StoragedProto& from) {
2618 // @@protoc_insertion_point(class_specific_copy_from_start:storaged_proto.StoragedProto)
2619 if (&from == this) return;
2620 Clear();
2621 MergeFrom(from);
2622 }
2623
IsInitialized() const2624 bool StoragedProto::IsInitialized() const {
2625 return true;
2626 }
2627
InternalSwap(StoragedProto * other)2628 void StoragedProto::InternalSwap(StoragedProto* other) {
2629 using std::swap;
2630 auto* lhs_arena = GetArenaForAllocation();
2631 auto* rhs_arena = other->GetArenaForAllocation();
2632 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2633 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
2634 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
2635 &_impl_.padding_, lhs_arena,
2636 &other->_impl_.padding_, rhs_arena
2637 );
2638 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
2639 PROTOBUF_FIELD_OFFSET(StoragedProto, _impl_.version_)
2640 + sizeof(StoragedProto::_impl_.version_) // NOLINT
2641 - PROTOBUF_FIELD_OFFSET(StoragedProto, _impl_.uid_io_usage_)>(
2642 reinterpret_cast<char*>(&_impl_.uid_io_usage_),
2643 reinterpret_cast<char*>(&other->_impl_.uid_io_usage_));
2644 }
2645
GetTypeName() const2646 std::string StoragedProto::GetTypeName() const {
2647 return "storaged_proto.StoragedProto";
2648 }
2649
2650
2651 // @@protoc_insertion_point(namespace_scope)
2652 } // namespace storaged_proto
2653 PROTOBUF_NAMESPACE_OPEN
2654 template<> PROTOBUF_NOINLINE ::storaged_proto::IOUsage*
CreateMaybeMessage(Arena * arena)2655 Arena::CreateMaybeMessage< ::storaged_proto::IOUsage >(Arena* arena) {
2656 return Arena::CreateMessageInternal< ::storaged_proto::IOUsage >(arena);
2657 }
2658 template<> PROTOBUF_NOINLINE ::storaged_proto::TaskIOUsage*
CreateMaybeMessage(Arena * arena)2659 Arena::CreateMaybeMessage< ::storaged_proto::TaskIOUsage >(Arena* arena) {
2660 return Arena::CreateMessageInternal< ::storaged_proto::TaskIOUsage >(arena);
2661 }
2662 template<> PROTOBUF_NOINLINE ::storaged_proto::UidRecord*
CreateMaybeMessage(Arena * arena)2663 Arena::CreateMaybeMessage< ::storaged_proto::UidRecord >(Arena* arena) {
2664 return Arena::CreateMessageInternal< ::storaged_proto::UidRecord >(arena);
2665 }
2666 template<> PROTOBUF_NOINLINE ::storaged_proto::UidIORecords*
CreateMaybeMessage(Arena * arena)2667 Arena::CreateMaybeMessage< ::storaged_proto::UidIORecords >(Arena* arena) {
2668 return Arena::CreateMessageInternal< ::storaged_proto::UidIORecords >(arena);
2669 }
2670 template<> PROTOBUF_NOINLINE ::storaged_proto::UidIOItem*
CreateMaybeMessage(Arena * arena)2671 Arena::CreateMaybeMessage< ::storaged_proto::UidIOItem >(Arena* arena) {
2672 return Arena::CreateMessageInternal< ::storaged_proto::UidIOItem >(arena);
2673 }
2674 template<> PROTOBUF_NOINLINE ::storaged_proto::UidIOUsage*
CreateMaybeMessage(Arena * arena)2675 Arena::CreateMaybeMessage< ::storaged_proto::UidIOUsage >(Arena* arena) {
2676 return Arena::CreateMessageInternal< ::storaged_proto::UidIOUsage >(arena);
2677 }
2678 template<> PROTOBUF_NOINLINE ::storaged_proto::IOPerfHistory*
CreateMaybeMessage(Arena * arena)2679 Arena::CreateMaybeMessage< ::storaged_proto::IOPerfHistory >(Arena* arena) {
2680 return Arena::CreateMessageInternal< ::storaged_proto::IOPerfHistory >(arena);
2681 }
2682 template<> PROTOBUF_NOINLINE ::storaged_proto::StoragedProto*
CreateMaybeMessage(Arena * arena)2683 Arena::CreateMaybeMessage< ::storaged_proto::StoragedProto >(Arena* arena) {
2684 return Arena::CreateMessageInternal< ::storaged_proto::StoragedProto >(arena);
2685 }
2686 PROTOBUF_NAMESPACE_CLOSE
2687
2688 // @@protoc_insertion_point(global_scope)
2689 #include <google/protobuf/port_undef.inc>
2690