1 // Generated by the protocol buffer compiler. DO NOT EDIT!
2 // source: protos/perfetto/trace/ftrace/regulator.proto
3
4 #include "protos/perfetto/trace/ftrace/regulator.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 perfetto {
22 namespace protos {
RegulatorDisableFtraceEvent(::_pbi::ConstantInitialized)23 PROTOBUF_CONSTEXPR RegulatorDisableFtraceEvent::RegulatorDisableFtraceEvent(
24 ::_pbi::ConstantInitialized): _impl_{
25 /*decltype(_impl_._has_bits_)*/{}
26 , /*decltype(_impl_._cached_size_)*/{}
27 , /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {}
28 struct RegulatorDisableFtraceEventDefaultTypeInternal {
RegulatorDisableFtraceEventDefaultTypeInternalperfetto::protos::RegulatorDisableFtraceEventDefaultTypeInternal29 PROTOBUF_CONSTEXPR RegulatorDisableFtraceEventDefaultTypeInternal()
30 : _instance(::_pbi::ConstantInitialized{}) {}
~RegulatorDisableFtraceEventDefaultTypeInternalperfetto::protos::RegulatorDisableFtraceEventDefaultTypeInternal31 ~RegulatorDisableFtraceEventDefaultTypeInternal() {}
32 union { // NOLINT(misc-non-private-member-variables-in-classes)
33 RegulatorDisableFtraceEvent _instance;
34 };
35 };
36 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RegulatorDisableFtraceEventDefaultTypeInternal _RegulatorDisableFtraceEvent_default_instance_;
RegulatorDisableCompleteFtraceEvent(::_pbi::ConstantInitialized)37 PROTOBUF_CONSTEXPR RegulatorDisableCompleteFtraceEvent::RegulatorDisableCompleteFtraceEvent(
38 ::_pbi::ConstantInitialized): _impl_{
39 /*decltype(_impl_._has_bits_)*/{}
40 , /*decltype(_impl_._cached_size_)*/{}
41 , /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {}
42 struct RegulatorDisableCompleteFtraceEventDefaultTypeInternal {
RegulatorDisableCompleteFtraceEventDefaultTypeInternalperfetto::protos::RegulatorDisableCompleteFtraceEventDefaultTypeInternal43 PROTOBUF_CONSTEXPR RegulatorDisableCompleteFtraceEventDefaultTypeInternal()
44 : _instance(::_pbi::ConstantInitialized{}) {}
~RegulatorDisableCompleteFtraceEventDefaultTypeInternalperfetto::protos::RegulatorDisableCompleteFtraceEventDefaultTypeInternal45 ~RegulatorDisableCompleteFtraceEventDefaultTypeInternal() {}
46 union { // NOLINT(misc-non-private-member-variables-in-classes)
47 RegulatorDisableCompleteFtraceEvent _instance;
48 };
49 };
50 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RegulatorDisableCompleteFtraceEventDefaultTypeInternal _RegulatorDisableCompleteFtraceEvent_default_instance_;
RegulatorEnableFtraceEvent(::_pbi::ConstantInitialized)51 PROTOBUF_CONSTEXPR RegulatorEnableFtraceEvent::RegulatorEnableFtraceEvent(
52 ::_pbi::ConstantInitialized): _impl_{
53 /*decltype(_impl_._has_bits_)*/{}
54 , /*decltype(_impl_._cached_size_)*/{}
55 , /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {}
56 struct RegulatorEnableFtraceEventDefaultTypeInternal {
RegulatorEnableFtraceEventDefaultTypeInternalperfetto::protos::RegulatorEnableFtraceEventDefaultTypeInternal57 PROTOBUF_CONSTEXPR RegulatorEnableFtraceEventDefaultTypeInternal()
58 : _instance(::_pbi::ConstantInitialized{}) {}
~RegulatorEnableFtraceEventDefaultTypeInternalperfetto::protos::RegulatorEnableFtraceEventDefaultTypeInternal59 ~RegulatorEnableFtraceEventDefaultTypeInternal() {}
60 union { // NOLINT(misc-non-private-member-variables-in-classes)
61 RegulatorEnableFtraceEvent _instance;
62 };
63 };
64 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RegulatorEnableFtraceEventDefaultTypeInternal _RegulatorEnableFtraceEvent_default_instance_;
RegulatorEnableCompleteFtraceEvent(::_pbi::ConstantInitialized)65 PROTOBUF_CONSTEXPR RegulatorEnableCompleteFtraceEvent::RegulatorEnableCompleteFtraceEvent(
66 ::_pbi::ConstantInitialized): _impl_{
67 /*decltype(_impl_._has_bits_)*/{}
68 , /*decltype(_impl_._cached_size_)*/{}
69 , /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {}
70 struct RegulatorEnableCompleteFtraceEventDefaultTypeInternal {
RegulatorEnableCompleteFtraceEventDefaultTypeInternalperfetto::protos::RegulatorEnableCompleteFtraceEventDefaultTypeInternal71 PROTOBUF_CONSTEXPR RegulatorEnableCompleteFtraceEventDefaultTypeInternal()
72 : _instance(::_pbi::ConstantInitialized{}) {}
~RegulatorEnableCompleteFtraceEventDefaultTypeInternalperfetto::protos::RegulatorEnableCompleteFtraceEventDefaultTypeInternal73 ~RegulatorEnableCompleteFtraceEventDefaultTypeInternal() {}
74 union { // NOLINT(misc-non-private-member-variables-in-classes)
75 RegulatorEnableCompleteFtraceEvent _instance;
76 };
77 };
78 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RegulatorEnableCompleteFtraceEventDefaultTypeInternal _RegulatorEnableCompleteFtraceEvent_default_instance_;
RegulatorEnableDelayFtraceEvent(::_pbi::ConstantInitialized)79 PROTOBUF_CONSTEXPR RegulatorEnableDelayFtraceEvent::RegulatorEnableDelayFtraceEvent(
80 ::_pbi::ConstantInitialized): _impl_{
81 /*decltype(_impl_._has_bits_)*/{}
82 , /*decltype(_impl_._cached_size_)*/{}
83 , /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {}
84 struct RegulatorEnableDelayFtraceEventDefaultTypeInternal {
RegulatorEnableDelayFtraceEventDefaultTypeInternalperfetto::protos::RegulatorEnableDelayFtraceEventDefaultTypeInternal85 PROTOBUF_CONSTEXPR RegulatorEnableDelayFtraceEventDefaultTypeInternal()
86 : _instance(::_pbi::ConstantInitialized{}) {}
~RegulatorEnableDelayFtraceEventDefaultTypeInternalperfetto::protos::RegulatorEnableDelayFtraceEventDefaultTypeInternal87 ~RegulatorEnableDelayFtraceEventDefaultTypeInternal() {}
88 union { // NOLINT(misc-non-private-member-variables-in-classes)
89 RegulatorEnableDelayFtraceEvent _instance;
90 };
91 };
92 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RegulatorEnableDelayFtraceEventDefaultTypeInternal _RegulatorEnableDelayFtraceEvent_default_instance_;
RegulatorSetVoltageFtraceEvent(::_pbi::ConstantInitialized)93 PROTOBUF_CONSTEXPR RegulatorSetVoltageFtraceEvent::RegulatorSetVoltageFtraceEvent(
94 ::_pbi::ConstantInitialized): _impl_{
95 /*decltype(_impl_._has_bits_)*/{}
96 , /*decltype(_impl_._cached_size_)*/{}
97 , /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
98 , /*decltype(_impl_.min_)*/0
99 , /*decltype(_impl_.max_)*/0} {}
100 struct RegulatorSetVoltageFtraceEventDefaultTypeInternal {
RegulatorSetVoltageFtraceEventDefaultTypeInternalperfetto::protos::RegulatorSetVoltageFtraceEventDefaultTypeInternal101 PROTOBUF_CONSTEXPR RegulatorSetVoltageFtraceEventDefaultTypeInternal()
102 : _instance(::_pbi::ConstantInitialized{}) {}
~RegulatorSetVoltageFtraceEventDefaultTypeInternalperfetto::protos::RegulatorSetVoltageFtraceEventDefaultTypeInternal103 ~RegulatorSetVoltageFtraceEventDefaultTypeInternal() {}
104 union { // NOLINT(misc-non-private-member-variables-in-classes)
105 RegulatorSetVoltageFtraceEvent _instance;
106 };
107 };
108 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RegulatorSetVoltageFtraceEventDefaultTypeInternal _RegulatorSetVoltageFtraceEvent_default_instance_;
RegulatorSetVoltageCompleteFtraceEvent(::_pbi::ConstantInitialized)109 PROTOBUF_CONSTEXPR RegulatorSetVoltageCompleteFtraceEvent::RegulatorSetVoltageCompleteFtraceEvent(
110 ::_pbi::ConstantInitialized): _impl_{
111 /*decltype(_impl_._has_bits_)*/{}
112 , /*decltype(_impl_._cached_size_)*/{}
113 , /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
114 , /*decltype(_impl_.val_)*/0u} {}
115 struct RegulatorSetVoltageCompleteFtraceEventDefaultTypeInternal {
RegulatorSetVoltageCompleteFtraceEventDefaultTypeInternalperfetto::protos::RegulatorSetVoltageCompleteFtraceEventDefaultTypeInternal116 PROTOBUF_CONSTEXPR RegulatorSetVoltageCompleteFtraceEventDefaultTypeInternal()
117 : _instance(::_pbi::ConstantInitialized{}) {}
~RegulatorSetVoltageCompleteFtraceEventDefaultTypeInternalperfetto::protos::RegulatorSetVoltageCompleteFtraceEventDefaultTypeInternal118 ~RegulatorSetVoltageCompleteFtraceEventDefaultTypeInternal() {}
119 union { // NOLINT(misc-non-private-member-variables-in-classes)
120 RegulatorSetVoltageCompleteFtraceEvent _instance;
121 };
122 };
123 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RegulatorSetVoltageCompleteFtraceEventDefaultTypeInternal _RegulatorSetVoltageCompleteFtraceEvent_default_instance_;
124 } // namespace protos
125 } // namespace perfetto
126 namespace perfetto {
127 namespace protos {
128
129 // ===================================================================
130
131 class RegulatorDisableFtraceEvent::_Internal {
132 public:
133 using HasBits = decltype(std::declval<RegulatorDisableFtraceEvent>()._impl_._has_bits_);
set_has_name(HasBits * has_bits)134 static void set_has_name(HasBits* has_bits) {
135 (*has_bits)[0] |= 1u;
136 }
137 };
138
RegulatorDisableFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)139 RegulatorDisableFtraceEvent::RegulatorDisableFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
140 bool is_message_owned)
141 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
142 SharedCtor(arena, is_message_owned);
143 // @@protoc_insertion_point(arena_constructor:perfetto.protos.RegulatorDisableFtraceEvent)
144 }
RegulatorDisableFtraceEvent(const RegulatorDisableFtraceEvent & from)145 RegulatorDisableFtraceEvent::RegulatorDisableFtraceEvent(const RegulatorDisableFtraceEvent& from)
146 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
147 RegulatorDisableFtraceEvent* const _this = this; (void)_this;
148 new (&_impl_) Impl_{
149 decltype(_impl_._has_bits_){from._impl_._has_bits_}
150 , /*decltype(_impl_._cached_size_)*/{}
151 , decltype(_impl_.name_){}};
152
153 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
154 _impl_.name_.InitDefault();
155 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
156 _impl_.name_.Set("", GetArenaForAllocation());
157 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
158 if (from._internal_has_name()) {
159 _this->_impl_.name_.Set(from._internal_name(),
160 _this->GetArenaForAllocation());
161 }
162 // @@protoc_insertion_point(copy_constructor:perfetto.protos.RegulatorDisableFtraceEvent)
163 }
164
SharedCtor(::_pb::Arena * arena,bool is_message_owned)165 inline void RegulatorDisableFtraceEvent::SharedCtor(
166 ::_pb::Arena* arena, bool is_message_owned) {
167 (void)arena;
168 (void)is_message_owned;
169 new (&_impl_) Impl_{
170 decltype(_impl_._has_bits_){}
171 , /*decltype(_impl_._cached_size_)*/{}
172 , decltype(_impl_.name_){}
173 };
174 _impl_.name_.InitDefault();
175 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
176 _impl_.name_.Set("", GetArenaForAllocation());
177 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
178 }
179
~RegulatorDisableFtraceEvent()180 RegulatorDisableFtraceEvent::~RegulatorDisableFtraceEvent() {
181 // @@protoc_insertion_point(destructor:perfetto.protos.RegulatorDisableFtraceEvent)
182 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
183 (void)arena;
184 return;
185 }
186 SharedDtor();
187 }
188
SharedDtor()189 inline void RegulatorDisableFtraceEvent::SharedDtor() {
190 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
191 _impl_.name_.Destroy();
192 }
193
SetCachedSize(int size) const194 void RegulatorDisableFtraceEvent::SetCachedSize(int size) const {
195 _impl_._cached_size_.Set(size);
196 }
197
Clear()198 void RegulatorDisableFtraceEvent::Clear() {
199 // @@protoc_insertion_point(message_clear_start:perfetto.protos.RegulatorDisableFtraceEvent)
200 ::uint32_t cached_has_bits = 0;
201 // Prevent compiler warnings about cached_has_bits being unused
202 (void) cached_has_bits;
203
204 cached_has_bits = _impl_._has_bits_[0];
205 if (cached_has_bits & 0x00000001u) {
206 _impl_.name_.ClearNonDefaultToEmpty();
207 }
208 _impl_._has_bits_.Clear();
209 _internal_metadata_.Clear<std::string>();
210 }
211
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)212 const char* RegulatorDisableFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
213 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
214 _Internal::HasBits has_bits{};
215 while (!ctx->Done(&ptr)) {
216 ::uint32_t tag;
217 ptr = ::_pbi::ReadTag(ptr, &tag);
218 switch (tag >> 3) {
219 // optional string name = 1;
220 case 1:
221 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
222 auto str = _internal_mutable_name();
223 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
224 CHK_(ptr);
225 } else {
226 goto handle_unusual;
227 }
228 continue;
229 default:
230 goto handle_unusual;
231 } // switch
232 handle_unusual:
233 if ((tag == 0) || ((tag & 7) == 4)) {
234 CHK_(ptr);
235 ctx->SetLastTag(tag);
236 goto message_done;
237 }
238 ptr = UnknownFieldParse(
239 tag,
240 _internal_metadata_.mutable_unknown_fields<std::string>(),
241 ptr, ctx);
242 CHK_(ptr != nullptr);
243 } // while
244 message_done:
245 _impl_._has_bits_.Or(has_bits);
246 return ptr;
247 failure:
248 ptr = nullptr;
249 goto message_done;
250 #undef CHK_
251 }
252
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const253 ::uint8_t* RegulatorDisableFtraceEvent::_InternalSerialize(
254 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
255 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.RegulatorDisableFtraceEvent)
256 ::uint32_t cached_has_bits = 0;
257 (void) cached_has_bits;
258
259 cached_has_bits = _impl_._has_bits_[0];
260 // optional string name = 1;
261 if (cached_has_bits & 0x00000001u) {
262 target = stream->WriteStringMaybeAliased(
263 1, this->_internal_name(), target);
264 }
265
266 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
267 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
268 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
269 }
270 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.RegulatorDisableFtraceEvent)
271 return target;
272 }
273
ByteSizeLong() const274 size_t RegulatorDisableFtraceEvent::ByteSizeLong() const {
275 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.RegulatorDisableFtraceEvent)
276 size_t total_size = 0;
277
278 ::uint32_t cached_has_bits = 0;
279 // Prevent compiler warnings about cached_has_bits being unused
280 (void) cached_has_bits;
281
282 // optional string name = 1;
283 cached_has_bits = _impl_._has_bits_[0];
284 if (cached_has_bits & 0x00000001u) {
285 total_size += 1 +
286 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
287 this->_internal_name());
288 }
289
290 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
291 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
292 }
293 int cached_size = ::_pbi::ToCachedSize(total_size);
294 SetCachedSize(cached_size);
295 return total_size;
296 }
297
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)298 void RegulatorDisableFtraceEvent::CheckTypeAndMergeFrom(
299 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
300 MergeFrom(*::_pbi::DownCast<const RegulatorDisableFtraceEvent*>(
301 &from));
302 }
303
MergeFrom(const RegulatorDisableFtraceEvent & from)304 void RegulatorDisableFtraceEvent::MergeFrom(const RegulatorDisableFtraceEvent& from) {
305 RegulatorDisableFtraceEvent* const _this = this;
306 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.RegulatorDisableFtraceEvent)
307 GOOGLE_DCHECK_NE(&from, _this);
308 ::uint32_t cached_has_bits = 0;
309 (void) cached_has_bits;
310
311 if (from._internal_has_name()) {
312 _this->_internal_set_name(from._internal_name());
313 }
314 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
315 }
316
CopyFrom(const RegulatorDisableFtraceEvent & from)317 void RegulatorDisableFtraceEvent::CopyFrom(const RegulatorDisableFtraceEvent& from) {
318 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.RegulatorDisableFtraceEvent)
319 if (&from == this) return;
320 Clear();
321 MergeFrom(from);
322 }
323
IsInitialized() const324 bool RegulatorDisableFtraceEvent::IsInitialized() const {
325 return true;
326 }
327
InternalSwap(RegulatorDisableFtraceEvent * other)328 void RegulatorDisableFtraceEvent::InternalSwap(RegulatorDisableFtraceEvent* other) {
329 using std::swap;
330 auto* lhs_arena = GetArenaForAllocation();
331 auto* rhs_arena = other->GetArenaForAllocation();
332 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
333 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
334 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
335 &_impl_.name_, lhs_arena,
336 &other->_impl_.name_, rhs_arena
337 );
338 }
339
GetTypeName() const340 std::string RegulatorDisableFtraceEvent::GetTypeName() const {
341 return "perfetto.protos.RegulatorDisableFtraceEvent";
342 }
343
344
345 // ===================================================================
346
347 class RegulatorDisableCompleteFtraceEvent::_Internal {
348 public:
349 using HasBits = decltype(std::declval<RegulatorDisableCompleteFtraceEvent>()._impl_._has_bits_);
set_has_name(HasBits * has_bits)350 static void set_has_name(HasBits* has_bits) {
351 (*has_bits)[0] |= 1u;
352 }
353 };
354
RegulatorDisableCompleteFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)355 RegulatorDisableCompleteFtraceEvent::RegulatorDisableCompleteFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
356 bool is_message_owned)
357 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
358 SharedCtor(arena, is_message_owned);
359 // @@protoc_insertion_point(arena_constructor:perfetto.protos.RegulatorDisableCompleteFtraceEvent)
360 }
RegulatorDisableCompleteFtraceEvent(const RegulatorDisableCompleteFtraceEvent & from)361 RegulatorDisableCompleteFtraceEvent::RegulatorDisableCompleteFtraceEvent(const RegulatorDisableCompleteFtraceEvent& from)
362 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
363 RegulatorDisableCompleteFtraceEvent* const _this = this; (void)_this;
364 new (&_impl_) Impl_{
365 decltype(_impl_._has_bits_){from._impl_._has_bits_}
366 , /*decltype(_impl_._cached_size_)*/{}
367 , decltype(_impl_.name_){}};
368
369 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
370 _impl_.name_.InitDefault();
371 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
372 _impl_.name_.Set("", GetArenaForAllocation());
373 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
374 if (from._internal_has_name()) {
375 _this->_impl_.name_.Set(from._internal_name(),
376 _this->GetArenaForAllocation());
377 }
378 // @@protoc_insertion_point(copy_constructor:perfetto.protos.RegulatorDisableCompleteFtraceEvent)
379 }
380
SharedCtor(::_pb::Arena * arena,bool is_message_owned)381 inline void RegulatorDisableCompleteFtraceEvent::SharedCtor(
382 ::_pb::Arena* arena, bool is_message_owned) {
383 (void)arena;
384 (void)is_message_owned;
385 new (&_impl_) Impl_{
386 decltype(_impl_._has_bits_){}
387 , /*decltype(_impl_._cached_size_)*/{}
388 , decltype(_impl_.name_){}
389 };
390 _impl_.name_.InitDefault();
391 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
392 _impl_.name_.Set("", GetArenaForAllocation());
393 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
394 }
395
~RegulatorDisableCompleteFtraceEvent()396 RegulatorDisableCompleteFtraceEvent::~RegulatorDisableCompleteFtraceEvent() {
397 // @@protoc_insertion_point(destructor:perfetto.protos.RegulatorDisableCompleteFtraceEvent)
398 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
399 (void)arena;
400 return;
401 }
402 SharedDtor();
403 }
404
SharedDtor()405 inline void RegulatorDisableCompleteFtraceEvent::SharedDtor() {
406 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
407 _impl_.name_.Destroy();
408 }
409
SetCachedSize(int size) const410 void RegulatorDisableCompleteFtraceEvent::SetCachedSize(int size) const {
411 _impl_._cached_size_.Set(size);
412 }
413
Clear()414 void RegulatorDisableCompleteFtraceEvent::Clear() {
415 // @@protoc_insertion_point(message_clear_start:perfetto.protos.RegulatorDisableCompleteFtraceEvent)
416 ::uint32_t cached_has_bits = 0;
417 // Prevent compiler warnings about cached_has_bits being unused
418 (void) cached_has_bits;
419
420 cached_has_bits = _impl_._has_bits_[0];
421 if (cached_has_bits & 0x00000001u) {
422 _impl_.name_.ClearNonDefaultToEmpty();
423 }
424 _impl_._has_bits_.Clear();
425 _internal_metadata_.Clear<std::string>();
426 }
427
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)428 const char* RegulatorDisableCompleteFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
429 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
430 _Internal::HasBits has_bits{};
431 while (!ctx->Done(&ptr)) {
432 ::uint32_t tag;
433 ptr = ::_pbi::ReadTag(ptr, &tag);
434 switch (tag >> 3) {
435 // optional string name = 1;
436 case 1:
437 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
438 auto str = _internal_mutable_name();
439 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
440 CHK_(ptr);
441 } else {
442 goto handle_unusual;
443 }
444 continue;
445 default:
446 goto handle_unusual;
447 } // switch
448 handle_unusual:
449 if ((tag == 0) || ((tag & 7) == 4)) {
450 CHK_(ptr);
451 ctx->SetLastTag(tag);
452 goto message_done;
453 }
454 ptr = UnknownFieldParse(
455 tag,
456 _internal_metadata_.mutable_unknown_fields<std::string>(),
457 ptr, ctx);
458 CHK_(ptr != nullptr);
459 } // while
460 message_done:
461 _impl_._has_bits_.Or(has_bits);
462 return ptr;
463 failure:
464 ptr = nullptr;
465 goto message_done;
466 #undef CHK_
467 }
468
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const469 ::uint8_t* RegulatorDisableCompleteFtraceEvent::_InternalSerialize(
470 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
471 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.RegulatorDisableCompleteFtraceEvent)
472 ::uint32_t cached_has_bits = 0;
473 (void) cached_has_bits;
474
475 cached_has_bits = _impl_._has_bits_[0];
476 // optional string name = 1;
477 if (cached_has_bits & 0x00000001u) {
478 target = stream->WriteStringMaybeAliased(
479 1, this->_internal_name(), target);
480 }
481
482 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
483 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
484 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
485 }
486 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.RegulatorDisableCompleteFtraceEvent)
487 return target;
488 }
489
ByteSizeLong() const490 size_t RegulatorDisableCompleteFtraceEvent::ByteSizeLong() const {
491 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.RegulatorDisableCompleteFtraceEvent)
492 size_t total_size = 0;
493
494 ::uint32_t cached_has_bits = 0;
495 // Prevent compiler warnings about cached_has_bits being unused
496 (void) cached_has_bits;
497
498 // optional string name = 1;
499 cached_has_bits = _impl_._has_bits_[0];
500 if (cached_has_bits & 0x00000001u) {
501 total_size += 1 +
502 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
503 this->_internal_name());
504 }
505
506 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
507 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
508 }
509 int cached_size = ::_pbi::ToCachedSize(total_size);
510 SetCachedSize(cached_size);
511 return total_size;
512 }
513
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)514 void RegulatorDisableCompleteFtraceEvent::CheckTypeAndMergeFrom(
515 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
516 MergeFrom(*::_pbi::DownCast<const RegulatorDisableCompleteFtraceEvent*>(
517 &from));
518 }
519
MergeFrom(const RegulatorDisableCompleteFtraceEvent & from)520 void RegulatorDisableCompleteFtraceEvent::MergeFrom(const RegulatorDisableCompleteFtraceEvent& from) {
521 RegulatorDisableCompleteFtraceEvent* const _this = this;
522 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.RegulatorDisableCompleteFtraceEvent)
523 GOOGLE_DCHECK_NE(&from, _this);
524 ::uint32_t cached_has_bits = 0;
525 (void) cached_has_bits;
526
527 if (from._internal_has_name()) {
528 _this->_internal_set_name(from._internal_name());
529 }
530 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
531 }
532
CopyFrom(const RegulatorDisableCompleteFtraceEvent & from)533 void RegulatorDisableCompleteFtraceEvent::CopyFrom(const RegulatorDisableCompleteFtraceEvent& from) {
534 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.RegulatorDisableCompleteFtraceEvent)
535 if (&from == this) return;
536 Clear();
537 MergeFrom(from);
538 }
539
IsInitialized() const540 bool RegulatorDisableCompleteFtraceEvent::IsInitialized() const {
541 return true;
542 }
543
InternalSwap(RegulatorDisableCompleteFtraceEvent * other)544 void RegulatorDisableCompleteFtraceEvent::InternalSwap(RegulatorDisableCompleteFtraceEvent* other) {
545 using std::swap;
546 auto* lhs_arena = GetArenaForAllocation();
547 auto* rhs_arena = other->GetArenaForAllocation();
548 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
549 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
550 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
551 &_impl_.name_, lhs_arena,
552 &other->_impl_.name_, rhs_arena
553 );
554 }
555
GetTypeName() const556 std::string RegulatorDisableCompleteFtraceEvent::GetTypeName() const {
557 return "perfetto.protos.RegulatorDisableCompleteFtraceEvent";
558 }
559
560
561 // ===================================================================
562
563 class RegulatorEnableFtraceEvent::_Internal {
564 public:
565 using HasBits = decltype(std::declval<RegulatorEnableFtraceEvent>()._impl_._has_bits_);
set_has_name(HasBits * has_bits)566 static void set_has_name(HasBits* has_bits) {
567 (*has_bits)[0] |= 1u;
568 }
569 };
570
RegulatorEnableFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)571 RegulatorEnableFtraceEvent::RegulatorEnableFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
572 bool is_message_owned)
573 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
574 SharedCtor(arena, is_message_owned);
575 // @@protoc_insertion_point(arena_constructor:perfetto.protos.RegulatorEnableFtraceEvent)
576 }
RegulatorEnableFtraceEvent(const RegulatorEnableFtraceEvent & from)577 RegulatorEnableFtraceEvent::RegulatorEnableFtraceEvent(const RegulatorEnableFtraceEvent& from)
578 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
579 RegulatorEnableFtraceEvent* const _this = this; (void)_this;
580 new (&_impl_) Impl_{
581 decltype(_impl_._has_bits_){from._impl_._has_bits_}
582 , /*decltype(_impl_._cached_size_)*/{}
583 , decltype(_impl_.name_){}};
584
585 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
586 _impl_.name_.InitDefault();
587 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
588 _impl_.name_.Set("", GetArenaForAllocation());
589 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
590 if (from._internal_has_name()) {
591 _this->_impl_.name_.Set(from._internal_name(),
592 _this->GetArenaForAllocation());
593 }
594 // @@protoc_insertion_point(copy_constructor:perfetto.protos.RegulatorEnableFtraceEvent)
595 }
596
SharedCtor(::_pb::Arena * arena,bool is_message_owned)597 inline void RegulatorEnableFtraceEvent::SharedCtor(
598 ::_pb::Arena* arena, bool is_message_owned) {
599 (void)arena;
600 (void)is_message_owned;
601 new (&_impl_) Impl_{
602 decltype(_impl_._has_bits_){}
603 , /*decltype(_impl_._cached_size_)*/{}
604 , decltype(_impl_.name_){}
605 };
606 _impl_.name_.InitDefault();
607 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
608 _impl_.name_.Set("", GetArenaForAllocation());
609 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
610 }
611
~RegulatorEnableFtraceEvent()612 RegulatorEnableFtraceEvent::~RegulatorEnableFtraceEvent() {
613 // @@protoc_insertion_point(destructor:perfetto.protos.RegulatorEnableFtraceEvent)
614 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
615 (void)arena;
616 return;
617 }
618 SharedDtor();
619 }
620
SharedDtor()621 inline void RegulatorEnableFtraceEvent::SharedDtor() {
622 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
623 _impl_.name_.Destroy();
624 }
625
SetCachedSize(int size) const626 void RegulatorEnableFtraceEvent::SetCachedSize(int size) const {
627 _impl_._cached_size_.Set(size);
628 }
629
Clear()630 void RegulatorEnableFtraceEvent::Clear() {
631 // @@protoc_insertion_point(message_clear_start:perfetto.protos.RegulatorEnableFtraceEvent)
632 ::uint32_t cached_has_bits = 0;
633 // Prevent compiler warnings about cached_has_bits being unused
634 (void) cached_has_bits;
635
636 cached_has_bits = _impl_._has_bits_[0];
637 if (cached_has_bits & 0x00000001u) {
638 _impl_.name_.ClearNonDefaultToEmpty();
639 }
640 _impl_._has_bits_.Clear();
641 _internal_metadata_.Clear<std::string>();
642 }
643
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)644 const char* RegulatorEnableFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
645 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
646 _Internal::HasBits has_bits{};
647 while (!ctx->Done(&ptr)) {
648 ::uint32_t tag;
649 ptr = ::_pbi::ReadTag(ptr, &tag);
650 switch (tag >> 3) {
651 // optional string name = 1;
652 case 1:
653 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
654 auto str = _internal_mutable_name();
655 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
656 CHK_(ptr);
657 } else {
658 goto handle_unusual;
659 }
660 continue;
661 default:
662 goto handle_unusual;
663 } // switch
664 handle_unusual:
665 if ((tag == 0) || ((tag & 7) == 4)) {
666 CHK_(ptr);
667 ctx->SetLastTag(tag);
668 goto message_done;
669 }
670 ptr = UnknownFieldParse(
671 tag,
672 _internal_metadata_.mutable_unknown_fields<std::string>(),
673 ptr, ctx);
674 CHK_(ptr != nullptr);
675 } // while
676 message_done:
677 _impl_._has_bits_.Or(has_bits);
678 return ptr;
679 failure:
680 ptr = nullptr;
681 goto message_done;
682 #undef CHK_
683 }
684
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const685 ::uint8_t* RegulatorEnableFtraceEvent::_InternalSerialize(
686 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
687 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.RegulatorEnableFtraceEvent)
688 ::uint32_t cached_has_bits = 0;
689 (void) cached_has_bits;
690
691 cached_has_bits = _impl_._has_bits_[0];
692 // optional string name = 1;
693 if (cached_has_bits & 0x00000001u) {
694 target = stream->WriteStringMaybeAliased(
695 1, this->_internal_name(), target);
696 }
697
698 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
699 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
700 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
701 }
702 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.RegulatorEnableFtraceEvent)
703 return target;
704 }
705
ByteSizeLong() const706 size_t RegulatorEnableFtraceEvent::ByteSizeLong() const {
707 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.RegulatorEnableFtraceEvent)
708 size_t total_size = 0;
709
710 ::uint32_t cached_has_bits = 0;
711 // Prevent compiler warnings about cached_has_bits being unused
712 (void) cached_has_bits;
713
714 // optional string name = 1;
715 cached_has_bits = _impl_._has_bits_[0];
716 if (cached_has_bits & 0x00000001u) {
717 total_size += 1 +
718 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
719 this->_internal_name());
720 }
721
722 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
723 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
724 }
725 int cached_size = ::_pbi::ToCachedSize(total_size);
726 SetCachedSize(cached_size);
727 return total_size;
728 }
729
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)730 void RegulatorEnableFtraceEvent::CheckTypeAndMergeFrom(
731 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
732 MergeFrom(*::_pbi::DownCast<const RegulatorEnableFtraceEvent*>(
733 &from));
734 }
735
MergeFrom(const RegulatorEnableFtraceEvent & from)736 void RegulatorEnableFtraceEvent::MergeFrom(const RegulatorEnableFtraceEvent& from) {
737 RegulatorEnableFtraceEvent* const _this = this;
738 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.RegulatorEnableFtraceEvent)
739 GOOGLE_DCHECK_NE(&from, _this);
740 ::uint32_t cached_has_bits = 0;
741 (void) cached_has_bits;
742
743 if (from._internal_has_name()) {
744 _this->_internal_set_name(from._internal_name());
745 }
746 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
747 }
748
CopyFrom(const RegulatorEnableFtraceEvent & from)749 void RegulatorEnableFtraceEvent::CopyFrom(const RegulatorEnableFtraceEvent& from) {
750 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.RegulatorEnableFtraceEvent)
751 if (&from == this) return;
752 Clear();
753 MergeFrom(from);
754 }
755
IsInitialized() const756 bool RegulatorEnableFtraceEvent::IsInitialized() const {
757 return true;
758 }
759
InternalSwap(RegulatorEnableFtraceEvent * other)760 void RegulatorEnableFtraceEvent::InternalSwap(RegulatorEnableFtraceEvent* other) {
761 using std::swap;
762 auto* lhs_arena = GetArenaForAllocation();
763 auto* rhs_arena = other->GetArenaForAllocation();
764 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
765 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
766 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
767 &_impl_.name_, lhs_arena,
768 &other->_impl_.name_, rhs_arena
769 );
770 }
771
GetTypeName() const772 std::string RegulatorEnableFtraceEvent::GetTypeName() const {
773 return "perfetto.protos.RegulatorEnableFtraceEvent";
774 }
775
776
777 // ===================================================================
778
779 class RegulatorEnableCompleteFtraceEvent::_Internal {
780 public:
781 using HasBits = decltype(std::declval<RegulatorEnableCompleteFtraceEvent>()._impl_._has_bits_);
set_has_name(HasBits * has_bits)782 static void set_has_name(HasBits* has_bits) {
783 (*has_bits)[0] |= 1u;
784 }
785 };
786
RegulatorEnableCompleteFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)787 RegulatorEnableCompleteFtraceEvent::RegulatorEnableCompleteFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
788 bool is_message_owned)
789 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
790 SharedCtor(arena, is_message_owned);
791 // @@protoc_insertion_point(arena_constructor:perfetto.protos.RegulatorEnableCompleteFtraceEvent)
792 }
RegulatorEnableCompleteFtraceEvent(const RegulatorEnableCompleteFtraceEvent & from)793 RegulatorEnableCompleteFtraceEvent::RegulatorEnableCompleteFtraceEvent(const RegulatorEnableCompleteFtraceEvent& from)
794 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
795 RegulatorEnableCompleteFtraceEvent* const _this = this; (void)_this;
796 new (&_impl_) Impl_{
797 decltype(_impl_._has_bits_){from._impl_._has_bits_}
798 , /*decltype(_impl_._cached_size_)*/{}
799 , decltype(_impl_.name_){}};
800
801 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
802 _impl_.name_.InitDefault();
803 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
804 _impl_.name_.Set("", GetArenaForAllocation());
805 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
806 if (from._internal_has_name()) {
807 _this->_impl_.name_.Set(from._internal_name(),
808 _this->GetArenaForAllocation());
809 }
810 // @@protoc_insertion_point(copy_constructor:perfetto.protos.RegulatorEnableCompleteFtraceEvent)
811 }
812
SharedCtor(::_pb::Arena * arena,bool is_message_owned)813 inline void RegulatorEnableCompleteFtraceEvent::SharedCtor(
814 ::_pb::Arena* arena, bool is_message_owned) {
815 (void)arena;
816 (void)is_message_owned;
817 new (&_impl_) Impl_{
818 decltype(_impl_._has_bits_){}
819 , /*decltype(_impl_._cached_size_)*/{}
820 , decltype(_impl_.name_){}
821 };
822 _impl_.name_.InitDefault();
823 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
824 _impl_.name_.Set("", GetArenaForAllocation());
825 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
826 }
827
~RegulatorEnableCompleteFtraceEvent()828 RegulatorEnableCompleteFtraceEvent::~RegulatorEnableCompleteFtraceEvent() {
829 // @@protoc_insertion_point(destructor:perfetto.protos.RegulatorEnableCompleteFtraceEvent)
830 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
831 (void)arena;
832 return;
833 }
834 SharedDtor();
835 }
836
SharedDtor()837 inline void RegulatorEnableCompleteFtraceEvent::SharedDtor() {
838 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
839 _impl_.name_.Destroy();
840 }
841
SetCachedSize(int size) const842 void RegulatorEnableCompleteFtraceEvent::SetCachedSize(int size) const {
843 _impl_._cached_size_.Set(size);
844 }
845
Clear()846 void RegulatorEnableCompleteFtraceEvent::Clear() {
847 // @@protoc_insertion_point(message_clear_start:perfetto.protos.RegulatorEnableCompleteFtraceEvent)
848 ::uint32_t cached_has_bits = 0;
849 // Prevent compiler warnings about cached_has_bits being unused
850 (void) cached_has_bits;
851
852 cached_has_bits = _impl_._has_bits_[0];
853 if (cached_has_bits & 0x00000001u) {
854 _impl_.name_.ClearNonDefaultToEmpty();
855 }
856 _impl_._has_bits_.Clear();
857 _internal_metadata_.Clear<std::string>();
858 }
859
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)860 const char* RegulatorEnableCompleteFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
861 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
862 _Internal::HasBits has_bits{};
863 while (!ctx->Done(&ptr)) {
864 ::uint32_t tag;
865 ptr = ::_pbi::ReadTag(ptr, &tag);
866 switch (tag >> 3) {
867 // optional string name = 1;
868 case 1:
869 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
870 auto str = _internal_mutable_name();
871 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
872 CHK_(ptr);
873 } else {
874 goto handle_unusual;
875 }
876 continue;
877 default:
878 goto handle_unusual;
879 } // switch
880 handle_unusual:
881 if ((tag == 0) || ((tag & 7) == 4)) {
882 CHK_(ptr);
883 ctx->SetLastTag(tag);
884 goto message_done;
885 }
886 ptr = UnknownFieldParse(
887 tag,
888 _internal_metadata_.mutable_unknown_fields<std::string>(),
889 ptr, ctx);
890 CHK_(ptr != nullptr);
891 } // while
892 message_done:
893 _impl_._has_bits_.Or(has_bits);
894 return ptr;
895 failure:
896 ptr = nullptr;
897 goto message_done;
898 #undef CHK_
899 }
900
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const901 ::uint8_t* RegulatorEnableCompleteFtraceEvent::_InternalSerialize(
902 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
903 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.RegulatorEnableCompleteFtraceEvent)
904 ::uint32_t cached_has_bits = 0;
905 (void) cached_has_bits;
906
907 cached_has_bits = _impl_._has_bits_[0];
908 // optional string name = 1;
909 if (cached_has_bits & 0x00000001u) {
910 target = stream->WriteStringMaybeAliased(
911 1, this->_internal_name(), target);
912 }
913
914 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
915 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
916 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
917 }
918 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.RegulatorEnableCompleteFtraceEvent)
919 return target;
920 }
921
ByteSizeLong() const922 size_t RegulatorEnableCompleteFtraceEvent::ByteSizeLong() const {
923 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.RegulatorEnableCompleteFtraceEvent)
924 size_t total_size = 0;
925
926 ::uint32_t cached_has_bits = 0;
927 // Prevent compiler warnings about cached_has_bits being unused
928 (void) cached_has_bits;
929
930 // optional string name = 1;
931 cached_has_bits = _impl_._has_bits_[0];
932 if (cached_has_bits & 0x00000001u) {
933 total_size += 1 +
934 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
935 this->_internal_name());
936 }
937
938 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
939 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
940 }
941 int cached_size = ::_pbi::ToCachedSize(total_size);
942 SetCachedSize(cached_size);
943 return total_size;
944 }
945
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)946 void RegulatorEnableCompleteFtraceEvent::CheckTypeAndMergeFrom(
947 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
948 MergeFrom(*::_pbi::DownCast<const RegulatorEnableCompleteFtraceEvent*>(
949 &from));
950 }
951
MergeFrom(const RegulatorEnableCompleteFtraceEvent & from)952 void RegulatorEnableCompleteFtraceEvent::MergeFrom(const RegulatorEnableCompleteFtraceEvent& from) {
953 RegulatorEnableCompleteFtraceEvent* const _this = this;
954 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.RegulatorEnableCompleteFtraceEvent)
955 GOOGLE_DCHECK_NE(&from, _this);
956 ::uint32_t cached_has_bits = 0;
957 (void) cached_has_bits;
958
959 if (from._internal_has_name()) {
960 _this->_internal_set_name(from._internal_name());
961 }
962 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
963 }
964
CopyFrom(const RegulatorEnableCompleteFtraceEvent & from)965 void RegulatorEnableCompleteFtraceEvent::CopyFrom(const RegulatorEnableCompleteFtraceEvent& from) {
966 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.RegulatorEnableCompleteFtraceEvent)
967 if (&from == this) return;
968 Clear();
969 MergeFrom(from);
970 }
971
IsInitialized() const972 bool RegulatorEnableCompleteFtraceEvent::IsInitialized() const {
973 return true;
974 }
975
InternalSwap(RegulatorEnableCompleteFtraceEvent * other)976 void RegulatorEnableCompleteFtraceEvent::InternalSwap(RegulatorEnableCompleteFtraceEvent* other) {
977 using std::swap;
978 auto* lhs_arena = GetArenaForAllocation();
979 auto* rhs_arena = other->GetArenaForAllocation();
980 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
981 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
982 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
983 &_impl_.name_, lhs_arena,
984 &other->_impl_.name_, rhs_arena
985 );
986 }
987
GetTypeName() const988 std::string RegulatorEnableCompleteFtraceEvent::GetTypeName() const {
989 return "perfetto.protos.RegulatorEnableCompleteFtraceEvent";
990 }
991
992
993 // ===================================================================
994
995 class RegulatorEnableDelayFtraceEvent::_Internal {
996 public:
997 using HasBits = decltype(std::declval<RegulatorEnableDelayFtraceEvent>()._impl_._has_bits_);
set_has_name(HasBits * has_bits)998 static void set_has_name(HasBits* has_bits) {
999 (*has_bits)[0] |= 1u;
1000 }
1001 };
1002
RegulatorEnableDelayFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1003 RegulatorEnableDelayFtraceEvent::RegulatorEnableDelayFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1004 bool is_message_owned)
1005 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1006 SharedCtor(arena, is_message_owned);
1007 // @@protoc_insertion_point(arena_constructor:perfetto.protos.RegulatorEnableDelayFtraceEvent)
1008 }
RegulatorEnableDelayFtraceEvent(const RegulatorEnableDelayFtraceEvent & from)1009 RegulatorEnableDelayFtraceEvent::RegulatorEnableDelayFtraceEvent(const RegulatorEnableDelayFtraceEvent& from)
1010 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1011 RegulatorEnableDelayFtraceEvent* const _this = this; (void)_this;
1012 new (&_impl_) Impl_{
1013 decltype(_impl_._has_bits_){from._impl_._has_bits_}
1014 , /*decltype(_impl_._cached_size_)*/{}
1015 , decltype(_impl_.name_){}};
1016
1017 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1018 _impl_.name_.InitDefault();
1019 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1020 _impl_.name_.Set("", GetArenaForAllocation());
1021 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1022 if (from._internal_has_name()) {
1023 _this->_impl_.name_.Set(from._internal_name(),
1024 _this->GetArenaForAllocation());
1025 }
1026 // @@protoc_insertion_point(copy_constructor:perfetto.protos.RegulatorEnableDelayFtraceEvent)
1027 }
1028
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1029 inline void RegulatorEnableDelayFtraceEvent::SharedCtor(
1030 ::_pb::Arena* arena, bool is_message_owned) {
1031 (void)arena;
1032 (void)is_message_owned;
1033 new (&_impl_) Impl_{
1034 decltype(_impl_._has_bits_){}
1035 , /*decltype(_impl_._cached_size_)*/{}
1036 , decltype(_impl_.name_){}
1037 };
1038 _impl_.name_.InitDefault();
1039 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1040 _impl_.name_.Set("", GetArenaForAllocation());
1041 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1042 }
1043
~RegulatorEnableDelayFtraceEvent()1044 RegulatorEnableDelayFtraceEvent::~RegulatorEnableDelayFtraceEvent() {
1045 // @@protoc_insertion_point(destructor:perfetto.protos.RegulatorEnableDelayFtraceEvent)
1046 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1047 (void)arena;
1048 return;
1049 }
1050 SharedDtor();
1051 }
1052
SharedDtor()1053 inline void RegulatorEnableDelayFtraceEvent::SharedDtor() {
1054 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1055 _impl_.name_.Destroy();
1056 }
1057
SetCachedSize(int size) const1058 void RegulatorEnableDelayFtraceEvent::SetCachedSize(int size) const {
1059 _impl_._cached_size_.Set(size);
1060 }
1061
Clear()1062 void RegulatorEnableDelayFtraceEvent::Clear() {
1063 // @@protoc_insertion_point(message_clear_start:perfetto.protos.RegulatorEnableDelayFtraceEvent)
1064 ::uint32_t cached_has_bits = 0;
1065 // Prevent compiler warnings about cached_has_bits being unused
1066 (void) cached_has_bits;
1067
1068 cached_has_bits = _impl_._has_bits_[0];
1069 if (cached_has_bits & 0x00000001u) {
1070 _impl_.name_.ClearNonDefaultToEmpty();
1071 }
1072 _impl_._has_bits_.Clear();
1073 _internal_metadata_.Clear<std::string>();
1074 }
1075
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1076 const char* RegulatorEnableDelayFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1077 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1078 _Internal::HasBits has_bits{};
1079 while (!ctx->Done(&ptr)) {
1080 ::uint32_t tag;
1081 ptr = ::_pbi::ReadTag(ptr, &tag);
1082 switch (tag >> 3) {
1083 // optional string name = 1;
1084 case 1:
1085 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
1086 auto str = _internal_mutable_name();
1087 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1088 CHK_(ptr);
1089 } else {
1090 goto handle_unusual;
1091 }
1092 continue;
1093 default:
1094 goto handle_unusual;
1095 } // switch
1096 handle_unusual:
1097 if ((tag == 0) || ((tag & 7) == 4)) {
1098 CHK_(ptr);
1099 ctx->SetLastTag(tag);
1100 goto message_done;
1101 }
1102 ptr = UnknownFieldParse(
1103 tag,
1104 _internal_metadata_.mutable_unknown_fields<std::string>(),
1105 ptr, ctx);
1106 CHK_(ptr != nullptr);
1107 } // while
1108 message_done:
1109 _impl_._has_bits_.Or(has_bits);
1110 return ptr;
1111 failure:
1112 ptr = nullptr;
1113 goto message_done;
1114 #undef CHK_
1115 }
1116
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1117 ::uint8_t* RegulatorEnableDelayFtraceEvent::_InternalSerialize(
1118 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1119 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.RegulatorEnableDelayFtraceEvent)
1120 ::uint32_t cached_has_bits = 0;
1121 (void) cached_has_bits;
1122
1123 cached_has_bits = _impl_._has_bits_[0];
1124 // optional string name = 1;
1125 if (cached_has_bits & 0x00000001u) {
1126 target = stream->WriteStringMaybeAliased(
1127 1, this->_internal_name(), target);
1128 }
1129
1130 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1131 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1132 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1133 }
1134 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.RegulatorEnableDelayFtraceEvent)
1135 return target;
1136 }
1137
ByteSizeLong() const1138 size_t RegulatorEnableDelayFtraceEvent::ByteSizeLong() const {
1139 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.RegulatorEnableDelayFtraceEvent)
1140 size_t total_size = 0;
1141
1142 ::uint32_t cached_has_bits = 0;
1143 // Prevent compiler warnings about cached_has_bits being unused
1144 (void) cached_has_bits;
1145
1146 // optional string name = 1;
1147 cached_has_bits = _impl_._has_bits_[0];
1148 if (cached_has_bits & 0x00000001u) {
1149 total_size += 1 +
1150 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
1151 this->_internal_name());
1152 }
1153
1154 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1155 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1156 }
1157 int cached_size = ::_pbi::ToCachedSize(total_size);
1158 SetCachedSize(cached_size);
1159 return total_size;
1160 }
1161
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1162 void RegulatorEnableDelayFtraceEvent::CheckTypeAndMergeFrom(
1163 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1164 MergeFrom(*::_pbi::DownCast<const RegulatorEnableDelayFtraceEvent*>(
1165 &from));
1166 }
1167
MergeFrom(const RegulatorEnableDelayFtraceEvent & from)1168 void RegulatorEnableDelayFtraceEvent::MergeFrom(const RegulatorEnableDelayFtraceEvent& from) {
1169 RegulatorEnableDelayFtraceEvent* const _this = this;
1170 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.RegulatorEnableDelayFtraceEvent)
1171 GOOGLE_DCHECK_NE(&from, _this);
1172 ::uint32_t cached_has_bits = 0;
1173 (void) cached_has_bits;
1174
1175 if (from._internal_has_name()) {
1176 _this->_internal_set_name(from._internal_name());
1177 }
1178 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1179 }
1180
CopyFrom(const RegulatorEnableDelayFtraceEvent & from)1181 void RegulatorEnableDelayFtraceEvent::CopyFrom(const RegulatorEnableDelayFtraceEvent& from) {
1182 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.RegulatorEnableDelayFtraceEvent)
1183 if (&from == this) return;
1184 Clear();
1185 MergeFrom(from);
1186 }
1187
IsInitialized() const1188 bool RegulatorEnableDelayFtraceEvent::IsInitialized() const {
1189 return true;
1190 }
1191
InternalSwap(RegulatorEnableDelayFtraceEvent * other)1192 void RegulatorEnableDelayFtraceEvent::InternalSwap(RegulatorEnableDelayFtraceEvent* other) {
1193 using std::swap;
1194 auto* lhs_arena = GetArenaForAllocation();
1195 auto* rhs_arena = other->GetArenaForAllocation();
1196 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1197 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
1198 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1199 &_impl_.name_, lhs_arena,
1200 &other->_impl_.name_, rhs_arena
1201 );
1202 }
1203
GetTypeName() const1204 std::string RegulatorEnableDelayFtraceEvent::GetTypeName() const {
1205 return "perfetto.protos.RegulatorEnableDelayFtraceEvent";
1206 }
1207
1208
1209 // ===================================================================
1210
1211 class RegulatorSetVoltageFtraceEvent::_Internal {
1212 public:
1213 using HasBits = decltype(std::declval<RegulatorSetVoltageFtraceEvent>()._impl_._has_bits_);
set_has_name(HasBits * has_bits)1214 static void set_has_name(HasBits* has_bits) {
1215 (*has_bits)[0] |= 1u;
1216 }
set_has_min(HasBits * has_bits)1217 static void set_has_min(HasBits* has_bits) {
1218 (*has_bits)[0] |= 2u;
1219 }
set_has_max(HasBits * has_bits)1220 static void set_has_max(HasBits* has_bits) {
1221 (*has_bits)[0] |= 4u;
1222 }
1223 };
1224
RegulatorSetVoltageFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1225 RegulatorSetVoltageFtraceEvent::RegulatorSetVoltageFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1226 bool is_message_owned)
1227 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1228 SharedCtor(arena, is_message_owned);
1229 // @@protoc_insertion_point(arena_constructor:perfetto.protos.RegulatorSetVoltageFtraceEvent)
1230 }
RegulatorSetVoltageFtraceEvent(const RegulatorSetVoltageFtraceEvent & from)1231 RegulatorSetVoltageFtraceEvent::RegulatorSetVoltageFtraceEvent(const RegulatorSetVoltageFtraceEvent& from)
1232 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1233 RegulatorSetVoltageFtraceEvent* const _this = this; (void)_this;
1234 new (&_impl_) Impl_{
1235 decltype(_impl_._has_bits_){from._impl_._has_bits_}
1236 , /*decltype(_impl_._cached_size_)*/{}
1237 , decltype(_impl_.name_){}
1238 , decltype(_impl_.min_){}
1239 , decltype(_impl_.max_){}};
1240
1241 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1242 _impl_.name_.InitDefault();
1243 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1244 _impl_.name_.Set("", GetArenaForAllocation());
1245 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1246 if (from._internal_has_name()) {
1247 _this->_impl_.name_.Set(from._internal_name(),
1248 _this->GetArenaForAllocation());
1249 }
1250 ::memcpy(&_impl_.min_, &from._impl_.min_,
1251 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.max_) -
1252 reinterpret_cast<char*>(&_impl_.min_)) + sizeof(_impl_.max_));
1253 // @@protoc_insertion_point(copy_constructor:perfetto.protos.RegulatorSetVoltageFtraceEvent)
1254 }
1255
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1256 inline void RegulatorSetVoltageFtraceEvent::SharedCtor(
1257 ::_pb::Arena* arena, bool is_message_owned) {
1258 (void)arena;
1259 (void)is_message_owned;
1260 new (&_impl_) Impl_{
1261 decltype(_impl_._has_bits_){}
1262 , /*decltype(_impl_._cached_size_)*/{}
1263 , decltype(_impl_.name_){}
1264 , decltype(_impl_.min_){0}
1265 , decltype(_impl_.max_){0}
1266 };
1267 _impl_.name_.InitDefault();
1268 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1269 _impl_.name_.Set("", GetArenaForAllocation());
1270 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1271 }
1272
~RegulatorSetVoltageFtraceEvent()1273 RegulatorSetVoltageFtraceEvent::~RegulatorSetVoltageFtraceEvent() {
1274 // @@protoc_insertion_point(destructor:perfetto.protos.RegulatorSetVoltageFtraceEvent)
1275 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1276 (void)arena;
1277 return;
1278 }
1279 SharedDtor();
1280 }
1281
SharedDtor()1282 inline void RegulatorSetVoltageFtraceEvent::SharedDtor() {
1283 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1284 _impl_.name_.Destroy();
1285 }
1286
SetCachedSize(int size) const1287 void RegulatorSetVoltageFtraceEvent::SetCachedSize(int size) const {
1288 _impl_._cached_size_.Set(size);
1289 }
1290
Clear()1291 void RegulatorSetVoltageFtraceEvent::Clear() {
1292 // @@protoc_insertion_point(message_clear_start:perfetto.protos.RegulatorSetVoltageFtraceEvent)
1293 ::uint32_t cached_has_bits = 0;
1294 // Prevent compiler warnings about cached_has_bits being unused
1295 (void) cached_has_bits;
1296
1297 cached_has_bits = _impl_._has_bits_[0];
1298 if (cached_has_bits & 0x00000001u) {
1299 _impl_.name_.ClearNonDefaultToEmpty();
1300 }
1301 if (cached_has_bits & 0x00000006u) {
1302 ::memset(&_impl_.min_, 0, static_cast<size_t>(
1303 reinterpret_cast<char*>(&_impl_.max_) -
1304 reinterpret_cast<char*>(&_impl_.min_)) + sizeof(_impl_.max_));
1305 }
1306 _impl_._has_bits_.Clear();
1307 _internal_metadata_.Clear<std::string>();
1308 }
1309
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1310 const char* RegulatorSetVoltageFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1311 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1312 _Internal::HasBits has_bits{};
1313 while (!ctx->Done(&ptr)) {
1314 ::uint32_t tag;
1315 ptr = ::_pbi::ReadTag(ptr, &tag);
1316 switch (tag >> 3) {
1317 // optional string name = 1;
1318 case 1:
1319 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
1320 auto str = _internal_mutable_name();
1321 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1322 CHK_(ptr);
1323 } else {
1324 goto handle_unusual;
1325 }
1326 continue;
1327 // optional int32 min = 2;
1328 case 2:
1329 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
1330 _Internal::set_has_min(&has_bits);
1331 _impl_.min_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1332 CHK_(ptr);
1333 } else {
1334 goto handle_unusual;
1335 }
1336 continue;
1337 // optional int32 max = 3;
1338 case 3:
1339 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
1340 _Internal::set_has_max(&has_bits);
1341 _impl_.max_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1342 CHK_(ptr);
1343 } else {
1344 goto handle_unusual;
1345 }
1346 continue;
1347 default:
1348 goto handle_unusual;
1349 } // switch
1350 handle_unusual:
1351 if ((tag == 0) || ((tag & 7) == 4)) {
1352 CHK_(ptr);
1353 ctx->SetLastTag(tag);
1354 goto message_done;
1355 }
1356 ptr = UnknownFieldParse(
1357 tag,
1358 _internal_metadata_.mutable_unknown_fields<std::string>(),
1359 ptr, ctx);
1360 CHK_(ptr != nullptr);
1361 } // while
1362 message_done:
1363 _impl_._has_bits_.Or(has_bits);
1364 return ptr;
1365 failure:
1366 ptr = nullptr;
1367 goto message_done;
1368 #undef CHK_
1369 }
1370
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1371 ::uint8_t* RegulatorSetVoltageFtraceEvent::_InternalSerialize(
1372 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1373 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.RegulatorSetVoltageFtraceEvent)
1374 ::uint32_t cached_has_bits = 0;
1375 (void) cached_has_bits;
1376
1377 cached_has_bits = _impl_._has_bits_[0];
1378 // optional string name = 1;
1379 if (cached_has_bits & 0x00000001u) {
1380 target = stream->WriteStringMaybeAliased(
1381 1, this->_internal_name(), target);
1382 }
1383
1384 // optional int32 min = 2;
1385 if (cached_has_bits & 0x00000002u) {
1386 target = stream->EnsureSpace(target);
1387 target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_min(), target);
1388 }
1389
1390 // optional int32 max = 3;
1391 if (cached_has_bits & 0x00000004u) {
1392 target = stream->EnsureSpace(target);
1393 target = ::_pbi::WireFormatLite::WriteInt32ToArray(3, this->_internal_max(), target);
1394 }
1395
1396 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1397 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1398 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1399 }
1400 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.RegulatorSetVoltageFtraceEvent)
1401 return target;
1402 }
1403
ByteSizeLong() const1404 size_t RegulatorSetVoltageFtraceEvent::ByteSizeLong() const {
1405 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.RegulatorSetVoltageFtraceEvent)
1406 size_t total_size = 0;
1407
1408 ::uint32_t cached_has_bits = 0;
1409 // Prevent compiler warnings about cached_has_bits being unused
1410 (void) cached_has_bits;
1411
1412 cached_has_bits = _impl_._has_bits_[0];
1413 if (cached_has_bits & 0x00000007u) {
1414 // optional string name = 1;
1415 if (cached_has_bits & 0x00000001u) {
1416 total_size += 1 +
1417 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
1418 this->_internal_name());
1419 }
1420
1421 // optional int32 min = 2;
1422 if (cached_has_bits & 0x00000002u) {
1423 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_min());
1424 }
1425
1426 // optional int32 max = 3;
1427 if (cached_has_bits & 0x00000004u) {
1428 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_max());
1429 }
1430
1431 }
1432 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1433 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1434 }
1435 int cached_size = ::_pbi::ToCachedSize(total_size);
1436 SetCachedSize(cached_size);
1437 return total_size;
1438 }
1439
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1440 void RegulatorSetVoltageFtraceEvent::CheckTypeAndMergeFrom(
1441 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1442 MergeFrom(*::_pbi::DownCast<const RegulatorSetVoltageFtraceEvent*>(
1443 &from));
1444 }
1445
MergeFrom(const RegulatorSetVoltageFtraceEvent & from)1446 void RegulatorSetVoltageFtraceEvent::MergeFrom(const RegulatorSetVoltageFtraceEvent& from) {
1447 RegulatorSetVoltageFtraceEvent* const _this = this;
1448 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.RegulatorSetVoltageFtraceEvent)
1449 GOOGLE_DCHECK_NE(&from, _this);
1450 ::uint32_t cached_has_bits = 0;
1451 (void) cached_has_bits;
1452
1453 cached_has_bits = from._impl_._has_bits_[0];
1454 if (cached_has_bits & 0x00000007u) {
1455 if (cached_has_bits & 0x00000001u) {
1456 _this->_internal_set_name(from._internal_name());
1457 }
1458 if (cached_has_bits & 0x00000002u) {
1459 _this->_impl_.min_ = from._impl_.min_;
1460 }
1461 if (cached_has_bits & 0x00000004u) {
1462 _this->_impl_.max_ = from._impl_.max_;
1463 }
1464 _this->_impl_._has_bits_[0] |= cached_has_bits;
1465 }
1466 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1467 }
1468
CopyFrom(const RegulatorSetVoltageFtraceEvent & from)1469 void RegulatorSetVoltageFtraceEvent::CopyFrom(const RegulatorSetVoltageFtraceEvent& from) {
1470 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.RegulatorSetVoltageFtraceEvent)
1471 if (&from == this) return;
1472 Clear();
1473 MergeFrom(from);
1474 }
1475
IsInitialized() const1476 bool RegulatorSetVoltageFtraceEvent::IsInitialized() const {
1477 return true;
1478 }
1479
InternalSwap(RegulatorSetVoltageFtraceEvent * other)1480 void RegulatorSetVoltageFtraceEvent::InternalSwap(RegulatorSetVoltageFtraceEvent* other) {
1481 using std::swap;
1482 auto* lhs_arena = GetArenaForAllocation();
1483 auto* rhs_arena = other->GetArenaForAllocation();
1484 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1485 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
1486 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1487 &_impl_.name_, lhs_arena,
1488 &other->_impl_.name_, rhs_arena
1489 );
1490 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
1491 PROTOBUF_FIELD_OFFSET(RegulatorSetVoltageFtraceEvent, _impl_.max_)
1492 + sizeof(RegulatorSetVoltageFtraceEvent::_impl_.max_) // NOLINT
1493 - PROTOBUF_FIELD_OFFSET(RegulatorSetVoltageFtraceEvent, _impl_.min_)>(
1494 reinterpret_cast<char*>(&_impl_.min_),
1495 reinterpret_cast<char*>(&other->_impl_.min_));
1496 }
1497
GetTypeName() const1498 std::string RegulatorSetVoltageFtraceEvent::GetTypeName() const {
1499 return "perfetto.protos.RegulatorSetVoltageFtraceEvent";
1500 }
1501
1502
1503 // ===================================================================
1504
1505 class RegulatorSetVoltageCompleteFtraceEvent::_Internal {
1506 public:
1507 using HasBits = decltype(std::declval<RegulatorSetVoltageCompleteFtraceEvent>()._impl_._has_bits_);
set_has_name(HasBits * has_bits)1508 static void set_has_name(HasBits* has_bits) {
1509 (*has_bits)[0] |= 1u;
1510 }
set_has_val(HasBits * has_bits)1511 static void set_has_val(HasBits* has_bits) {
1512 (*has_bits)[0] |= 2u;
1513 }
1514 };
1515
RegulatorSetVoltageCompleteFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1516 RegulatorSetVoltageCompleteFtraceEvent::RegulatorSetVoltageCompleteFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1517 bool is_message_owned)
1518 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1519 SharedCtor(arena, is_message_owned);
1520 // @@protoc_insertion_point(arena_constructor:perfetto.protos.RegulatorSetVoltageCompleteFtraceEvent)
1521 }
RegulatorSetVoltageCompleteFtraceEvent(const RegulatorSetVoltageCompleteFtraceEvent & from)1522 RegulatorSetVoltageCompleteFtraceEvent::RegulatorSetVoltageCompleteFtraceEvent(const RegulatorSetVoltageCompleteFtraceEvent& from)
1523 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1524 RegulatorSetVoltageCompleteFtraceEvent* const _this = this; (void)_this;
1525 new (&_impl_) Impl_{
1526 decltype(_impl_._has_bits_){from._impl_._has_bits_}
1527 , /*decltype(_impl_._cached_size_)*/{}
1528 , decltype(_impl_.name_){}
1529 , decltype(_impl_.val_){}};
1530
1531 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1532 _impl_.name_.InitDefault();
1533 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1534 _impl_.name_.Set("", GetArenaForAllocation());
1535 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1536 if (from._internal_has_name()) {
1537 _this->_impl_.name_.Set(from._internal_name(),
1538 _this->GetArenaForAllocation());
1539 }
1540 _this->_impl_.val_ = from._impl_.val_;
1541 // @@protoc_insertion_point(copy_constructor:perfetto.protos.RegulatorSetVoltageCompleteFtraceEvent)
1542 }
1543
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1544 inline void RegulatorSetVoltageCompleteFtraceEvent::SharedCtor(
1545 ::_pb::Arena* arena, bool is_message_owned) {
1546 (void)arena;
1547 (void)is_message_owned;
1548 new (&_impl_) Impl_{
1549 decltype(_impl_._has_bits_){}
1550 , /*decltype(_impl_._cached_size_)*/{}
1551 , decltype(_impl_.name_){}
1552 , decltype(_impl_.val_){0u}
1553 };
1554 _impl_.name_.InitDefault();
1555 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1556 _impl_.name_.Set("", GetArenaForAllocation());
1557 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1558 }
1559
~RegulatorSetVoltageCompleteFtraceEvent()1560 RegulatorSetVoltageCompleteFtraceEvent::~RegulatorSetVoltageCompleteFtraceEvent() {
1561 // @@protoc_insertion_point(destructor:perfetto.protos.RegulatorSetVoltageCompleteFtraceEvent)
1562 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1563 (void)arena;
1564 return;
1565 }
1566 SharedDtor();
1567 }
1568
SharedDtor()1569 inline void RegulatorSetVoltageCompleteFtraceEvent::SharedDtor() {
1570 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1571 _impl_.name_.Destroy();
1572 }
1573
SetCachedSize(int size) const1574 void RegulatorSetVoltageCompleteFtraceEvent::SetCachedSize(int size) const {
1575 _impl_._cached_size_.Set(size);
1576 }
1577
Clear()1578 void RegulatorSetVoltageCompleteFtraceEvent::Clear() {
1579 // @@protoc_insertion_point(message_clear_start:perfetto.protos.RegulatorSetVoltageCompleteFtraceEvent)
1580 ::uint32_t cached_has_bits = 0;
1581 // Prevent compiler warnings about cached_has_bits being unused
1582 (void) cached_has_bits;
1583
1584 cached_has_bits = _impl_._has_bits_[0];
1585 if (cached_has_bits & 0x00000001u) {
1586 _impl_.name_.ClearNonDefaultToEmpty();
1587 }
1588 _impl_.val_ = 0u;
1589 _impl_._has_bits_.Clear();
1590 _internal_metadata_.Clear<std::string>();
1591 }
1592
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1593 const char* RegulatorSetVoltageCompleteFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1594 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1595 _Internal::HasBits has_bits{};
1596 while (!ctx->Done(&ptr)) {
1597 ::uint32_t tag;
1598 ptr = ::_pbi::ReadTag(ptr, &tag);
1599 switch (tag >> 3) {
1600 // optional string name = 1;
1601 case 1:
1602 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
1603 auto str = _internal_mutable_name();
1604 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1605 CHK_(ptr);
1606 } else {
1607 goto handle_unusual;
1608 }
1609 continue;
1610 // optional uint32 val = 2;
1611 case 2:
1612 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
1613 _Internal::set_has_val(&has_bits);
1614 _impl_.val_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1615 CHK_(ptr);
1616 } else {
1617 goto handle_unusual;
1618 }
1619 continue;
1620 default:
1621 goto handle_unusual;
1622 } // switch
1623 handle_unusual:
1624 if ((tag == 0) || ((tag & 7) == 4)) {
1625 CHK_(ptr);
1626 ctx->SetLastTag(tag);
1627 goto message_done;
1628 }
1629 ptr = UnknownFieldParse(
1630 tag,
1631 _internal_metadata_.mutable_unknown_fields<std::string>(),
1632 ptr, ctx);
1633 CHK_(ptr != nullptr);
1634 } // while
1635 message_done:
1636 _impl_._has_bits_.Or(has_bits);
1637 return ptr;
1638 failure:
1639 ptr = nullptr;
1640 goto message_done;
1641 #undef CHK_
1642 }
1643
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1644 ::uint8_t* RegulatorSetVoltageCompleteFtraceEvent::_InternalSerialize(
1645 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1646 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.RegulatorSetVoltageCompleteFtraceEvent)
1647 ::uint32_t cached_has_bits = 0;
1648 (void) cached_has_bits;
1649
1650 cached_has_bits = _impl_._has_bits_[0];
1651 // optional string name = 1;
1652 if (cached_has_bits & 0x00000001u) {
1653 target = stream->WriteStringMaybeAliased(
1654 1, this->_internal_name(), target);
1655 }
1656
1657 // optional uint32 val = 2;
1658 if (cached_has_bits & 0x00000002u) {
1659 target = stream->EnsureSpace(target);
1660 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_val(), target);
1661 }
1662
1663 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1664 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1665 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1666 }
1667 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.RegulatorSetVoltageCompleteFtraceEvent)
1668 return target;
1669 }
1670
ByteSizeLong() const1671 size_t RegulatorSetVoltageCompleteFtraceEvent::ByteSizeLong() const {
1672 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.RegulatorSetVoltageCompleteFtraceEvent)
1673 size_t total_size = 0;
1674
1675 ::uint32_t cached_has_bits = 0;
1676 // Prevent compiler warnings about cached_has_bits being unused
1677 (void) cached_has_bits;
1678
1679 cached_has_bits = _impl_._has_bits_[0];
1680 if (cached_has_bits & 0x00000003u) {
1681 // optional string name = 1;
1682 if (cached_has_bits & 0x00000001u) {
1683 total_size += 1 +
1684 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
1685 this->_internal_name());
1686 }
1687
1688 // optional uint32 val = 2;
1689 if (cached_has_bits & 0x00000002u) {
1690 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_val());
1691 }
1692
1693 }
1694 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1695 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1696 }
1697 int cached_size = ::_pbi::ToCachedSize(total_size);
1698 SetCachedSize(cached_size);
1699 return total_size;
1700 }
1701
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1702 void RegulatorSetVoltageCompleteFtraceEvent::CheckTypeAndMergeFrom(
1703 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1704 MergeFrom(*::_pbi::DownCast<const RegulatorSetVoltageCompleteFtraceEvent*>(
1705 &from));
1706 }
1707
MergeFrom(const RegulatorSetVoltageCompleteFtraceEvent & from)1708 void RegulatorSetVoltageCompleteFtraceEvent::MergeFrom(const RegulatorSetVoltageCompleteFtraceEvent& from) {
1709 RegulatorSetVoltageCompleteFtraceEvent* const _this = this;
1710 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.RegulatorSetVoltageCompleteFtraceEvent)
1711 GOOGLE_DCHECK_NE(&from, _this);
1712 ::uint32_t cached_has_bits = 0;
1713 (void) cached_has_bits;
1714
1715 cached_has_bits = from._impl_._has_bits_[0];
1716 if (cached_has_bits & 0x00000003u) {
1717 if (cached_has_bits & 0x00000001u) {
1718 _this->_internal_set_name(from._internal_name());
1719 }
1720 if (cached_has_bits & 0x00000002u) {
1721 _this->_impl_.val_ = from._impl_.val_;
1722 }
1723 _this->_impl_._has_bits_[0] |= cached_has_bits;
1724 }
1725 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1726 }
1727
CopyFrom(const RegulatorSetVoltageCompleteFtraceEvent & from)1728 void RegulatorSetVoltageCompleteFtraceEvent::CopyFrom(const RegulatorSetVoltageCompleteFtraceEvent& from) {
1729 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.RegulatorSetVoltageCompleteFtraceEvent)
1730 if (&from == this) return;
1731 Clear();
1732 MergeFrom(from);
1733 }
1734
IsInitialized() const1735 bool RegulatorSetVoltageCompleteFtraceEvent::IsInitialized() const {
1736 return true;
1737 }
1738
InternalSwap(RegulatorSetVoltageCompleteFtraceEvent * other)1739 void RegulatorSetVoltageCompleteFtraceEvent::InternalSwap(RegulatorSetVoltageCompleteFtraceEvent* other) {
1740 using std::swap;
1741 auto* lhs_arena = GetArenaForAllocation();
1742 auto* rhs_arena = other->GetArenaForAllocation();
1743 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1744 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
1745 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1746 &_impl_.name_, lhs_arena,
1747 &other->_impl_.name_, rhs_arena
1748 );
1749 swap(_impl_.val_, other->_impl_.val_);
1750 }
1751
GetTypeName() const1752 std::string RegulatorSetVoltageCompleteFtraceEvent::GetTypeName() const {
1753 return "perfetto.protos.RegulatorSetVoltageCompleteFtraceEvent";
1754 }
1755
1756
1757 // @@protoc_insertion_point(namespace_scope)
1758 } // namespace protos
1759 } // namespace perfetto
1760 PROTOBUF_NAMESPACE_OPEN
1761 template<> PROTOBUF_NOINLINE ::perfetto::protos::RegulatorDisableFtraceEvent*
CreateMaybeMessage(Arena * arena)1762 Arena::CreateMaybeMessage< ::perfetto::protos::RegulatorDisableFtraceEvent >(Arena* arena) {
1763 return Arena::CreateMessageInternal< ::perfetto::protos::RegulatorDisableFtraceEvent >(arena);
1764 }
1765 template<> PROTOBUF_NOINLINE ::perfetto::protos::RegulatorDisableCompleteFtraceEvent*
CreateMaybeMessage(Arena * arena)1766 Arena::CreateMaybeMessage< ::perfetto::protos::RegulatorDisableCompleteFtraceEvent >(Arena* arena) {
1767 return Arena::CreateMessageInternal< ::perfetto::protos::RegulatorDisableCompleteFtraceEvent >(arena);
1768 }
1769 template<> PROTOBUF_NOINLINE ::perfetto::protos::RegulatorEnableFtraceEvent*
CreateMaybeMessage(Arena * arena)1770 Arena::CreateMaybeMessage< ::perfetto::protos::RegulatorEnableFtraceEvent >(Arena* arena) {
1771 return Arena::CreateMessageInternal< ::perfetto::protos::RegulatorEnableFtraceEvent >(arena);
1772 }
1773 template<> PROTOBUF_NOINLINE ::perfetto::protos::RegulatorEnableCompleteFtraceEvent*
CreateMaybeMessage(Arena * arena)1774 Arena::CreateMaybeMessage< ::perfetto::protos::RegulatorEnableCompleteFtraceEvent >(Arena* arena) {
1775 return Arena::CreateMessageInternal< ::perfetto::protos::RegulatorEnableCompleteFtraceEvent >(arena);
1776 }
1777 template<> PROTOBUF_NOINLINE ::perfetto::protos::RegulatorEnableDelayFtraceEvent*
CreateMaybeMessage(Arena * arena)1778 Arena::CreateMaybeMessage< ::perfetto::protos::RegulatorEnableDelayFtraceEvent >(Arena* arena) {
1779 return Arena::CreateMessageInternal< ::perfetto::protos::RegulatorEnableDelayFtraceEvent >(arena);
1780 }
1781 template<> PROTOBUF_NOINLINE ::perfetto::protos::RegulatorSetVoltageFtraceEvent*
CreateMaybeMessage(Arena * arena)1782 Arena::CreateMaybeMessage< ::perfetto::protos::RegulatorSetVoltageFtraceEvent >(Arena* arena) {
1783 return Arena::CreateMessageInternal< ::perfetto::protos::RegulatorSetVoltageFtraceEvent >(arena);
1784 }
1785 template<> PROTOBUF_NOINLINE ::perfetto::protos::RegulatorSetVoltageCompleteFtraceEvent*
CreateMaybeMessage(Arena * arena)1786 Arena::CreateMaybeMessage< ::perfetto::protos::RegulatorSetVoltageCompleteFtraceEvent >(Arena* arena) {
1787 return Arena::CreateMessageInternal< ::perfetto::protos::RegulatorSetVoltageCompleteFtraceEvent >(arena);
1788 }
1789 PROTOBUF_NAMESPACE_CLOSE
1790
1791 // @@protoc_insertion_point(global_scope)
1792 #include <google/protobuf/port_undef.inc>
1793