1 // Generated by the protocol buffer compiler. DO NOT EDIT!
2 // source: protos/perfetto/trace/ftrace/trusty.proto
3
4 #include "protos/perfetto/trace/ftrace/trusty.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 {
TrustySmcFtraceEvent(::_pbi::ConstantInitialized)23 PROTOBUF_CONSTEXPR TrustySmcFtraceEvent::TrustySmcFtraceEvent(
24 ::_pbi::ConstantInitialized): _impl_{
25 /*decltype(_impl_._has_bits_)*/{}
26 , /*decltype(_impl_._cached_size_)*/{}
27 , /*decltype(_impl_.r0_)*/::uint64_t{0u}
28 , /*decltype(_impl_.r1_)*/::uint64_t{0u}
29 , /*decltype(_impl_.r2_)*/::uint64_t{0u}
30 , /*decltype(_impl_.r3_)*/::uint64_t{0u}} {}
31 struct TrustySmcFtraceEventDefaultTypeInternal {
TrustySmcFtraceEventDefaultTypeInternalperfetto::protos::TrustySmcFtraceEventDefaultTypeInternal32 PROTOBUF_CONSTEXPR TrustySmcFtraceEventDefaultTypeInternal()
33 : _instance(::_pbi::ConstantInitialized{}) {}
~TrustySmcFtraceEventDefaultTypeInternalperfetto::protos::TrustySmcFtraceEventDefaultTypeInternal34 ~TrustySmcFtraceEventDefaultTypeInternal() {}
35 union { // NOLINT(misc-non-private-member-variables-in-classes)
36 TrustySmcFtraceEvent _instance;
37 };
38 };
39 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TrustySmcFtraceEventDefaultTypeInternal _TrustySmcFtraceEvent_default_instance_;
TrustySmcDoneFtraceEvent(::_pbi::ConstantInitialized)40 PROTOBUF_CONSTEXPR TrustySmcDoneFtraceEvent::TrustySmcDoneFtraceEvent(
41 ::_pbi::ConstantInitialized): _impl_{
42 /*decltype(_impl_._has_bits_)*/{}
43 , /*decltype(_impl_._cached_size_)*/{}
44 , /*decltype(_impl_.ret_)*/::uint64_t{0u}} {}
45 struct TrustySmcDoneFtraceEventDefaultTypeInternal {
TrustySmcDoneFtraceEventDefaultTypeInternalperfetto::protos::TrustySmcDoneFtraceEventDefaultTypeInternal46 PROTOBUF_CONSTEXPR TrustySmcDoneFtraceEventDefaultTypeInternal()
47 : _instance(::_pbi::ConstantInitialized{}) {}
~TrustySmcDoneFtraceEventDefaultTypeInternalperfetto::protos::TrustySmcDoneFtraceEventDefaultTypeInternal48 ~TrustySmcDoneFtraceEventDefaultTypeInternal() {}
49 union { // NOLINT(misc-non-private-member-variables-in-classes)
50 TrustySmcDoneFtraceEvent _instance;
51 };
52 };
53 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TrustySmcDoneFtraceEventDefaultTypeInternal _TrustySmcDoneFtraceEvent_default_instance_;
TrustyStdCall32FtraceEvent(::_pbi::ConstantInitialized)54 PROTOBUF_CONSTEXPR TrustyStdCall32FtraceEvent::TrustyStdCall32FtraceEvent(
55 ::_pbi::ConstantInitialized): _impl_{
56 /*decltype(_impl_._has_bits_)*/{}
57 , /*decltype(_impl_._cached_size_)*/{}
58 , /*decltype(_impl_.r0_)*/::uint64_t{0u}
59 , /*decltype(_impl_.r1_)*/::uint64_t{0u}
60 , /*decltype(_impl_.r2_)*/::uint64_t{0u}
61 , /*decltype(_impl_.r3_)*/::uint64_t{0u}} {}
62 struct TrustyStdCall32FtraceEventDefaultTypeInternal {
TrustyStdCall32FtraceEventDefaultTypeInternalperfetto::protos::TrustyStdCall32FtraceEventDefaultTypeInternal63 PROTOBUF_CONSTEXPR TrustyStdCall32FtraceEventDefaultTypeInternal()
64 : _instance(::_pbi::ConstantInitialized{}) {}
~TrustyStdCall32FtraceEventDefaultTypeInternalperfetto::protos::TrustyStdCall32FtraceEventDefaultTypeInternal65 ~TrustyStdCall32FtraceEventDefaultTypeInternal() {}
66 union { // NOLINT(misc-non-private-member-variables-in-classes)
67 TrustyStdCall32FtraceEvent _instance;
68 };
69 };
70 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TrustyStdCall32FtraceEventDefaultTypeInternal _TrustyStdCall32FtraceEvent_default_instance_;
TrustyStdCall32DoneFtraceEvent(::_pbi::ConstantInitialized)71 PROTOBUF_CONSTEXPR TrustyStdCall32DoneFtraceEvent::TrustyStdCall32DoneFtraceEvent(
72 ::_pbi::ConstantInitialized): _impl_{
73 /*decltype(_impl_._has_bits_)*/{}
74 , /*decltype(_impl_._cached_size_)*/{}
75 , /*decltype(_impl_.ret_)*/::int64_t{0}} {}
76 struct TrustyStdCall32DoneFtraceEventDefaultTypeInternal {
TrustyStdCall32DoneFtraceEventDefaultTypeInternalperfetto::protos::TrustyStdCall32DoneFtraceEventDefaultTypeInternal77 PROTOBUF_CONSTEXPR TrustyStdCall32DoneFtraceEventDefaultTypeInternal()
78 : _instance(::_pbi::ConstantInitialized{}) {}
~TrustyStdCall32DoneFtraceEventDefaultTypeInternalperfetto::protos::TrustyStdCall32DoneFtraceEventDefaultTypeInternal79 ~TrustyStdCall32DoneFtraceEventDefaultTypeInternal() {}
80 union { // NOLINT(misc-non-private-member-variables-in-classes)
81 TrustyStdCall32DoneFtraceEvent _instance;
82 };
83 };
84 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TrustyStdCall32DoneFtraceEventDefaultTypeInternal _TrustyStdCall32DoneFtraceEvent_default_instance_;
TrustyShareMemoryFtraceEvent(::_pbi::ConstantInitialized)85 PROTOBUF_CONSTEXPR TrustyShareMemoryFtraceEvent::TrustyShareMemoryFtraceEvent(
86 ::_pbi::ConstantInitialized): _impl_{
87 /*decltype(_impl_._has_bits_)*/{}
88 , /*decltype(_impl_._cached_size_)*/{}
89 , /*decltype(_impl_.len_)*/::uint64_t{0u}
90 , /*decltype(_impl_.lend_)*/0u
91 , /*decltype(_impl_.nents_)*/0u} {}
92 struct TrustyShareMemoryFtraceEventDefaultTypeInternal {
TrustyShareMemoryFtraceEventDefaultTypeInternalperfetto::protos::TrustyShareMemoryFtraceEventDefaultTypeInternal93 PROTOBUF_CONSTEXPR TrustyShareMemoryFtraceEventDefaultTypeInternal()
94 : _instance(::_pbi::ConstantInitialized{}) {}
~TrustyShareMemoryFtraceEventDefaultTypeInternalperfetto::protos::TrustyShareMemoryFtraceEventDefaultTypeInternal95 ~TrustyShareMemoryFtraceEventDefaultTypeInternal() {}
96 union { // NOLINT(misc-non-private-member-variables-in-classes)
97 TrustyShareMemoryFtraceEvent _instance;
98 };
99 };
100 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TrustyShareMemoryFtraceEventDefaultTypeInternal _TrustyShareMemoryFtraceEvent_default_instance_;
TrustyShareMemoryDoneFtraceEvent(::_pbi::ConstantInitialized)101 PROTOBUF_CONSTEXPR TrustyShareMemoryDoneFtraceEvent::TrustyShareMemoryDoneFtraceEvent(
102 ::_pbi::ConstantInitialized): _impl_{
103 /*decltype(_impl_._has_bits_)*/{}
104 , /*decltype(_impl_._cached_size_)*/{}
105 , /*decltype(_impl_.handle_)*/::uint64_t{0u}
106 , /*decltype(_impl_.len_)*/::uint64_t{0u}
107 , /*decltype(_impl_.lend_)*/0u
108 , /*decltype(_impl_.nents_)*/0u
109 , /*decltype(_impl_.ret_)*/0} {}
110 struct TrustyShareMemoryDoneFtraceEventDefaultTypeInternal {
TrustyShareMemoryDoneFtraceEventDefaultTypeInternalperfetto::protos::TrustyShareMemoryDoneFtraceEventDefaultTypeInternal111 PROTOBUF_CONSTEXPR TrustyShareMemoryDoneFtraceEventDefaultTypeInternal()
112 : _instance(::_pbi::ConstantInitialized{}) {}
~TrustyShareMemoryDoneFtraceEventDefaultTypeInternalperfetto::protos::TrustyShareMemoryDoneFtraceEventDefaultTypeInternal113 ~TrustyShareMemoryDoneFtraceEventDefaultTypeInternal() {}
114 union { // NOLINT(misc-non-private-member-variables-in-classes)
115 TrustyShareMemoryDoneFtraceEvent _instance;
116 };
117 };
118 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TrustyShareMemoryDoneFtraceEventDefaultTypeInternal _TrustyShareMemoryDoneFtraceEvent_default_instance_;
TrustyReclaimMemoryFtraceEvent(::_pbi::ConstantInitialized)119 PROTOBUF_CONSTEXPR TrustyReclaimMemoryFtraceEvent::TrustyReclaimMemoryFtraceEvent(
120 ::_pbi::ConstantInitialized): _impl_{
121 /*decltype(_impl_._has_bits_)*/{}
122 , /*decltype(_impl_._cached_size_)*/{}
123 , /*decltype(_impl_.id_)*/::uint64_t{0u}} {}
124 struct TrustyReclaimMemoryFtraceEventDefaultTypeInternal {
TrustyReclaimMemoryFtraceEventDefaultTypeInternalperfetto::protos::TrustyReclaimMemoryFtraceEventDefaultTypeInternal125 PROTOBUF_CONSTEXPR TrustyReclaimMemoryFtraceEventDefaultTypeInternal()
126 : _instance(::_pbi::ConstantInitialized{}) {}
~TrustyReclaimMemoryFtraceEventDefaultTypeInternalperfetto::protos::TrustyReclaimMemoryFtraceEventDefaultTypeInternal127 ~TrustyReclaimMemoryFtraceEventDefaultTypeInternal() {}
128 union { // NOLINT(misc-non-private-member-variables-in-classes)
129 TrustyReclaimMemoryFtraceEvent _instance;
130 };
131 };
132 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TrustyReclaimMemoryFtraceEventDefaultTypeInternal _TrustyReclaimMemoryFtraceEvent_default_instance_;
TrustyReclaimMemoryDoneFtraceEvent(::_pbi::ConstantInitialized)133 PROTOBUF_CONSTEXPR TrustyReclaimMemoryDoneFtraceEvent::TrustyReclaimMemoryDoneFtraceEvent(
134 ::_pbi::ConstantInitialized): _impl_{
135 /*decltype(_impl_._has_bits_)*/{}
136 , /*decltype(_impl_._cached_size_)*/{}
137 , /*decltype(_impl_.id_)*/::uint64_t{0u}
138 , /*decltype(_impl_.ret_)*/0} {}
139 struct TrustyReclaimMemoryDoneFtraceEventDefaultTypeInternal {
TrustyReclaimMemoryDoneFtraceEventDefaultTypeInternalperfetto::protos::TrustyReclaimMemoryDoneFtraceEventDefaultTypeInternal140 PROTOBUF_CONSTEXPR TrustyReclaimMemoryDoneFtraceEventDefaultTypeInternal()
141 : _instance(::_pbi::ConstantInitialized{}) {}
~TrustyReclaimMemoryDoneFtraceEventDefaultTypeInternalperfetto::protos::TrustyReclaimMemoryDoneFtraceEventDefaultTypeInternal142 ~TrustyReclaimMemoryDoneFtraceEventDefaultTypeInternal() {}
143 union { // NOLINT(misc-non-private-member-variables-in-classes)
144 TrustyReclaimMemoryDoneFtraceEvent _instance;
145 };
146 };
147 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TrustyReclaimMemoryDoneFtraceEventDefaultTypeInternal _TrustyReclaimMemoryDoneFtraceEvent_default_instance_;
TrustyIrqFtraceEvent(::_pbi::ConstantInitialized)148 PROTOBUF_CONSTEXPR TrustyIrqFtraceEvent::TrustyIrqFtraceEvent(
149 ::_pbi::ConstantInitialized): _impl_{
150 /*decltype(_impl_._has_bits_)*/{}
151 , /*decltype(_impl_._cached_size_)*/{}
152 , /*decltype(_impl_.irq_)*/0} {}
153 struct TrustyIrqFtraceEventDefaultTypeInternal {
TrustyIrqFtraceEventDefaultTypeInternalperfetto::protos::TrustyIrqFtraceEventDefaultTypeInternal154 PROTOBUF_CONSTEXPR TrustyIrqFtraceEventDefaultTypeInternal()
155 : _instance(::_pbi::ConstantInitialized{}) {}
~TrustyIrqFtraceEventDefaultTypeInternalperfetto::protos::TrustyIrqFtraceEventDefaultTypeInternal156 ~TrustyIrqFtraceEventDefaultTypeInternal() {}
157 union { // NOLINT(misc-non-private-member-variables-in-classes)
158 TrustyIrqFtraceEvent _instance;
159 };
160 };
161 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TrustyIrqFtraceEventDefaultTypeInternal _TrustyIrqFtraceEvent_default_instance_;
TrustyIpcHandleEventFtraceEvent(::_pbi::ConstantInitialized)162 PROTOBUF_CONSTEXPR TrustyIpcHandleEventFtraceEvent::TrustyIpcHandleEventFtraceEvent(
163 ::_pbi::ConstantInitialized): _impl_{
164 /*decltype(_impl_._has_bits_)*/{}
165 , /*decltype(_impl_._cached_size_)*/{}
166 , /*decltype(_impl_.srv_name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
167 , /*decltype(_impl_.chan_)*/0u
168 , /*decltype(_impl_.event_id_)*/0u} {}
169 struct TrustyIpcHandleEventFtraceEventDefaultTypeInternal {
TrustyIpcHandleEventFtraceEventDefaultTypeInternalperfetto::protos::TrustyIpcHandleEventFtraceEventDefaultTypeInternal170 PROTOBUF_CONSTEXPR TrustyIpcHandleEventFtraceEventDefaultTypeInternal()
171 : _instance(::_pbi::ConstantInitialized{}) {}
~TrustyIpcHandleEventFtraceEventDefaultTypeInternalperfetto::protos::TrustyIpcHandleEventFtraceEventDefaultTypeInternal172 ~TrustyIpcHandleEventFtraceEventDefaultTypeInternal() {}
173 union { // NOLINT(misc-non-private-member-variables-in-classes)
174 TrustyIpcHandleEventFtraceEvent _instance;
175 };
176 };
177 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TrustyIpcHandleEventFtraceEventDefaultTypeInternal _TrustyIpcHandleEventFtraceEvent_default_instance_;
TrustyIpcConnectFtraceEvent(::_pbi::ConstantInitialized)178 PROTOBUF_CONSTEXPR TrustyIpcConnectFtraceEvent::TrustyIpcConnectFtraceEvent(
179 ::_pbi::ConstantInitialized): _impl_{
180 /*decltype(_impl_._has_bits_)*/{}
181 , /*decltype(_impl_._cached_size_)*/{}
182 , /*decltype(_impl_.port_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
183 , /*decltype(_impl_.chan_)*/0u
184 , /*decltype(_impl_.state_)*/0} {}
185 struct TrustyIpcConnectFtraceEventDefaultTypeInternal {
TrustyIpcConnectFtraceEventDefaultTypeInternalperfetto::protos::TrustyIpcConnectFtraceEventDefaultTypeInternal186 PROTOBUF_CONSTEXPR TrustyIpcConnectFtraceEventDefaultTypeInternal()
187 : _instance(::_pbi::ConstantInitialized{}) {}
~TrustyIpcConnectFtraceEventDefaultTypeInternalperfetto::protos::TrustyIpcConnectFtraceEventDefaultTypeInternal188 ~TrustyIpcConnectFtraceEventDefaultTypeInternal() {}
189 union { // NOLINT(misc-non-private-member-variables-in-classes)
190 TrustyIpcConnectFtraceEvent _instance;
191 };
192 };
193 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TrustyIpcConnectFtraceEventDefaultTypeInternal _TrustyIpcConnectFtraceEvent_default_instance_;
TrustyIpcConnectEndFtraceEvent(::_pbi::ConstantInitialized)194 PROTOBUF_CONSTEXPR TrustyIpcConnectEndFtraceEvent::TrustyIpcConnectEndFtraceEvent(
195 ::_pbi::ConstantInitialized): _impl_{
196 /*decltype(_impl_._has_bits_)*/{}
197 , /*decltype(_impl_._cached_size_)*/{}
198 , /*decltype(_impl_.chan_)*/0u
199 , /*decltype(_impl_.err_)*/0
200 , /*decltype(_impl_.state_)*/0} {}
201 struct TrustyIpcConnectEndFtraceEventDefaultTypeInternal {
TrustyIpcConnectEndFtraceEventDefaultTypeInternalperfetto::protos::TrustyIpcConnectEndFtraceEventDefaultTypeInternal202 PROTOBUF_CONSTEXPR TrustyIpcConnectEndFtraceEventDefaultTypeInternal()
203 : _instance(::_pbi::ConstantInitialized{}) {}
~TrustyIpcConnectEndFtraceEventDefaultTypeInternalperfetto::protos::TrustyIpcConnectEndFtraceEventDefaultTypeInternal204 ~TrustyIpcConnectEndFtraceEventDefaultTypeInternal() {}
205 union { // NOLINT(misc-non-private-member-variables-in-classes)
206 TrustyIpcConnectEndFtraceEvent _instance;
207 };
208 };
209 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TrustyIpcConnectEndFtraceEventDefaultTypeInternal _TrustyIpcConnectEndFtraceEvent_default_instance_;
TrustyIpcWriteFtraceEvent(::_pbi::ConstantInitialized)210 PROTOBUF_CONSTEXPR TrustyIpcWriteFtraceEvent::TrustyIpcWriteFtraceEvent(
211 ::_pbi::ConstantInitialized): _impl_{
212 /*decltype(_impl_._has_bits_)*/{}
213 , /*decltype(_impl_._cached_size_)*/{}
214 , /*decltype(_impl_.srv_name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
215 , /*decltype(_impl_.buf_id_)*/::uint64_t{0u}
216 , /*decltype(_impl_.chan_)*/0u
217 , /*decltype(_impl_.kind_shm_)*/0
218 , /*decltype(_impl_.shm_cnt_)*/::uint64_t{0u}
219 , /*decltype(_impl_.len_or_err_)*/0} {}
220 struct TrustyIpcWriteFtraceEventDefaultTypeInternal {
TrustyIpcWriteFtraceEventDefaultTypeInternalperfetto::protos::TrustyIpcWriteFtraceEventDefaultTypeInternal221 PROTOBUF_CONSTEXPR TrustyIpcWriteFtraceEventDefaultTypeInternal()
222 : _instance(::_pbi::ConstantInitialized{}) {}
~TrustyIpcWriteFtraceEventDefaultTypeInternalperfetto::protos::TrustyIpcWriteFtraceEventDefaultTypeInternal223 ~TrustyIpcWriteFtraceEventDefaultTypeInternal() {}
224 union { // NOLINT(misc-non-private-member-variables-in-classes)
225 TrustyIpcWriteFtraceEvent _instance;
226 };
227 };
228 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TrustyIpcWriteFtraceEventDefaultTypeInternal _TrustyIpcWriteFtraceEvent_default_instance_;
TrustyIpcPollFtraceEvent(::_pbi::ConstantInitialized)229 PROTOBUF_CONSTEXPR TrustyIpcPollFtraceEvent::TrustyIpcPollFtraceEvent(
230 ::_pbi::ConstantInitialized): _impl_{
231 /*decltype(_impl_._has_bits_)*/{}
232 , /*decltype(_impl_._cached_size_)*/{}
233 , /*decltype(_impl_.srv_name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
234 , /*decltype(_impl_.chan_)*/0u
235 , /*decltype(_impl_.poll_mask_)*/0u} {}
236 struct TrustyIpcPollFtraceEventDefaultTypeInternal {
TrustyIpcPollFtraceEventDefaultTypeInternalperfetto::protos::TrustyIpcPollFtraceEventDefaultTypeInternal237 PROTOBUF_CONSTEXPR TrustyIpcPollFtraceEventDefaultTypeInternal()
238 : _instance(::_pbi::ConstantInitialized{}) {}
~TrustyIpcPollFtraceEventDefaultTypeInternalperfetto::protos::TrustyIpcPollFtraceEventDefaultTypeInternal239 ~TrustyIpcPollFtraceEventDefaultTypeInternal() {}
240 union { // NOLINT(misc-non-private-member-variables-in-classes)
241 TrustyIpcPollFtraceEvent _instance;
242 };
243 };
244 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TrustyIpcPollFtraceEventDefaultTypeInternal _TrustyIpcPollFtraceEvent_default_instance_;
TrustyIpcReadFtraceEvent(::_pbi::ConstantInitialized)245 PROTOBUF_CONSTEXPR TrustyIpcReadFtraceEvent::TrustyIpcReadFtraceEvent(
246 ::_pbi::ConstantInitialized): _impl_{
247 /*decltype(_impl_._has_bits_)*/{}
248 , /*decltype(_impl_._cached_size_)*/{}
249 , /*decltype(_impl_.srv_name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
250 , /*decltype(_impl_.chan_)*/0u} {}
251 struct TrustyIpcReadFtraceEventDefaultTypeInternal {
TrustyIpcReadFtraceEventDefaultTypeInternalperfetto::protos::TrustyIpcReadFtraceEventDefaultTypeInternal252 PROTOBUF_CONSTEXPR TrustyIpcReadFtraceEventDefaultTypeInternal()
253 : _instance(::_pbi::ConstantInitialized{}) {}
~TrustyIpcReadFtraceEventDefaultTypeInternalperfetto::protos::TrustyIpcReadFtraceEventDefaultTypeInternal254 ~TrustyIpcReadFtraceEventDefaultTypeInternal() {}
255 union { // NOLINT(misc-non-private-member-variables-in-classes)
256 TrustyIpcReadFtraceEvent _instance;
257 };
258 };
259 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TrustyIpcReadFtraceEventDefaultTypeInternal _TrustyIpcReadFtraceEvent_default_instance_;
TrustyIpcReadEndFtraceEvent(::_pbi::ConstantInitialized)260 PROTOBUF_CONSTEXPR TrustyIpcReadEndFtraceEvent::TrustyIpcReadEndFtraceEvent(
261 ::_pbi::ConstantInitialized): _impl_{
262 /*decltype(_impl_._has_bits_)*/{}
263 , /*decltype(_impl_._cached_size_)*/{}
264 , /*decltype(_impl_.srv_name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
265 , /*decltype(_impl_.buf_id_)*/::uint64_t{0u}
266 , /*decltype(_impl_.chan_)*/0u
267 , /*decltype(_impl_.len_or_err_)*/0
268 , /*decltype(_impl_.shm_cnt_)*/::uint64_t{0u}} {}
269 struct TrustyIpcReadEndFtraceEventDefaultTypeInternal {
TrustyIpcReadEndFtraceEventDefaultTypeInternalperfetto::protos::TrustyIpcReadEndFtraceEventDefaultTypeInternal270 PROTOBUF_CONSTEXPR TrustyIpcReadEndFtraceEventDefaultTypeInternal()
271 : _instance(::_pbi::ConstantInitialized{}) {}
~TrustyIpcReadEndFtraceEventDefaultTypeInternalperfetto::protos::TrustyIpcReadEndFtraceEventDefaultTypeInternal272 ~TrustyIpcReadEndFtraceEventDefaultTypeInternal() {}
273 union { // NOLINT(misc-non-private-member-variables-in-classes)
274 TrustyIpcReadEndFtraceEvent _instance;
275 };
276 };
277 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TrustyIpcReadEndFtraceEventDefaultTypeInternal _TrustyIpcReadEndFtraceEvent_default_instance_;
TrustyIpcRxFtraceEvent(::_pbi::ConstantInitialized)278 PROTOBUF_CONSTEXPR TrustyIpcRxFtraceEvent::TrustyIpcRxFtraceEvent(
279 ::_pbi::ConstantInitialized): _impl_{
280 /*decltype(_impl_._has_bits_)*/{}
281 , /*decltype(_impl_._cached_size_)*/{}
282 , /*decltype(_impl_.srv_name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
283 , /*decltype(_impl_.buf_id_)*/::uint64_t{0u}
284 , /*decltype(_impl_.chan_)*/0u} {}
285 struct TrustyIpcRxFtraceEventDefaultTypeInternal {
TrustyIpcRxFtraceEventDefaultTypeInternalperfetto::protos::TrustyIpcRxFtraceEventDefaultTypeInternal286 PROTOBUF_CONSTEXPR TrustyIpcRxFtraceEventDefaultTypeInternal()
287 : _instance(::_pbi::ConstantInitialized{}) {}
~TrustyIpcRxFtraceEventDefaultTypeInternalperfetto::protos::TrustyIpcRxFtraceEventDefaultTypeInternal288 ~TrustyIpcRxFtraceEventDefaultTypeInternal() {}
289 union { // NOLINT(misc-non-private-member-variables-in-classes)
290 TrustyIpcRxFtraceEvent _instance;
291 };
292 };
293 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TrustyIpcRxFtraceEventDefaultTypeInternal _TrustyIpcRxFtraceEvent_default_instance_;
TrustyEnqueueNopFtraceEvent(::_pbi::ConstantInitialized)294 PROTOBUF_CONSTEXPR TrustyEnqueueNopFtraceEvent::TrustyEnqueueNopFtraceEvent(
295 ::_pbi::ConstantInitialized): _impl_{
296 /*decltype(_impl_._has_bits_)*/{}
297 , /*decltype(_impl_._cached_size_)*/{}
298 , /*decltype(_impl_.arg1_)*/0u
299 , /*decltype(_impl_.arg2_)*/0u
300 , /*decltype(_impl_.arg3_)*/0u} {}
301 struct TrustyEnqueueNopFtraceEventDefaultTypeInternal {
TrustyEnqueueNopFtraceEventDefaultTypeInternalperfetto::protos::TrustyEnqueueNopFtraceEventDefaultTypeInternal302 PROTOBUF_CONSTEXPR TrustyEnqueueNopFtraceEventDefaultTypeInternal()
303 : _instance(::_pbi::ConstantInitialized{}) {}
~TrustyEnqueueNopFtraceEventDefaultTypeInternalperfetto::protos::TrustyEnqueueNopFtraceEventDefaultTypeInternal304 ~TrustyEnqueueNopFtraceEventDefaultTypeInternal() {}
305 union { // NOLINT(misc-non-private-member-variables-in-classes)
306 TrustyEnqueueNopFtraceEvent _instance;
307 };
308 };
309 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TrustyEnqueueNopFtraceEventDefaultTypeInternal _TrustyEnqueueNopFtraceEvent_default_instance_;
310 } // namespace protos
311 } // namespace perfetto
312 namespace perfetto {
313 namespace protos {
314
315 // ===================================================================
316
317 class TrustySmcFtraceEvent::_Internal {
318 public:
319 using HasBits = decltype(std::declval<TrustySmcFtraceEvent>()._impl_._has_bits_);
set_has_r0(HasBits * has_bits)320 static void set_has_r0(HasBits* has_bits) {
321 (*has_bits)[0] |= 1u;
322 }
set_has_r1(HasBits * has_bits)323 static void set_has_r1(HasBits* has_bits) {
324 (*has_bits)[0] |= 2u;
325 }
set_has_r2(HasBits * has_bits)326 static void set_has_r2(HasBits* has_bits) {
327 (*has_bits)[0] |= 4u;
328 }
set_has_r3(HasBits * has_bits)329 static void set_has_r3(HasBits* has_bits) {
330 (*has_bits)[0] |= 8u;
331 }
332 };
333
TrustySmcFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)334 TrustySmcFtraceEvent::TrustySmcFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
335 bool is_message_owned)
336 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
337 SharedCtor(arena, is_message_owned);
338 // @@protoc_insertion_point(arena_constructor:perfetto.protos.TrustySmcFtraceEvent)
339 }
TrustySmcFtraceEvent(const TrustySmcFtraceEvent & from)340 TrustySmcFtraceEvent::TrustySmcFtraceEvent(const TrustySmcFtraceEvent& from)
341 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
342 TrustySmcFtraceEvent* const _this = this; (void)_this;
343 new (&_impl_) Impl_{
344 decltype(_impl_._has_bits_){from._impl_._has_bits_}
345 , /*decltype(_impl_._cached_size_)*/{}
346 , decltype(_impl_.r0_){}
347 , decltype(_impl_.r1_){}
348 , decltype(_impl_.r2_){}
349 , decltype(_impl_.r3_){}};
350
351 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
352 ::memcpy(&_impl_.r0_, &from._impl_.r0_,
353 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.r3_) -
354 reinterpret_cast<char*>(&_impl_.r0_)) + sizeof(_impl_.r3_));
355 // @@protoc_insertion_point(copy_constructor:perfetto.protos.TrustySmcFtraceEvent)
356 }
357
SharedCtor(::_pb::Arena * arena,bool is_message_owned)358 inline void TrustySmcFtraceEvent::SharedCtor(
359 ::_pb::Arena* arena, bool is_message_owned) {
360 (void)arena;
361 (void)is_message_owned;
362 new (&_impl_) Impl_{
363 decltype(_impl_._has_bits_){}
364 , /*decltype(_impl_._cached_size_)*/{}
365 , decltype(_impl_.r0_){::uint64_t{0u}}
366 , decltype(_impl_.r1_){::uint64_t{0u}}
367 , decltype(_impl_.r2_){::uint64_t{0u}}
368 , decltype(_impl_.r3_){::uint64_t{0u}}
369 };
370 }
371
~TrustySmcFtraceEvent()372 TrustySmcFtraceEvent::~TrustySmcFtraceEvent() {
373 // @@protoc_insertion_point(destructor:perfetto.protos.TrustySmcFtraceEvent)
374 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
375 (void)arena;
376 return;
377 }
378 SharedDtor();
379 }
380
SharedDtor()381 inline void TrustySmcFtraceEvent::SharedDtor() {
382 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
383 }
384
SetCachedSize(int size) const385 void TrustySmcFtraceEvent::SetCachedSize(int size) const {
386 _impl_._cached_size_.Set(size);
387 }
388
Clear()389 void TrustySmcFtraceEvent::Clear() {
390 // @@protoc_insertion_point(message_clear_start:perfetto.protos.TrustySmcFtraceEvent)
391 ::uint32_t cached_has_bits = 0;
392 // Prevent compiler warnings about cached_has_bits being unused
393 (void) cached_has_bits;
394
395 cached_has_bits = _impl_._has_bits_[0];
396 if (cached_has_bits & 0x0000000fu) {
397 ::memset(&_impl_.r0_, 0, static_cast<size_t>(
398 reinterpret_cast<char*>(&_impl_.r3_) -
399 reinterpret_cast<char*>(&_impl_.r0_)) + sizeof(_impl_.r3_));
400 }
401 _impl_._has_bits_.Clear();
402 _internal_metadata_.Clear<std::string>();
403 }
404
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)405 const char* TrustySmcFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
406 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
407 _Internal::HasBits has_bits{};
408 while (!ctx->Done(&ptr)) {
409 ::uint32_t tag;
410 ptr = ::_pbi::ReadTag(ptr, &tag);
411 switch (tag >> 3) {
412 // optional uint64 r0 = 1;
413 case 1:
414 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
415 _Internal::set_has_r0(&has_bits);
416 _impl_.r0_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
417 CHK_(ptr);
418 } else {
419 goto handle_unusual;
420 }
421 continue;
422 // optional uint64 r1 = 2;
423 case 2:
424 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
425 _Internal::set_has_r1(&has_bits);
426 _impl_.r1_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
427 CHK_(ptr);
428 } else {
429 goto handle_unusual;
430 }
431 continue;
432 // optional uint64 r2 = 3;
433 case 3:
434 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
435 _Internal::set_has_r2(&has_bits);
436 _impl_.r2_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
437 CHK_(ptr);
438 } else {
439 goto handle_unusual;
440 }
441 continue;
442 // optional uint64 r3 = 4;
443 case 4:
444 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
445 _Internal::set_has_r3(&has_bits);
446 _impl_.r3_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
447 CHK_(ptr);
448 } else {
449 goto handle_unusual;
450 }
451 continue;
452 default:
453 goto handle_unusual;
454 } // switch
455 handle_unusual:
456 if ((tag == 0) || ((tag & 7) == 4)) {
457 CHK_(ptr);
458 ctx->SetLastTag(tag);
459 goto message_done;
460 }
461 ptr = UnknownFieldParse(
462 tag,
463 _internal_metadata_.mutable_unknown_fields<std::string>(),
464 ptr, ctx);
465 CHK_(ptr != nullptr);
466 } // while
467 message_done:
468 _impl_._has_bits_.Or(has_bits);
469 return ptr;
470 failure:
471 ptr = nullptr;
472 goto message_done;
473 #undef CHK_
474 }
475
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const476 ::uint8_t* TrustySmcFtraceEvent::_InternalSerialize(
477 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
478 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.TrustySmcFtraceEvent)
479 ::uint32_t cached_has_bits = 0;
480 (void) cached_has_bits;
481
482 cached_has_bits = _impl_._has_bits_[0];
483 // optional uint64 r0 = 1;
484 if (cached_has_bits & 0x00000001u) {
485 target = stream->EnsureSpace(target);
486 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_r0(), target);
487 }
488
489 // optional uint64 r1 = 2;
490 if (cached_has_bits & 0x00000002u) {
491 target = stream->EnsureSpace(target);
492 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(2, this->_internal_r1(), target);
493 }
494
495 // optional uint64 r2 = 3;
496 if (cached_has_bits & 0x00000004u) {
497 target = stream->EnsureSpace(target);
498 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(3, this->_internal_r2(), target);
499 }
500
501 // optional uint64 r3 = 4;
502 if (cached_has_bits & 0x00000008u) {
503 target = stream->EnsureSpace(target);
504 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(4, this->_internal_r3(), target);
505 }
506
507 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
508 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
509 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
510 }
511 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.TrustySmcFtraceEvent)
512 return target;
513 }
514
ByteSizeLong() const515 size_t TrustySmcFtraceEvent::ByteSizeLong() const {
516 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.TrustySmcFtraceEvent)
517 size_t total_size = 0;
518
519 ::uint32_t cached_has_bits = 0;
520 // Prevent compiler warnings about cached_has_bits being unused
521 (void) cached_has_bits;
522
523 cached_has_bits = _impl_._has_bits_[0];
524 if (cached_has_bits & 0x0000000fu) {
525 // optional uint64 r0 = 1;
526 if (cached_has_bits & 0x00000001u) {
527 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_r0());
528 }
529
530 // optional uint64 r1 = 2;
531 if (cached_has_bits & 0x00000002u) {
532 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_r1());
533 }
534
535 // optional uint64 r2 = 3;
536 if (cached_has_bits & 0x00000004u) {
537 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_r2());
538 }
539
540 // optional uint64 r3 = 4;
541 if (cached_has_bits & 0x00000008u) {
542 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_r3());
543 }
544
545 }
546 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
547 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
548 }
549 int cached_size = ::_pbi::ToCachedSize(total_size);
550 SetCachedSize(cached_size);
551 return total_size;
552 }
553
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)554 void TrustySmcFtraceEvent::CheckTypeAndMergeFrom(
555 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
556 MergeFrom(*::_pbi::DownCast<const TrustySmcFtraceEvent*>(
557 &from));
558 }
559
MergeFrom(const TrustySmcFtraceEvent & from)560 void TrustySmcFtraceEvent::MergeFrom(const TrustySmcFtraceEvent& from) {
561 TrustySmcFtraceEvent* const _this = this;
562 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.TrustySmcFtraceEvent)
563 GOOGLE_DCHECK_NE(&from, _this);
564 ::uint32_t cached_has_bits = 0;
565 (void) cached_has_bits;
566
567 cached_has_bits = from._impl_._has_bits_[0];
568 if (cached_has_bits & 0x0000000fu) {
569 if (cached_has_bits & 0x00000001u) {
570 _this->_impl_.r0_ = from._impl_.r0_;
571 }
572 if (cached_has_bits & 0x00000002u) {
573 _this->_impl_.r1_ = from._impl_.r1_;
574 }
575 if (cached_has_bits & 0x00000004u) {
576 _this->_impl_.r2_ = from._impl_.r2_;
577 }
578 if (cached_has_bits & 0x00000008u) {
579 _this->_impl_.r3_ = from._impl_.r3_;
580 }
581 _this->_impl_._has_bits_[0] |= cached_has_bits;
582 }
583 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
584 }
585
CopyFrom(const TrustySmcFtraceEvent & from)586 void TrustySmcFtraceEvent::CopyFrom(const TrustySmcFtraceEvent& from) {
587 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.TrustySmcFtraceEvent)
588 if (&from == this) return;
589 Clear();
590 MergeFrom(from);
591 }
592
IsInitialized() const593 bool TrustySmcFtraceEvent::IsInitialized() const {
594 return true;
595 }
596
InternalSwap(TrustySmcFtraceEvent * other)597 void TrustySmcFtraceEvent::InternalSwap(TrustySmcFtraceEvent* other) {
598 using std::swap;
599 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
600 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
601 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
602 PROTOBUF_FIELD_OFFSET(TrustySmcFtraceEvent, _impl_.r3_)
603 + sizeof(TrustySmcFtraceEvent::_impl_.r3_) // NOLINT
604 - PROTOBUF_FIELD_OFFSET(TrustySmcFtraceEvent, _impl_.r0_)>(
605 reinterpret_cast<char*>(&_impl_.r0_),
606 reinterpret_cast<char*>(&other->_impl_.r0_));
607 }
608
GetTypeName() const609 std::string TrustySmcFtraceEvent::GetTypeName() const {
610 return "perfetto.protos.TrustySmcFtraceEvent";
611 }
612
613
614 // ===================================================================
615
616 class TrustySmcDoneFtraceEvent::_Internal {
617 public:
618 using HasBits = decltype(std::declval<TrustySmcDoneFtraceEvent>()._impl_._has_bits_);
set_has_ret(HasBits * has_bits)619 static void set_has_ret(HasBits* has_bits) {
620 (*has_bits)[0] |= 1u;
621 }
622 };
623
TrustySmcDoneFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)624 TrustySmcDoneFtraceEvent::TrustySmcDoneFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
625 bool is_message_owned)
626 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
627 SharedCtor(arena, is_message_owned);
628 // @@protoc_insertion_point(arena_constructor:perfetto.protos.TrustySmcDoneFtraceEvent)
629 }
TrustySmcDoneFtraceEvent(const TrustySmcDoneFtraceEvent & from)630 TrustySmcDoneFtraceEvent::TrustySmcDoneFtraceEvent(const TrustySmcDoneFtraceEvent& from)
631 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
632 TrustySmcDoneFtraceEvent* const _this = this; (void)_this;
633 new (&_impl_) Impl_{
634 decltype(_impl_._has_bits_){from._impl_._has_bits_}
635 , /*decltype(_impl_._cached_size_)*/{}
636 , decltype(_impl_.ret_){}};
637
638 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
639 _this->_impl_.ret_ = from._impl_.ret_;
640 // @@protoc_insertion_point(copy_constructor:perfetto.protos.TrustySmcDoneFtraceEvent)
641 }
642
SharedCtor(::_pb::Arena * arena,bool is_message_owned)643 inline void TrustySmcDoneFtraceEvent::SharedCtor(
644 ::_pb::Arena* arena, bool is_message_owned) {
645 (void)arena;
646 (void)is_message_owned;
647 new (&_impl_) Impl_{
648 decltype(_impl_._has_bits_){}
649 , /*decltype(_impl_._cached_size_)*/{}
650 , decltype(_impl_.ret_){::uint64_t{0u}}
651 };
652 }
653
~TrustySmcDoneFtraceEvent()654 TrustySmcDoneFtraceEvent::~TrustySmcDoneFtraceEvent() {
655 // @@protoc_insertion_point(destructor:perfetto.protos.TrustySmcDoneFtraceEvent)
656 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
657 (void)arena;
658 return;
659 }
660 SharedDtor();
661 }
662
SharedDtor()663 inline void TrustySmcDoneFtraceEvent::SharedDtor() {
664 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
665 }
666
SetCachedSize(int size) const667 void TrustySmcDoneFtraceEvent::SetCachedSize(int size) const {
668 _impl_._cached_size_.Set(size);
669 }
670
Clear()671 void TrustySmcDoneFtraceEvent::Clear() {
672 // @@protoc_insertion_point(message_clear_start:perfetto.protos.TrustySmcDoneFtraceEvent)
673 ::uint32_t cached_has_bits = 0;
674 // Prevent compiler warnings about cached_has_bits being unused
675 (void) cached_has_bits;
676
677 _impl_.ret_ = ::uint64_t{0u};
678 _impl_._has_bits_.Clear();
679 _internal_metadata_.Clear<std::string>();
680 }
681
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)682 const char* TrustySmcDoneFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
683 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
684 _Internal::HasBits has_bits{};
685 while (!ctx->Done(&ptr)) {
686 ::uint32_t tag;
687 ptr = ::_pbi::ReadTag(ptr, &tag);
688 switch (tag >> 3) {
689 // optional uint64 ret = 1;
690 case 1:
691 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
692 _Internal::set_has_ret(&has_bits);
693 _impl_.ret_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
694 CHK_(ptr);
695 } else {
696 goto handle_unusual;
697 }
698 continue;
699 default:
700 goto handle_unusual;
701 } // switch
702 handle_unusual:
703 if ((tag == 0) || ((tag & 7) == 4)) {
704 CHK_(ptr);
705 ctx->SetLastTag(tag);
706 goto message_done;
707 }
708 ptr = UnknownFieldParse(
709 tag,
710 _internal_metadata_.mutable_unknown_fields<std::string>(),
711 ptr, ctx);
712 CHK_(ptr != nullptr);
713 } // while
714 message_done:
715 _impl_._has_bits_.Or(has_bits);
716 return ptr;
717 failure:
718 ptr = nullptr;
719 goto message_done;
720 #undef CHK_
721 }
722
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const723 ::uint8_t* TrustySmcDoneFtraceEvent::_InternalSerialize(
724 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
725 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.TrustySmcDoneFtraceEvent)
726 ::uint32_t cached_has_bits = 0;
727 (void) cached_has_bits;
728
729 cached_has_bits = _impl_._has_bits_[0];
730 // optional uint64 ret = 1;
731 if (cached_has_bits & 0x00000001u) {
732 target = stream->EnsureSpace(target);
733 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_ret(), target);
734 }
735
736 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
737 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
738 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
739 }
740 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.TrustySmcDoneFtraceEvent)
741 return target;
742 }
743
ByteSizeLong() const744 size_t TrustySmcDoneFtraceEvent::ByteSizeLong() const {
745 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.TrustySmcDoneFtraceEvent)
746 size_t total_size = 0;
747
748 ::uint32_t cached_has_bits = 0;
749 // Prevent compiler warnings about cached_has_bits being unused
750 (void) cached_has_bits;
751
752 // optional uint64 ret = 1;
753 cached_has_bits = _impl_._has_bits_[0];
754 if (cached_has_bits & 0x00000001u) {
755 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_ret());
756 }
757
758 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
759 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
760 }
761 int cached_size = ::_pbi::ToCachedSize(total_size);
762 SetCachedSize(cached_size);
763 return total_size;
764 }
765
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)766 void TrustySmcDoneFtraceEvent::CheckTypeAndMergeFrom(
767 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
768 MergeFrom(*::_pbi::DownCast<const TrustySmcDoneFtraceEvent*>(
769 &from));
770 }
771
MergeFrom(const TrustySmcDoneFtraceEvent & from)772 void TrustySmcDoneFtraceEvent::MergeFrom(const TrustySmcDoneFtraceEvent& from) {
773 TrustySmcDoneFtraceEvent* const _this = this;
774 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.TrustySmcDoneFtraceEvent)
775 GOOGLE_DCHECK_NE(&from, _this);
776 ::uint32_t cached_has_bits = 0;
777 (void) cached_has_bits;
778
779 if (from._internal_has_ret()) {
780 _this->_internal_set_ret(from._internal_ret());
781 }
782 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
783 }
784
CopyFrom(const TrustySmcDoneFtraceEvent & from)785 void TrustySmcDoneFtraceEvent::CopyFrom(const TrustySmcDoneFtraceEvent& from) {
786 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.TrustySmcDoneFtraceEvent)
787 if (&from == this) return;
788 Clear();
789 MergeFrom(from);
790 }
791
IsInitialized() const792 bool TrustySmcDoneFtraceEvent::IsInitialized() const {
793 return true;
794 }
795
InternalSwap(TrustySmcDoneFtraceEvent * other)796 void TrustySmcDoneFtraceEvent::InternalSwap(TrustySmcDoneFtraceEvent* other) {
797 using std::swap;
798 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
799 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
800 swap(_impl_.ret_, other->_impl_.ret_);
801 }
802
GetTypeName() const803 std::string TrustySmcDoneFtraceEvent::GetTypeName() const {
804 return "perfetto.protos.TrustySmcDoneFtraceEvent";
805 }
806
807
808 // ===================================================================
809
810 class TrustyStdCall32FtraceEvent::_Internal {
811 public:
812 using HasBits = decltype(std::declval<TrustyStdCall32FtraceEvent>()._impl_._has_bits_);
set_has_r0(HasBits * has_bits)813 static void set_has_r0(HasBits* has_bits) {
814 (*has_bits)[0] |= 1u;
815 }
set_has_r1(HasBits * has_bits)816 static void set_has_r1(HasBits* has_bits) {
817 (*has_bits)[0] |= 2u;
818 }
set_has_r2(HasBits * has_bits)819 static void set_has_r2(HasBits* has_bits) {
820 (*has_bits)[0] |= 4u;
821 }
set_has_r3(HasBits * has_bits)822 static void set_has_r3(HasBits* has_bits) {
823 (*has_bits)[0] |= 8u;
824 }
825 };
826
TrustyStdCall32FtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)827 TrustyStdCall32FtraceEvent::TrustyStdCall32FtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
828 bool is_message_owned)
829 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
830 SharedCtor(arena, is_message_owned);
831 // @@protoc_insertion_point(arena_constructor:perfetto.protos.TrustyStdCall32FtraceEvent)
832 }
TrustyStdCall32FtraceEvent(const TrustyStdCall32FtraceEvent & from)833 TrustyStdCall32FtraceEvent::TrustyStdCall32FtraceEvent(const TrustyStdCall32FtraceEvent& from)
834 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
835 TrustyStdCall32FtraceEvent* const _this = this; (void)_this;
836 new (&_impl_) Impl_{
837 decltype(_impl_._has_bits_){from._impl_._has_bits_}
838 , /*decltype(_impl_._cached_size_)*/{}
839 , decltype(_impl_.r0_){}
840 , decltype(_impl_.r1_){}
841 , decltype(_impl_.r2_){}
842 , decltype(_impl_.r3_){}};
843
844 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
845 ::memcpy(&_impl_.r0_, &from._impl_.r0_,
846 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.r3_) -
847 reinterpret_cast<char*>(&_impl_.r0_)) + sizeof(_impl_.r3_));
848 // @@protoc_insertion_point(copy_constructor:perfetto.protos.TrustyStdCall32FtraceEvent)
849 }
850
SharedCtor(::_pb::Arena * arena,bool is_message_owned)851 inline void TrustyStdCall32FtraceEvent::SharedCtor(
852 ::_pb::Arena* arena, bool is_message_owned) {
853 (void)arena;
854 (void)is_message_owned;
855 new (&_impl_) Impl_{
856 decltype(_impl_._has_bits_){}
857 , /*decltype(_impl_._cached_size_)*/{}
858 , decltype(_impl_.r0_){::uint64_t{0u}}
859 , decltype(_impl_.r1_){::uint64_t{0u}}
860 , decltype(_impl_.r2_){::uint64_t{0u}}
861 , decltype(_impl_.r3_){::uint64_t{0u}}
862 };
863 }
864
~TrustyStdCall32FtraceEvent()865 TrustyStdCall32FtraceEvent::~TrustyStdCall32FtraceEvent() {
866 // @@protoc_insertion_point(destructor:perfetto.protos.TrustyStdCall32FtraceEvent)
867 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
868 (void)arena;
869 return;
870 }
871 SharedDtor();
872 }
873
SharedDtor()874 inline void TrustyStdCall32FtraceEvent::SharedDtor() {
875 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
876 }
877
SetCachedSize(int size) const878 void TrustyStdCall32FtraceEvent::SetCachedSize(int size) const {
879 _impl_._cached_size_.Set(size);
880 }
881
Clear()882 void TrustyStdCall32FtraceEvent::Clear() {
883 // @@protoc_insertion_point(message_clear_start:perfetto.protos.TrustyStdCall32FtraceEvent)
884 ::uint32_t cached_has_bits = 0;
885 // Prevent compiler warnings about cached_has_bits being unused
886 (void) cached_has_bits;
887
888 cached_has_bits = _impl_._has_bits_[0];
889 if (cached_has_bits & 0x0000000fu) {
890 ::memset(&_impl_.r0_, 0, static_cast<size_t>(
891 reinterpret_cast<char*>(&_impl_.r3_) -
892 reinterpret_cast<char*>(&_impl_.r0_)) + sizeof(_impl_.r3_));
893 }
894 _impl_._has_bits_.Clear();
895 _internal_metadata_.Clear<std::string>();
896 }
897
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)898 const char* TrustyStdCall32FtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
899 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
900 _Internal::HasBits has_bits{};
901 while (!ctx->Done(&ptr)) {
902 ::uint32_t tag;
903 ptr = ::_pbi::ReadTag(ptr, &tag);
904 switch (tag >> 3) {
905 // optional uint64 r0 = 1;
906 case 1:
907 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
908 _Internal::set_has_r0(&has_bits);
909 _impl_.r0_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
910 CHK_(ptr);
911 } else {
912 goto handle_unusual;
913 }
914 continue;
915 // optional uint64 r1 = 2;
916 case 2:
917 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
918 _Internal::set_has_r1(&has_bits);
919 _impl_.r1_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
920 CHK_(ptr);
921 } else {
922 goto handle_unusual;
923 }
924 continue;
925 // optional uint64 r2 = 3;
926 case 3:
927 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
928 _Internal::set_has_r2(&has_bits);
929 _impl_.r2_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
930 CHK_(ptr);
931 } else {
932 goto handle_unusual;
933 }
934 continue;
935 // optional uint64 r3 = 4;
936 case 4:
937 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
938 _Internal::set_has_r3(&has_bits);
939 _impl_.r3_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
940 CHK_(ptr);
941 } else {
942 goto handle_unusual;
943 }
944 continue;
945 default:
946 goto handle_unusual;
947 } // switch
948 handle_unusual:
949 if ((tag == 0) || ((tag & 7) == 4)) {
950 CHK_(ptr);
951 ctx->SetLastTag(tag);
952 goto message_done;
953 }
954 ptr = UnknownFieldParse(
955 tag,
956 _internal_metadata_.mutable_unknown_fields<std::string>(),
957 ptr, ctx);
958 CHK_(ptr != nullptr);
959 } // while
960 message_done:
961 _impl_._has_bits_.Or(has_bits);
962 return ptr;
963 failure:
964 ptr = nullptr;
965 goto message_done;
966 #undef CHK_
967 }
968
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const969 ::uint8_t* TrustyStdCall32FtraceEvent::_InternalSerialize(
970 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
971 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.TrustyStdCall32FtraceEvent)
972 ::uint32_t cached_has_bits = 0;
973 (void) cached_has_bits;
974
975 cached_has_bits = _impl_._has_bits_[0];
976 // optional uint64 r0 = 1;
977 if (cached_has_bits & 0x00000001u) {
978 target = stream->EnsureSpace(target);
979 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_r0(), target);
980 }
981
982 // optional uint64 r1 = 2;
983 if (cached_has_bits & 0x00000002u) {
984 target = stream->EnsureSpace(target);
985 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(2, this->_internal_r1(), target);
986 }
987
988 // optional uint64 r2 = 3;
989 if (cached_has_bits & 0x00000004u) {
990 target = stream->EnsureSpace(target);
991 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(3, this->_internal_r2(), target);
992 }
993
994 // optional uint64 r3 = 4;
995 if (cached_has_bits & 0x00000008u) {
996 target = stream->EnsureSpace(target);
997 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(4, this->_internal_r3(), target);
998 }
999
1000 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1001 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1002 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1003 }
1004 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.TrustyStdCall32FtraceEvent)
1005 return target;
1006 }
1007
ByteSizeLong() const1008 size_t TrustyStdCall32FtraceEvent::ByteSizeLong() const {
1009 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.TrustyStdCall32FtraceEvent)
1010 size_t total_size = 0;
1011
1012 ::uint32_t cached_has_bits = 0;
1013 // Prevent compiler warnings about cached_has_bits being unused
1014 (void) cached_has_bits;
1015
1016 cached_has_bits = _impl_._has_bits_[0];
1017 if (cached_has_bits & 0x0000000fu) {
1018 // optional uint64 r0 = 1;
1019 if (cached_has_bits & 0x00000001u) {
1020 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_r0());
1021 }
1022
1023 // optional uint64 r1 = 2;
1024 if (cached_has_bits & 0x00000002u) {
1025 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_r1());
1026 }
1027
1028 // optional uint64 r2 = 3;
1029 if (cached_has_bits & 0x00000004u) {
1030 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_r2());
1031 }
1032
1033 // optional uint64 r3 = 4;
1034 if (cached_has_bits & 0x00000008u) {
1035 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_r3());
1036 }
1037
1038 }
1039 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1040 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1041 }
1042 int cached_size = ::_pbi::ToCachedSize(total_size);
1043 SetCachedSize(cached_size);
1044 return total_size;
1045 }
1046
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1047 void TrustyStdCall32FtraceEvent::CheckTypeAndMergeFrom(
1048 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1049 MergeFrom(*::_pbi::DownCast<const TrustyStdCall32FtraceEvent*>(
1050 &from));
1051 }
1052
MergeFrom(const TrustyStdCall32FtraceEvent & from)1053 void TrustyStdCall32FtraceEvent::MergeFrom(const TrustyStdCall32FtraceEvent& from) {
1054 TrustyStdCall32FtraceEvent* const _this = this;
1055 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.TrustyStdCall32FtraceEvent)
1056 GOOGLE_DCHECK_NE(&from, _this);
1057 ::uint32_t cached_has_bits = 0;
1058 (void) cached_has_bits;
1059
1060 cached_has_bits = from._impl_._has_bits_[0];
1061 if (cached_has_bits & 0x0000000fu) {
1062 if (cached_has_bits & 0x00000001u) {
1063 _this->_impl_.r0_ = from._impl_.r0_;
1064 }
1065 if (cached_has_bits & 0x00000002u) {
1066 _this->_impl_.r1_ = from._impl_.r1_;
1067 }
1068 if (cached_has_bits & 0x00000004u) {
1069 _this->_impl_.r2_ = from._impl_.r2_;
1070 }
1071 if (cached_has_bits & 0x00000008u) {
1072 _this->_impl_.r3_ = from._impl_.r3_;
1073 }
1074 _this->_impl_._has_bits_[0] |= cached_has_bits;
1075 }
1076 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1077 }
1078
CopyFrom(const TrustyStdCall32FtraceEvent & from)1079 void TrustyStdCall32FtraceEvent::CopyFrom(const TrustyStdCall32FtraceEvent& from) {
1080 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.TrustyStdCall32FtraceEvent)
1081 if (&from == this) return;
1082 Clear();
1083 MergeFrom(from);
1084 }
1085
IsInitialized() const1086 bool TrustyStdCall32FtraceEvent::IsInitialized() const {
1087 return true;
1088 }
1089
InternalSwap(TrustyStdCall32FtraceEvent * other)1090 void TrustyStdCall32FtraceEvent::InternalSwap(TrustyStdCall32FtraceEvent* other) {
1091 using std::swap;
1092 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1093 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
1094 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
1095 PROTOBUF_FIELD_OFFSET(TrustyStdCall32FtraceEvent, _impl_.r3_)
1096 + sizeof(TrustyStdCall32FtraceEvent::_impl_.r3_) // NOLINT
1097 - PROTOBUF_FIELD_OFFSET(TrustyStdCall32FtraceEvent, _impl_.r0_)>(
1098 reinterpret_cast<char*>(&_impl_.r0_),
1099 reinterpret_cast<char*>(&other->_impl_.r0_));
1100 }
1101
GetTypeName() const1102 std::string TrustyStdCall32FtraceEvent::GetTypeName() const {
1103 return "perfetto.protos.TrustyStdCall32FtraceEvent";
1104 }
1105
1106
1107 // ===================================================================
1108
1109 class TrustyStdCall32DoneFtraceEvent::_Internal {
1110 public:
1111 using HasBits = decltype(std::declval<TrustyStdCall32DoneFtraceEvent>()._impl_._has_bits_);
set_has_ret(HasBits * has_bits)1112 static void set_has_ret(HasBits* has_bits) {
1113 (*has_bits)[0] |= 1u;
1114 }
1115 };
1116
TrustyStdCall32DoneFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1117 TrustyStdCall32DoneFtraceEvent::TrustyStdCall32DoneFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1118 bool is_message_owned)
1119 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1120 SharedCtor(arena, is_message_owned);
1121 // @@protoc_insertion_point(arena_constructor:perfetto.protos.TrustyStdCall32DoneFtraceEvent)
1122 }
TrustyStdCall32DoneFtraceEvent(const TrustyStdCall32DoneFtraceEvent & from)1123 TrustyStdCall32DoneFtraceEvent::TrustyStdCall32DoneFtraceEvent(const TrustyStdCall32DoneFtraceEvent& from)
1124 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1125 TrustyStdCall32DoneFtraceEvent* const _this = this; (void)_this;
1126 new (&_impl_) Impl_{
1127 decltype(_impl_._has_bits_){from._impl_._has_bits_}
1128 , /*decltype(_impl_._cached_size_)*/{}
1129 , decltype(_impl_.ret_){}};
1130
1131 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1132 _this->_impl_.ret_ = from._impl_.ret_;
1133 // @@protoc_insertion_point(copy_constructor:perfetto.protos.TrustyStdCall32DoneFtraceEvent)
1134 }
1135
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1136 inline void TrustyStdCall32DoneFtraceEvent::SharedCtor(
1137 ::_pb::Arena* arena, bool is_message_owned) {
1138 (void)arena;
1139 (void)is_message_owned;
1140 new (&_impl_) Impl_{
1141 decltype(_impl_._has_bits_){}
1142 , /*decltype(_impl_._cached_size_)*/{}
1143 , decltype(_impl_.ret_){::int64_t{0}}
1144 };
1145 }
1146
~TrustyStdCall32DoneFtraceEvent()1147 TrustyStdCall32DoneFtraceEvent::~TrustyStdCall32DoneFtraceEvent() {
1148 // @@protoc_insertion_point(destructor:perfetto.protos.TrustyStdCall32DoneFtraceEvent)
1149 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1150 (void)arena;
1151 return;
1152 }
1153 SharedDtor();
1154 }
1155
SharedDtor()1156 inline void TrustyStdCall32DoneFtraceEvent::SharedDtor() {
1157 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1158 }
1159
SetCachedSize(int size) const1160 void TrustyStdCall32DoneFtraceEvent::SetCachedSize(int size) const {
1161 _impl_._cached_size_.Set(size);
1162 }
1163
Clear()1164 void TrustyStdCall32DoneFtraceEvent::Clear() {
1165 // @@protoc_insertion_point(message_clear_start:perfetto.protos.TrustyStdCall32DoneFtraceEvent)
1166 ::uint32_t cached_has_bits = 0;
1167 // Prevent compiler warnings about cached_has_bits being unused
1168 (void) cached_has_bits;
1169
1170 _impl_.ret_ = ::int64_t{0};
1171 _impl_._has_bits_.Clear();
1172 _internal_metadata_.Clear<std::string>();
1173 }
1174
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1175 const char* TrustyStdCall32DoneFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1176 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1177 _Internal::HasBits has_bits{};
1178 while (!ctx->Done(&ptr)) {
1179 ::uint32_t tag;
1180 ptr = ::_pbi::ReadTag(ptr, &tag);
1181 switch (tag >> 3) {
1182 // optional int64 ret = 1;
1183 case 1:
1184 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
1185 _Internal::set_has_ret(&has_bits);
1186 _impl_.ret_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1187 CHK_(ptr);
1188 } else {
1189 goto handle_unusual;
1190 }
1191 continue;
1192 default:
1193 goto handle_unusual;
1194 } // switch
1195 handle_unusual:
1196 if ((tag == 0) || ((tag & 7) == 4)) {
1197 CHK_(ptr);
1198 ctx->SetLastTag(tag);
1199 goto message_done;
1200 }
1201 ptr = UnknownFieldParse(
1202 tag,
1203 _internal_metadata_.mutable_unknown_fields<std::string>(),
1204 ptr, ctx);
1205 CHK_(ptr != nullptr);
1206 } // while
1207 message_done:
1208 _impl_._has_bits_.Or(has_bits);
1209 return ptr;
1210 failure:
1211 ptr = nullptr;
1212 goto message_done;
1213 #undef CHK_
1214 }
1215
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1216 ::uint8_t* TrustyStdCall32DoneFtraceEvent::_InternalSerialize(
1217 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1218 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.TrustyStdCall32DoneFtraceEvent)
1219 ::uint32_t cached_has_bits = 0;
1220 (void) cached_has_bits;
1221
1222 cached_has_bits = _impl_._has_bits_[0];
1223 // optional int64 ret = 1;
1224 if (cached_has_bits & 0x00000001u) {
1225 target = stream->EnsureSpace(target);
1226 target = ::_pbi::WireFormatLite::WriteInt64ToArray(1, this->_internal_ret(), target);
1227 }
1228
1229 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1230 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1231 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1232 }
1233 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.TrustyStdCall32DoneFtraceEvent)
1234 return target;
1235 }
1236
ByteSizeLong() const1237 size_t TrustyStdCall32DoneFtraceEvent::ByteSizeLong() const {
1238 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.TrustyStdCall32DoneFtraceEvent)
1239 size_t total_size = 0;
1240
1241 ::uint32_t cached_has_bits = 0;
1242 // Prevent compiler warnings about cached_has_bits being unused
1243 (void) cached_has_bits;
1244
1245 // optional int64 ret = 1;
1246 cached_has_bits = _impl_._has_bits_[0];
1247 if (cached_has_bits & 0x00000001u) {
1248 total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_ret());
1249 }
1250
1251 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1252 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1253 }
1254 int cached_size = ::_pbi::ToCachedSize(total_size);
1255 SetCachedSize(cached_size);
1256 return total_size;
1257 }
1258
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1259 void TrustyStdCall32DoneFtraceEvent::CheckTypeAndMergeFrom(
1260 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1261 MergeFrom(*::_pbi::DownCast<const TrustyStdCall32DoneFtraceEvent*>(
1262 &from));
1263 }
1264
MergeFrom(const TrustyStdCall32DoneFtraceEvent & from)1265 void TrustyStdCall32DoneFtraceEvent::MergeFrom(const TrustyStdCall32DoneFtraceEvent& from) {
1266 TrustyStdCall32DoneFtraceEvent* const _this = this;
1267 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.TrustyStdCall32DoneFtraceEvent)
1268 GOOGLE_DCHECK_NE(&from, _this);
1269 ::uint32_t cached_has_bits = 0;
1270 (void) cached_has_bits;
1271
1272 if (from._internal_has_ret()) {
1273 _this->_internal_set_ret(from._internal_ret());
1274 }
1275 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1276 }
1277
CopyFrom(const TrustyStdCall32DoneFtraceEvent & from)1278 void TrustyStdCall32DoneFtraceEvent::CopyFrom(const TrustyStdCall32DoneFtraceEvent& from) {
1279 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.TrustyStdCall32DoneFtraceEvent)
1280 if (&from == this) return;
1281 Clear();
1282 MergeFrom(from);
1283 }
1284
IsInitialized() const1285 bool TrustyStdCall32DoneFtraceEvent::IsInitialized() const {
1286 return true;
1287 }
1288
InternalSwap(TrustyStdCall32DoneFtraceEvent * other)1289 void TrustyStdCall32DoneFtraceEvent::InternalSwap(TrustyStdCall32DoneFtraceEvent* other) {
1290 using std::swap;
1291 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1292 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
1293 swap(_impl_.ret_, other->_impl_.ret_);
1294 }
1295
GetTypeName() const1296 std::string TrustyStdCall32DoneFtraceEvent::GetTypeName() const {
1297 return "perfetto.protos.TrustyStdCall32DoneFtraceEvent";
1298 }
1299
1300
1301 // ===================================================================
1302
1303 class TrustyShareMemoryFtraceEvent::_Internal {
1304 public:
1305 using HasBits = decltype(std::declval<TrustyShareMemoryFtraceEvent>()._impl_._has_bits_);
set_has_len(HasBits * has_bits)1306 static void set_has_len(HasBits* has_bits) {
1307 (*has_bits)[0] |= 1u;
1308 }
set_has_lend(HasBits * has_bits)1309 static void set_has_lend(HasBits* has_bits) {
1310 (*has_bits)[0] |= 2u;
1311 }
set_has_nents(HasBits * has_bits)1312 static void set_has_nents(HasBits* has_bits) {
1313 (*has_bits)[0] |= 4u;
1314 }
1315 };
1316
TrustyShareMemoryFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1317 TrustyShareMemoryFtraceEvent::TrustyShareMemoryFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1318 bool is_message_owned)
1319 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1320 SharedCtor(arena, is_message_owned);
1321 // @@protoc_insertion_point(arena_constructor:perfetto.protos.TrustyShareMemoryFtraceEvent)
1322 }
TrustyShareMemoryFtraceEvent(const TrustyShareMemoryFtraceEvent & from)1323 TrustyShareMemoryFtraceEvent::TrustyShareMemoryFtraceEvent(const TrustyShareMemoryFtraceEvent& from)
1324 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1325 TrustyShareMemoryFtraceEvent* const _this = this; (void)_this;
1326 new (&_impl_) Impl_{
1327 decltype(_impl_._has_bits_){from._impl_._has_bits_}
1328 , /*decltype(_impl_._cached_size_)*/{}
1329 , decltype(_impl_.len_){}
1330 , decltype(_impl_.lend_){}
1331 , decltype(_impl_.nents_){}};
1332
1333 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1334 ::memcpy(&_impl_.len_, &from._impl_.len_,
1335 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.nents_) -
1336 reinterpret_cast<char*>(&_impl_.len_)) + sizeof(_impl_.nents_));
1337 // @@protoc_insertion_point(copy_constructor:perfetto.protos.TrustyShareMemoryFtraceEvent)
1338 }
1339
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1340 inline void TrustyShareMemoryFtraceEvent::SharedCtor(
1341 ::_pb::Arena* arena, bool is_message_owned) {
1342 (void)arena;
1343 (void)is_message_owned;
1344 new (&_impl_) Impl_{
1345 decltype(_impl_._has_bits_){}
1346 , /*decltype(_impl_._cached_size_)*/{}
1347 , decltype(_impl_.len_){::uint64_t{0u}}
1348 , decltype(_impl_.lend_){0u}
1349 , decltype(_impl_.nents_){0u}
1350 };
1351 }
1352
~TrustyShareMemoryFtraceEvent()1353 TrustyShareMemoryFtraceEvent::~TrustyShareMemoryFtraceEvent() {
1354 // @@protoc_insertion_point(destructor:perfetto.protos.TrustyShareMemoryFtraceEvent)
1355 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1356 (void)arena;
1357 return;
1358 }
1359 SharedDtor();
1360 }
1361
SharedDtor()1362 inline void TrustyShareMemoryFtraceEvent::SharedDtor() {
1363 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1364 }
1365
SetCachedSize(int size) const1366 void TrustyShareMemoryFtraceEvent::SetCachedSize(int size) const {
1367 _impl_._cached_size_.Set(size);
1368 }
1369
Clear()1370 void TrustyShareMemoryFtraceEvent::Clear() {
1371 // @@protoc_insertion_point(message_clear_start:perfetto.protos.TrustyShareMemoryFtraceEvent)
1372 ::uint32_t cached_has_bits = 0;
1373 // Prevent compiler warnings about cached_has_bits being unused
1374 (void) cached_has_bits;
1375
1376 cached_has_bits = _impl_._has_bits_[0];
1377 if (cached_has_bits & 0x00000007u) {
1378 ::memset(&_impl_.len_, 0, static_cast<size_t>(
1379 reinterpret_cast<char*>(&_impl_.nents_) -
1380 reinterpret_cast<char*>(&_impl_.len_)) + sizeof(_impl_.nents_));
1381 }
1382 _impl_._has_bits_.Clear();
1383 _internal_metadata_.Clear<std::string>();
1384 }
1385
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1386 const char* TrustyShareMemoryFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1387 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1388 _Internal::HasBits has_bits{};
1389 while (!ctx->Done(&ptr)) {
1390 ::uint32_t tag;
1391 ptr = ::_pbi::ReadTag(ptr, &tag);
1392 switch (tag >> 3) {
1393 // optional uint64 len = 1;
1394 case 1:
1395 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
1396 _Internal::set_has_len(&has_bits);
1397 _impl_.len_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1398 CHK_(ptr);
1399 } else {
1400 goto handle_unusual;
1401 }
1402 continue;
1403 // optional uint32 lend = 2;
1404 case 2:
1405 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
1406 _Internal::set_has_lend(&has_bits);
1407 _impl_.lend_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1408 CHK_(ptr);
1409 } else {
1410 goto handle_unusual;
1411 }
1412 continue;
1413 // optional uint32 nents = 3;
1414 case 3:
1415 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
1416 _Internal::set_has_nents(&has_bits);
1417 _impl_.nents_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1418 CHK_(ptr);
1419 } else {
1420 goto handle_unusual;
1421 }
1422 continue;
1423 default:
1424 goto handle_unusual;
1425 } // switch
1426 handle_unusual:
1427 if ((tag == 0) || ((tag & 7) == 4)) {
1428 CHK_(ptr);
1429 ctx->SetLastTag(tag);
1430 goto message_done;
1431 }
1432 ptr = UnknownFieldParse(
1433 tag,
1434 _internal_metadata_.mutable_unknown_fields<std::string>(),
1435 ptr, ctx);
1436 CHK_(ptr != nullptr);
1437 } // while
1438 message_done:
1439 _impl_._has_bits_.Or(has_bits);
1440 return ptr;
1441 failure:
1442 ptr = nullptr;
1443 goto message_done;
1444 #undef CHK_
1445 }
1446
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1447 ::uint8_t* TrustyShareMemoryFtraceEvent::_InternalSerialize(
1448 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1449 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.TrustyShareMemoryFtraceEvent)
1450 ::uint32_t cached_has_bits = 0;
1451 (void) cached_has_bits;
1452
1453 cached_has_bits = _impl_._has_bits_[0];
1454 // optional uint64 len = 1;
1455 if (cached_has_bits & 0x00000001u) {
1456 target = stream->EnsureSpace(target);
1457 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_len(), target);
1458 }
1459
1460 // optional uint32 lend = 2;
1461 if (cached_has_bits & 0x00000002u) {
1462 target = stream->EnsureSpace(target);
1463 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_lend(), target);
1464 }
1465
1466 // optional uint32 nents = 3;
1467 if (cached_has_bits & 0x00000004u) {
1468 target = stream->EnsureSpace(target);
1469 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_nents(), target);
1470 }
1471
1472 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1473 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1474 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1475 }
1476 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.TrustyShareMemoryFtraceEvent)
1477 return target;
1478 }
1479
ByteSizeLong() const1480 size_t TrustyShareMemoryFtraceEvent::ByteSizeLong() const {
1481 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.TrustyShareMemoryFtraceEvent)
1482 size_t total_size = 0;
1483
1484 ::uint32_t cached_has_bits = 0;
1485 // Prevent compiler warnings about cached_has_bits being unused
1486 (void) cached_has_bits;
1487
1488 cached_has_bits = _impl_._has_bits_[0];
1489 if (cached_has_bits & 0x00000007u) {
1490 // optional uint64 len = 1;
1491 if (cached_has_bits & 0x00000001u) {
1492 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_len());
1493 }
1494
1495 // optional uint32 lend = 2;
1496 if (cached_has_bits & 0x00000002u) {
1497 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_lend());
1498 }
1499
1500 // optional uint32 nents = 3;
1501 if (cached_has_bits & 0x00000004u) {
1502 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_nents());
1503 }
1504
1505 }
1506 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1507 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1508 }
1509 int cached_size = ::_pbi::ToCachedSize(total_size);
1510 SetCachedSize(cached_size);
1511 return total_size;
1512 }
1513
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1514 void TrustyShareMemoryFtraceEvent::CheckTypeAndMergeFrom(
1515 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1516 MergeFrom(*::_pbi::DownCast<const TrustyShareMemoryFtraceEvent*>(
1517 &from));
1518 }
1519
MergeFrom(const TrustyShareMemoryFtraceEvent & from)1520 void TrustyShareMemoryFtraceEvent::MergeFrom(const TrustyShareMemoryFtraceEvent& from) {
1521 TrustyShareMemoryFtraceEvent* const _this = this;
1522 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.TrustyShareMemoryFtraceEvent)
1523 GOOGLE_DCHECK_NE(&from, _this);
1524 ::uint32_t cached_has_bits = 0;
1525 (void) cached_has_bits;
1526
1527 cached_has_bits = from._impl_._has_bits_[0];
1528 if (cached_has_bits & 0x00000007u) {
1529 if (cached_has_bits & 0x00000001u) {
1530 _this->_impl_.len_ = from._impl_.len_;
1531 }
1532 if (cached_has_bits & 0x00000002u) {
1533 _this->_impl_.lend_ = from._impl_.lend_;
1534 }
1535 if (cached_has_bits & 0x00000004u) {
1536 _this->_impl_.nents_ = from._impl_.nents_;
1537 }
1538 _this->_impl_._has_bits_[0] |= cached_has_bits;
1539 }
1540 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1541 }
1542
CopyFrom(const TrustyShareMemoryFtraceEvent & from)1543 void TrustyShareMemoryFtraceEvent::CopyFrom(const TrustyShareMemoryFtraceEvent& from) {
1544 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.TrustyShareMemoryFtraceEvent)
1545 if (&from == this) return;
1546 Clear();
1547 MergeFrom(from);
1548 }
1549
IsInitialized() const1550 bool TrustyShareMemoryFtraceEvent::IsInitialized() const {
1551 return true;
1552 }
1553
InternalSwap(TrustyShareMemoryFtraceEvent * other)1554 void TrustyShareMemoryFtraceEvent::InternalSwap(TrustyShareMemoryFtraceEvent* other) {
1555 using std::swap;
1556 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1557 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
1558 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
1559 PROTOBUF_FIELD_OFFSET(TrustyShareMemoryFtraceEvent, _impl_.nents_)
1560 + sizeof(TrustyShareMemoryFtraceEvent::_impl_.nents_) // NOLINT
1561 - PROTOBUF_FIELD_OFFSET(TrustyShareMemoryFtraceEvent, _impl_.len_)>(
1562 reinterpret_cast<char*>(&_impl_.len_),
1563 reinterpret_cast<char*>(&other->_impl_.len_));
1564 }
1565
GetTypeName() const1566 std::string TrustyShareMemoryFtraceEvent::GetTypeName() const {
1567 return "perfetto.protos.TrustyShareMemoryFtraceEvent";
1568 }
1569
1570
1571 // ===================================================================
1572
1573 class TrustyShareMemoryDoneFtraceEvent::_Internal {
1574 public:
1575 using HasBits = decltype(std::declval<TrustyShareMemoryDoneFtraceEvent>()._impl_._has_bits_);
set_has_handle(HasBits * has_bits)1576 static void set_has_handle(HasBits* has_bits) {
1577 (*has_bits)[0] |= 1u;
1578 }
set_has_len(HasBits * has_bits)1579 static void set_has_len(HasBits* has_bits) {
1580 (*has_bits)[0] |= 2u;
1581 }
set_has_lend(HasBits * has_bits)1582 static void set_has_lend(HasBits* has_bits) {
1583 (*has_bits)[0] |= 4u;
1584 }
set_has_nents(HasBits * has_bits)1585 static void set_has_nents(HasBits* has_bits) {
1586 (*has_bits)[0] |= 8u;
1587 }
set_has_ret(HasBits * has_bits)1588 static void set_has_ret(HasBits* has_bits) {
1589 (*has_bits)[0] |= 16u;
1590 }
1591 };
1592
TrustyShareMemoryDoneFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1593 TrustyShareMemoryDoneFtraceEvent::TrustyShareMemoryDoneFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1594 bool is_message_owned)
1595 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1596 SharedCtor(arena, is_message_owned);
1597 // @@protoc_insertion_point(arena_constructor:perfetto.protos.TrustyShareMemoryDoneFtraceEvent)
1598 }
TrustyShareMemoryDoneFtraceEvent(const TrustyShareMemoryDoneFtraceEvent & from)1599 TrustyShareMemoryDoneFtraceEvent::TrustyShareMemoryDoneFtraceEvent(const TrustyShareMemoryDoneFtraceEvent& from)
1600 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1601 TrustyShareMemoryDoneFtraceEvent* const _this = this; (void)_this;
1602 new (&_impl_) Impl_{
1603 decltype(_impl_._has_bits_){from._impl_._has_bits_}
1604 , /*decltype(_impl_._cached_size_)*/{}
1605 , decltype(_impl_.handle_){}
1606 , decltype(_impl_.len_){}
1607 , decltype(_impl_.lend_){}
1608 , decltype(_impl_.nents_){}
1609 , decltype(_impl_.ret_){}};
1610
1611 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1612 ::memcpy(&_impl_.handle_, &from._impl_.handle_,
1613 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.ret_) -
1614 reinterpret_cast<char*>(&_impl_.handle_)) + sizeof(_impl_.ret_));
1615 // @@protoc_insertion_point(copy_constructor:perfetto.protos.TrustyShareMemoryDoneFtraceEvent)
1616 }
1617
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1618 inline void TrustyShareMemoryDoneFtraceEvent::SharedCtor(
1619 ::_pb::Arena* arena, bool is_message_owned) {
1620 (void)arena;
1621 (void)is_message_owned;
1622 new (&_impl_) Impl_{
1623 decltype(_impl_._has_bits_){}
1624 , /*decltype(_impl_._cached_size_)*/{}
1625 , decltype(_impl_.handle_){::uint64_t{0u}}
1626 , decltype(_impl_.len_){::uint64_t{0u}}
1627 , decltype(_impl_.lend_){0u}
1628 , decltype(_impl_.nents_){0u}
1629 , decltype(_impl_.ret_){0}
1630 };
1631 }
1632
~TrustyShareMemoryDoneFtraceEvent()1633 TrustyShareMemoryDoneFtraceEvent::~TrustyShareMemoryDoneFtraceEvent() {
1634 // @@protoc_insertion_point(destructor:perfetto.protos.TrustyShareMemoryDoneFtraceEvent)
1635 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1636 (void)arena;
1637 return;
1638 }
1639 SharedDtor();
1640 }
1641
SharedDtor()1642 inline void TrustyShareMemoryDoneFtraceEvent::SharedDtor() {
1643 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1644 }
1645
SetCachedSize(int size) const1646 void TrustyShareMemoryDoneFtraceEvent::SetCachedSize(int size) const {
1647 _impl_._cached_size_.Set(size);
1648 }
1649
Clear()1650 void TrustyShareMemoryDoneFtraceEvent::Clear() {
1651 // @@protoc_insertion_point(message_clear_start:perfetto.protos.TrustyShareMemoryDoneFtraceEvent)
1652 ::uint32_t cached_has_bits = 0;
1653 // Prevent compiler warnings about cached_has_bits being unused
1654 (void) cached_has_bits;
1655
1656 cached_has_bits = _impl_._has_bits_[0];
1657 if (cached_has_bits & 0x0000001fu) {
1658 ::memset(&_impl_.handle_, 0, static_cast<size_t>(
1659 reinterpret_cast<char*>(&_impl_.ret_) -
1660 reinterpret_cast<char*>(&_impl_.handle_)) + sizeof(_impl_.ret_));
1661 }
1662 _impl_._has_bits_.Clear();
1663 _internal_metadata_.Clear<std::string>();
1664 }
1665
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1666 const char* TrustyShareMemoryDoneFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1667 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1668 _Internal::HasBits has_bits{};
1669 while (!ctx->Done(&ptr)) {
1670 ::uint32_t tag;
1671 ptr = ::_pbi::ReadTag(ptr, &tag);
1672 switch (tag >> 3) {
1673 // optional uint64 handle = 1;
1674 case 1:
1675 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
1676 _Internal::set_has_handle(&has_bits);
1677 _impl_.handle_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1678 CHK_(ptr);
1679 } else {
1680 goto handle_unusual;
1681 }
1682 continue;
1683 // optional uint64 len = 2;
1684 case 2:
1685 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
1686 _Internal::set_has_len(&has_bits);
1687 _impl_.len_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1688 CHK_(ptr);
1689 } else {
1690 goto handle_unusual;
1691 }
1692 continue;
1693 // optional uint32 lend = 3;
1694 case 3:
1695 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
1696 _Internal::set_has_lend(&has_bits);
1697 _impl_.lend_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1698 CHK_(ptr);
1699 } else {
1700 goto handle_unusual;
1701 }
1702 continue;
1703 // optional uint32 nents = 4;
1704 case 4:
1705 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
1706 _Internal::set_has_nents(&has_bits);
1707 _impl_.nents_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1708 CHK_(ptr);
1709 } else {
1710 goto handle_unusual;
1711 }
1712 continue;
1713 // optional int32 ret = 5;
1714 case 5:
1715 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
1716 _Internal::set_has_ret(&has_bits);
1717 _impl_.ret_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1718 CHK_(ptr);
1719 } else {
1720 goto handle_unusual;
1721 }
1722 continue;
1723 default:
1724 goto handle_unusual;
1725 } // switch
1726 handle_unusual:
1727 if ((tag == 0) || ((tag & 7) == 4)) {
1728 CHK_(ptr);
1729 ctx->SetLastTag(tag);
1730 goto message_done;
1731 }
1732 ptr = UnknownFieldParse(
1733 tag,
1734 _internal_metadata_.mutable_unknown_fields<std::string>(),
1735 ptr, ctx);
1736 CHK_(ptr != nullptr);
1737 } // while
1738 message_done:
1739 _impl_._has_bits_.Or(has_bits);
1740 return ptr;
1741 failure:
1742 ptr = nullptr;
1743 goto message_done;
1744 #undef CHK_
1745 }
1746
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1747 ::uint8_t* TrustyShareMemoryDoneFtraceEvent::_InternalSerialize(
1748 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1749 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.TrustyShareMemoryDoneFtraceEvent)
1750 ::uint32_t cached_has_bits = 0;
1751 (void) cached_has_bits;
1752
1753 cached_has_bits = _impl_._has_bits_[0];
1754 // optional uint64 handle = 1;
1755 if (cached_has_bits & 0x00000001u) {
1756 target = stream->EnsureSpace(target);
1757 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_handle(), target);
1758 }
1759
1760 // optional uint64 len = 2;
1761 if (cached_has_bits & 0x00000002u) {
1762 target = stream->EnsureSpace(target);
1763 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(2, this->_internal_len(), target);
1764 }
1765
1766 // optional uint32 lend = 3;
1767 if (cached_has_bits & 0x00000004u) {
1768 target = stream->EnsureSpace(target);
1769 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_lend(), target);
1770 }
1771
1772 // optional uint32 nents = 4;
1773 if (cached_has_bits & 0x00000008u) {
1774 target = stream->EnsureSpace(target);
1775 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(4, this->_internal_nents(), target);
1776 }
1777
1778 // optional int32 ret = 5;
1779 if (cached_has_bits & 0x00000010u) {
1780 target = stream->EnsureSpace(target);
1781 target = ::_pbi::WireFormatLite::WriteInt32ToArray(5, this->_internal_ret(), target);
1782 }
1783
1784 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1785 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1786 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1787 }
1788 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.TrustyShareMemoryDoneFtraceEvent)
1789 return target;
1790 }
1791
ByteSizeLong() const1792 size_t TrustyShareMemoryDoneFtraceEvent::ByteSizeLong() const {
1793 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.TrustyShareMemoryDoneFtraceEvent)
1794 size_t total_size = 0;
1795
1796 ::uint32_t cached_has_bits = 0;
1797 // Prevent compiler warnings about cached_has_bits being unused
1798 (void) cached_has_bits;
1799
1800 cached_has_bits = _impl_._has_bits_[0];
1801 if (cached_has_bits & 0x0000001fu) {
1802 // optional uint64 handle = 1;
1803 if (cached_has_bits & 0x00000001u) {
1804 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_handle());
1805 }
1806
1807 // optional uint64 len = 2;
1808 if (cached_has_bits & 0x00000002u) {
1809 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_len());
1810 }
1811
1812 // optional uint32 lend = 3;
1813 if (cached_has_bits & 0x00000004u) {
1814 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_lend());
1815 }
1816
1817 // optional uint32 nents = 4;
1818 if (cached_has_bits & 0x00000008u) {
1819 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_nents());
1820 }
1821
1822 // optional int32 ret = 5;
1823 if (cached_has_bits & 0x00000010u) {
1824 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_ret());
1825 }
1826
1827 }
1828 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1829 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1830 }
1831 int cached_size = ::_pbi::ToCachedSize(total_size);
1832 SetCachedSize(cached_size);
1833 return total_size;
1834 }
1835
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1836 void TrustyShareMemoryDoneFtraceEvent::CheckTypeAndMergeFrom(
1837 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1838 MergeFrom(*::_pbi::DownCast<const TrustyShareMemoryDoneFtraceEvent*>(
1839 &from));
1840 }
1841
MergeFrom(const TrustyShareMemoryDoneFtraceEvent & from)1842 void TrustyShareMemoryDoneFtraceEvent::MergeFrom(const TrustyShareMemoryDoneFtraceEvent& from) {
1843 TrustyShareMemoryDoneFtraceEvent* const _this = this;
1844 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.TrustyShareMemoryDoneFtraceEvent)
1845 GOOGLE_DCHECK_NE(&from, _this);
1846 ::uint32_t cached_has_bits = 0;
1847 (void) cached_has_bits;
1848
1849 cached_has_bits = from._impl_._has_bits_[0];
1850 if (cached_has_bits & 0x0000001fu) {
1851 if (cached_has_bits & 0x00000001u) {
1852 _this->_impl_.handle_ = from._impl_.handle_;
1853 }
1854 if (cached_has_bits & 0x00000002u) {
1855 _this->_impl_.len_ = from._impl_.len_;
1856 }
1857 if (cached_has_bits & 0x00000004u) {
1858 _this->_impl_.lend_ = from._impl_.lend_;
1859 }
1860 if (cached_has_bits & 0x00000008u) {
1861 _this->_impl_.nents_ = from._impl_.nents_;
1862 }
1863 if (cached_has_bits & 0x00000010u) {
1864 _this->_impl_.ret_ = from._impl_.ret_;
1865 }
1866 _this->_impl_._has_bits_[0] |= cached_has_bits;
1867 }
1868 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1869 }
1870
CopyFrom(const TrustyShareMemoryDoneFtraceEvent & from)1871 void TrustyShareMemoryDoneFtraceEvent::CopyFrom(const TrustyShareMemoryDoneFtraceEvent& from) {
1872 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.TrustyShareMemoryDoneFtraceEvent)
1873 if (&from == this) return;
1874 Clear();
1875 MergeFrom(from);
1876 }
1877
IsInitialized() const1878 bool TrustyShareMemoryDoneFtraceEvent::IsInitialized() const {
1879 return true;
1880 }
1881
InternalSwap(TrustyShareMemoryDoneFtraceEvent * other)1882 void TrustyShareMemoryDoneFtraceEvent::InternalSwap(TrustyShareMemoryDoneFtraceEvent* other) {
1883 using std::swap;
1884 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1885 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
1886 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
1887 PROTOBUF_FIELD_OFFSET(TrustyShareMemoryDoneFtraceEvent, _impl_.ret_)
1888 + sizeof(TrustyShareMemoryDoneFtraceEvent::_impl_.ret_) // NOLINT
1889 - PROTOBUF_FIELD_OFFSET(TrustyShareMemoryDoneFtraceEvent, _impl_.handle_)>(
1890 reinterpret_cast<char*>(&_impl_.handle_),
1891 reinterpret_cast<char*>(&other->_impl_.handle_));
1892 }
1893
GetTypeName() const1894 std::string TrustyShareMemoryDoneFtraceEvent::GetTypeName() const {
1895 return "perfetto.protos.TrustyShareMemoryDoneFtraceEvent";
1896 }
1897
1898
1899 // ===================================================================
1900
1901 class TrustyReclaimMemoryFtraceEvent::_Internal {
1902 public:
1903 using HasBits = decltype(std::declval<TrustyReclaimMemoryFtraceEvent>()._impl_._has_bits_);
set_has_id(HasBits * has_bits)1904 static void set_has_id(HasBits* has_bits) {
1905 (*has_bits)[0] |= 1u;
1906 }
1907 };
1908
TrustyReclaimMemoryFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1909 TrustyReclaimMemoryFtraceEvent::TrustyReclaimMemoryFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1910 bool is_message_owned)
1911 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1912 SharedCtor(arena, is_message_owned);
1913 // @@protoc_insertion_point(arena_constructor:perfetto.protos.TrustyReclaimMemoryFtraceEvent)
1914 }
TrustyReclaimMemoryFtraceEvent(const TrustyReclaimMemoryFtraceEvent & from)1915 TrustyReclaimMemoryFtraceEvent::TrustyReclaimMemoryFtraceEvent(const TrustyReclaimMemoryFtraceEvent& from)
1916 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1917 TrustyReclaimMemoryFtraceEvent* const _this = this; (void)_this;
1918 new (&_impl_) Impl_{
1919 decltype(_impl_._has_bits_){from._impl_._has_bits_}
1920 , /*decltype(_impl_._cached_size_)*/{}
1921 , decltype(_impl_.id_){}};
1922
1923 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1924 _this->_impl_.id_ = from._impl_.id_;
1925 // @@protoc_insertion_point(copy_constructor:perfetto.protos.TrustyReclaimMemoryFtraceEvent)
1926 }
1927
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1928 inline void TrustyReclaimMemoryFtraceEvent::SharedCtor(
1929 ::_pb::Arena* arena, bool is_message_owned) {
1930 (void)arena;
1931 (void)is_message_owned;
1932 new (&_impl_) Impl_{
1933 decltype(_impl_._has_bits_){}
1934 , /*decltype(_impl_._cached_size_)*/{}
1935 , decltype(_impl_.id_){::uint64_t{0u}}
1936 };
1937 }
1938
~TrustyReclaimMemoryFtraceEvent()1939 TrustyReclaimMemoryFtraceEvent::~TrustyReclaimMemoryFtraceEvent() {
1940 // @@protoc_insertion_point(destructor:perfetto.protos.TrustyReclaimMemoryFtraceEvent)
1941 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1942 (void)arena;
1943 return;
1944 }
1945 SharedDtor();
1946 }
1947
SharedDtor()1948 inline void TrustyReclaimMemoryFtraceEvent::SharedDtor() {
1949 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1950 }
1951
SetCachedSize(int size) const1952 void TrustyReclaimMemoryFtraceEvent::SetCachedSize(int size) const {
1953 _impl_._cached_size_.Set(size);
1954 }
1955
Clear()1956 void TrustyReclaimMemoryFtraceEvent::Clear() {
1957 // @@protoc_insertion_point(message_clear_start:perfetto.protos.TrustyReclaimMemoryFtraceEvent)
1958 ::uint32_t cached_has_bits = 0;
1959 // Prevent compiler warnings about cached_has_bits being unused
1960 (void) cached_has_bits;
1961
1962 _impl_.id_ = ::uint64_t{0u};
1963 _impl_._has_bits_.Clear();
1964 _internal_metadata_.Clear<std::string>();
1965 }
1966
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1967 const char* TrustyReclaimMemoryFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1968 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1969 _Internal::HasBits has_bits{};
1970 while (!ctx->Done(&ptr)) {
1971 ::uint32_t tag;
1972 ptr = ::_pbi::ReadTag(ptr, &tag);
1973 switch (tag >> 3) {
1974 // optional uint64 id = 1;
1975 case 1:
1976 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
1977 _Internal::set_has_id(&has_bits);
1978 _impl_.id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1979 CHK_(ptr);
1980 } else {
1981 goto handle_unusual;
1982 }
1983 continue;
1984 default:
1985 goto handle_unusual;
1986 } // switch
1987 handle_unusual:
1988 if ((tag == 0) || ((tag & 7) == 4)) {
1989 CHK_(ptr);
1990 ctx->SetLastTag(tag);
1991 goto message_done;
1992 }
1993 ptr = UnknownFieldParse(
1994 tag,
1995 _internal_metadata_.mutable_unknown_fields<std::string>(),
1996 ptr, ctx);
1997 CHK_(ptr != nullptr);
1998 } // while
1999 message_done:
2000 _impl_._has_bits_.Or(has_bits);
2001 return ptr;
2002 failure:
2003 ptr = nullptr;
2004 goto message_done;
2005 #undef CHK_
2006 }
2007
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const2008 ::uint8_t* TrustyReclaimMemoryFtraceEvent::_InternalSerialize(
2009 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
2010 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.TrustyReclaimMemoryFtraceEvent)
2011 ::uint32_t cached_has_bits = 0;
2012 (void) cached_has_bits;
2013
2014 cached_has_bits = _impl_._has_bits_[0];
2015 // optional uint64 id = 1;
2016 if (cached_has_bits & 0x00000001u) {
2017 target = stream->EnsureSpace(target);
2018 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_id(), target);
2019 }
2020
2021 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2022 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
2023 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
2024 }
2025 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.TrustyReclaimMemoryFtraceEvent)
2026 return target;
2027 }
2028
ByteSizeLong() const2029 size_t TrustyReclaimMemoryFtraceEvent::ByteSizeLong() const {
2030 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.TrustyReclaimMemoryFtraceEvent)
2031 size_t total_size = 0;
2032
2033 ::uint32_t cached_has_bits = 0;
2034 // Prevent compiler warnings about cached_has_bits being unused
2035 (void) cached_has_bits;
2036
2037 // optional uint64 id = 1;
2038 cached_has_bits = _impl_._has_bits_[0];
2039 if (cached_has_bits & 0x00000001u) {
2040 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_id());
2041 }
2042
2043 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2044 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
2045 }
2046 int cached_size = ::_pbi::ToCachedSize(total_size);
2047 SetCachedSize(cached_size);
2048 return total_size;
2049 }
2050
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)2051 void TrustyReclaimMemoryFtraceEvent::CheckTypeAndMergeFrom(
2052 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
2053 MergeFrom(*::_pbi::DownCast<const TrustyReclaimMemoryFtraceEvent*>(
2054 &from));
2055 }
2056
MergeFrom(const TrustyReclaimMemoryFtraceEvent & from)2057 void TrustyReclaimMemoryFtraceEvent::MergeFrom(const TrustyReclaimMemoryFtraceEvent& from) {
2058 TrustyReclaimMemoryFtraceEvent* const _this = this;
2059 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.TrustyReclaimMemoryFtraceEvent)
2060 GOOGLE_DCHECK_NE(&from, _this);
2061 ::uint32_t cached_has_bits = 0;
2062 (void) cached_has_bits;
2063
2064 if (from._internal_has_id()) {
2065 _this->_internal_set_id(from._internal_id());
2066 }
2067 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2068 }
2069
CopyFrom(const TrustyReclaimMemoryFtraceEvent & from)2070 void TrustyReclaimMemoryFtraceEvent::CopyFrom(const TrustyReclaimMemoryFtraceEvent& from) {
2071 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.TrustyReclaimMemoryFtraceEvent)
2072 if (&from == this) return;
2073 Clear();
2074 MergeFrom(from);
2075 }
2076
IsInitialized() const2077 bool TrustyReclaimMemoryFtraceEvent::IsInitialized() const {
2078 return true;
2079 }
2080
InternalSwap(TrustyReclaimMemoryFtraceEvent * other)2081 void TrustyReclaimMemoryFtraceEvent::InternalSwap(TrustyReclaimMemoryFtraceEvent* other) {
2082 using std::swap;
2083 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2084 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
2085 swap(_impl_.id_, other->_impl_.id_);
2086 }
2087
GetTypeName() const2088 std::string TrustyReclaimMemoryFtraceEvent::GetTypeName() const {
2089 return "perfetto.protos.TrustyReclaimMemoryFtraceEvent";
2090 }
2091
2092
2093 // ===================================================================
2094
2095 class TrustyReclaimMemoryDoneFtraceEvent::_Internal {
2096 public:
2097 using HasBits = decltype(std::declval<TrustyReclaimMemoryDoneFtraceEvent>()._impl_._has_bits_);
set_has_id(HasBits * has_bits)2098 static void set_has_id(HasBits* has_bits) {
2099 (*has_bits)[0] |= 1u;
2100 }
set_has_ret(HasBits * has_bits)2101 static void set_has_ret(HasBits* has_bits) {
2102 (*has_bits)[0] |= 2u;
2103 }
2104 };
2105
TrustyReclaimMemoryDoneFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)2106 TrustyReclaimMemoryDoneFtraceEvent::TrustyReclaimMemoryDoneFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2107 bool is_message_owned)
2108 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
2109 SharedCtor(arena, is_message_owned);
2110 // @@protoc_insertion_point(arena_constructor:perfetto.protos.TrustyReclaimMemoryDoneFtraceEvent)
2111 }
TrustyReclaimMemoryDoneFtraceEvent(const TrustyReclaimMemoryDoneFtraceEvent & from)2112 TrustyReclaimMemoryDoneFtraceEvent::TrustyReclaimMemoryDoneFtraceEvent(const TrustyReclaimMemoryDoneFtraceEvent& from)
2113 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
2114 TrustyReclaimMemoryDoneFtraceEvent* const _this = this; (void)_this;
2115 new (&_impl_) Impl_{
2116 decltype(_impl_._has_bits_){from._impl_._has_bits_}
2117 , /*decltype(_impl_._cached_size_)*/{}
2118 , decltype(_impl_.id_){}
2119 , decltype(_impl_.ret_){}};
2120
2121 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2122 ::memcpy(&_impl_.id_, &from._impl_.id_,
2123 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.ret_) -
2124 reinterpret_cast<char*>(&_impl_.id_)) + sizeof(_impl_.ret_));
2125 // @@protoc_insertion_point(copy_constructor:perfetto.protos.TrustyReclaimMemoryDoneFtraceEvent)
2126 }
2127
SharedCtor(::_pb::Arena * arena,bool is_message_owned)2128 inline void TrustyReclaimMemoryDoneFtraceEvent::SharedCtor(
2129 ::_pb::Arena* arena, bool is_message_owned) {
2130 (void)arena;
2131 (void)is_message_owned;
2132 new (&_impl_) Impl_{
2133 decltype(_impl_._has_bits_){}
2134 , /*decltype(_impl_._cached_size_)*/{}
2135 , decltype(_impl_.id_){::uint64_t{0u}}
2136 , decltype(_impl_.ret_){0}
2137 };
2138 }
2139
~TrustyReclaimMemoryDoneFtraceEvent()2140 TrustyReclaimMemoryDoneFtraceEvent::~TrustyReclaimMemoryDoneFtraceEvent() {
2141 // @@protoc_insertion_point(destructor:perfetto.protos.TrustyReclaimMemoryDoneFtraceEvent)
2142 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
2143 (void)arena;
2144 return;
2145 }
2146 SharedDtor();
2147 }
2148
SharedDtor()2149 inline void TrustyReclaimMemoryDoneFtraceEvent::SharedDtor() {
2150 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
2151 }
2152
SetCachedSize(int size) const2153 void TrustyReclaimMemoryDoneFtraceEvent::SetCachedSize(int size) const {
2154 _impl_._cached_size_.Set(size);
2155 }
2156
Clear()2157 void TrustyReclaimMemoryDoneFtraceEvent::Clear() {
2158 // @@protoc_insertion_point(message_clear_start:perfetto.protos.TrustyReclaimMemoryDoneFtraceEvent)
2159 ::uint32_t cached_has_bits = 0;
2160 // Prevent compiler warnings about cached_has_bits being unused
2161 (void) cached_has_bits;
2162
2163 cached_has_bits = _impl_._has_bits_[0];
2164 if (cached_has_bits & 0x00000003u) {
2165 ::memset(&_impl_.id_, 0, static_cast<size_t>(
2166 reinterpret_cast<char*>(&_impl_.ret_) -
2167 reinterpret_cast<char*>(&_impl_.id_)) + sizeof(_impl_.ret_));
2168 }
2169 _impl_._has_bits_.Clear();
2170 _internal_metadata_.Clear<std::string>();
2171 }
2172
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)2173 const char* TrustyReclaimMemoryDoneFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
2174 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
2175 _Internal::HasBits has_bits{};
2176 while (!ctx->Done(&ptr)) {
2177 ::uint32_t tag;
2178 ptr = ::_pbi::ReadTag(ptr, &tag);
2179 switch (tag >> 3) {
2180 // optional uint64 id = 1;
2181 case 1:
2182 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
2183 _Internal::set_has_id(&has_bits);
2184 _impl_.id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
2185 CHK_(ptr);
2186 } else {
2187 goto handle_unusual;
2188 }
2189 continue;
2190 // optional int32 ret = 2;
2191 case 2:
2192 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
2193 _Internal::set_has_ret(&has_bits);
2194 _impl_.ret_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
2195 CHK_(ptr);
2196 } else {
2197 goto handle_unusual;
2198 }
2199 continue;
2200 default:
2201 goto handle_unusual;
2202 } // switch
2203 handle_unusual:
2204 if ((tag == 0) || ((tag & 7) == 4)) {
2205 CHK_(ptr);
2206 ctx->SetLastTag(tag);
2207 goto message_done;
2208 }
2209 ptr = UnknownFieldParse(
2210 tag,
2211 _internal_metadata_.mutable_unknown_fields<std::string>(),
2212 ptr, ctx);
2213 CHK_(ptr != nullptr);
2214 } // while
2215 message_done:
2216 _impl_._has_bits_.Or(has_bits);
2217 return ptr;
2218 failure:
2219 ptr = nullptr;
2220 goto message_done;
2221 #undef CHK_
2222 }
2223
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const2224 ::uint8_t* TrustyReclaimMemoryDoneFtraceEvent::_InternalSerialize(
2225 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
2226 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.TrustyReclaimMemoryDoneFtraceEvent)
2227 ::uint32_t cached_has_bits = 0;
2228 (void) cached_has_bits;
2229
2230 cached_has_bits = _impl_._has_bits_[0];
2231 // optional uint64 id = 1;
2232 if (cached_has_bits & 0x00000001u) {
2233 target = stream->EnsureSpace(target);
2234 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_id(), target);
2235 }
2236
2237 // optional int32 ret = 2;
2238 if (cached_has_bits & 0x00000002u) {
2239 target = stream->EnsureSpace(target);
2240 target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_ret(), target);
2241 }
2242
2243 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2244 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
2245 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
2246 }
2247 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.TrustyReclaimMemoryDoneFtraceEvent)
2248 return target;
2249 }
2250
ByteSizeLong() const2251 size_t TrustyReclaimMemoryDoneFtraceEvent::ByteSizeLong() const {
2252 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.TrustyReclaimMemoryDoneFtraceEvent)
2253 size_t total_size = 0;
2254
2255 ::uint32_t cached_has_bits = 0;
2256 // Prevent compiler warnings about cached_has_bits being unused
2257 (void) cached_has_bits;
2258
2259 cached_has_bits = _impl_._has_bits_[0];
2260 if (cached_has_bits & 0x00000003u) {
2261 // optional uint64 id = 1;
2262 if (cached_has_bits & 0x00000001u) {
2263 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_id());
2264 }
2265
2266 // optional int32 ret = 2;
2267 if (cached_has_bits & 0x00000002u) {
2268 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_ret());
2269 }
2270
2271 }
2272 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2273 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
2274 }
2275 int cached_size = ::_pbi::ToCachedSize(total_size);
2276 SetCachedSize(cached_size);
2277 return total_size;
2278 }
2279
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)2280 void TrustyReclaimMemoryDoneFtraceEvent::CheckTypeAndMergeFrom(
2281 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
2282 MergeFrom(*::_pbi::DownCast<const TrustyReclaimMemoryDoneFtraceEvent*>(
2283 &from));
2284 }
2285
MergeFrom(const TrustyReclaimMemoryDoneFtraceEvent & from)2286 void TrustyReclaimMemoryDoneFtraceEvent::MergeFrom(const TrustyReclaimMemoryDoneFtraceEvent& from) {
2287 TrustyReclaimMemoryDoneFtraceEvent* const _this = this;
2288 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.TrustyReclaimMemoryDoneFtraceEvent)
2289 GOOGLE_DCHECK_NE(&from, _this);
2290 ::uint32_t cached_has_bits = 0;
2291 (void) cached_has_bits;
2292
2293 cached_has_bits = from._impl_._has_bits_[0];
2294 if (cached_has_bits & 0x00000003u) {
2295 if (cached_has_bits & 0x00000001u) {
2296 _this->_impl_.id_ = from._impl_.id_;
2297 }
2298 if (cached_has_bits & 0x00000002u) {
2299 _this->_impl_.ret_ = from._impl_.ret_;
2300 }
2301 _this->_impl_._has_bits_[0] |= cached_has_bits;
2302 }
2303 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2304 }
2305
CopyFrom(const TrustyReclaimMemoryDoneFtraceEvent & from)2306 void TrustyReclaimMemoryDoneFtraceEvent::CopyFrom(const TrustyReclaimMemoryDoneFtraceEvent& from) {
2307 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.TrustyReclaimMemoryDoneFtraceEvent)
2308 if (&from == this) return;
2309 Clear();
2310 MergeFrom(from);
2311 }
2312
IsInitialized() const2313 bool TrustyReclaimMemoryDoneFtraceEvent::IsInitialized() const {
2314 return true;
2315 }
2316
InternalSwap(TrustyReclaimMemoryDoneFtraceEvent * other)2317 void TrustyReclaimMemoryDoneFtraceEvent::InternalSwap(TrustyReclaimMemoryDoneFtraceEvent* other) {
2318 using std::swap;
2319 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2320 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
2321 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
2322 PROTOBUF_FIELD_OFFSET(TrustyReclaimMemoryDoneFtraceEvent, _impl_.ret_)
2323 + sizeof(TrustyReclaimMemoryDoneFtraceEvent::_impl_.ret_) // NOLINT
2324 - PROTOBUF_FIELD_OFFSET(TrustyReclaimMemoryDoneFtraceEvent, _impl_.id_)>(
2325 reinterpret_cast<char*>(&_impl_.id_),
2326 reinterpret_cast<char*>(&other->_impl_.id_));
2327 }
2328
GetTypeName() const2329 std::string TrustyReclaimMemoryDoneFtraceEvent::GetTypeName() const {
2330 return "perfetto.protos.TrustyReclaimMemoryDoneFtraceEvent";
2331 }
2332
2333
2334 // ===================================================================
2335
2336 class TrustyIrqFtraceEvent::_Internal {
2337 public:
2338 using HasBits = decltype(std::declval<TrustyIrqFtraceEvent>()._impl_._has_bits_);
set_has_irq(HasBits * has_bits)2339 static void set_has_irq(HasBits* has_bits) {
2340 (*has_bits)[0] |= 1u;
2341 }
2342 };
2343
TrustyIrqFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)2344 TrustyIrqFtraceEvent::TrustyIrqFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2345 bool is_message_owned)
2346 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
2347 SharedCtor(arena, is_message_owned);
2348 // @@protoc_insertion_point(arena_constructor:perfetto.protos.TrustyIrqFtraceEvent)
2349 }
TrustyIrqFtraceEvent(const TrustyIrqFtraceEvent & from)2350 TrustyIrqFtraceEvent::TrustyIrqFtraceEvent(const TrustyIrqFtraceEvent& from)
2351 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
2352 TrustyIrqFtraceEvent* const _this = this; (void)_this;
2353 new (&_impl_) Impl_{
2354 decltype(_impl_._has_bits_){from._impl_._has_bits_}
2355 , /*decltype(_impl_._cached_size_)*/{}
2356 , decltype(_impl_.irq_){}};
2357
2358 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2359 _this->_impl_.irq_ = from._impl_.irq_;
2360 // @@protoc_insertion_point(copy_constructor:perfetto.protos.TrustyIrqFtraceEvent)
2361 }
2362
SharedCtor(::_pb::Arena * arena,bool is_message_owned)2363 inline void TrustyIrqFtraceEvent::SharedCtor(
2364 ::_pb::Arena* arena, bool is_message_owned) {
2365 (void)arena;
2366 (void)is_message_owned;
2367 new (&_impl_) Impl_{
2368 decltype(_impl_._has_bits_){}
2369 , /*decltype(_impl_._cached_size_)*/{}
2370 , decltype(_impl_.irq_){0}
2371 };
2372 }
2373
~TrustyIrqFtraceEvent()2374 TrustyIrqFtraceEvent::~TrustyIrqFtraceEvent() {
2375 // @@protoc_insertion_point(destructor:perfetto.protos.TrustyIrqFtraceEvent)
2376 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
2377 (void)arena;
2378 return;
2379 }
2380 SharedDtor();
2381 }
2382
SharedDtor()2383 inline void TrustyIrqFtraceEvent::SharedDtor() {
2384 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
2385 }
2386
SetCachedSize(int size) const2387 void TrustyIrqFtraceEvent::SetCachedSize(int size) const {
2388 _impl_._cached_size_.Set(size);
2389 }
2390
Clear()2391 void TrustyIrqFtraceEvent::Clear() {
2392 // @@protoc_insertion_point(message_clear_start:perfetto.protos.TrustyIrqFtraceEvent)
2393 ::uint32_t cached_has_bits = 0;
2394 // Prevent compiler warnings about cached_has_bits being unused
2395 (void) cached_has_bits;
2396
2397 _impl_.irq_ = 0;
2398 _impl_._has_bits_.Clear();
2399 _internal_metadata_.Clear<std::string>();
2400 }
2401
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)2402 const char* TrustyIrqFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
2403 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
2404 _Internal::HasBits has_bits{};
2405 while (!ctx->Done(&ptr)) {
2406 ::uint32_t tag;
2407 ptr = ::_pbi::ReadTag(ptr, &tag);
2408 switch (tag >> 3) {
2409 // optional int32 irq = 1;
2410 case 1:
2411 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
2412 _Internal::set_has_irq(&has_bits);
2413 _impl_.irq_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
2414 CHK_(ptr);
2415 } else {
2416 goto handle_unusual;
2417 }
2418 continue;
2419 default:
2420 goto handle_unusual;
2421 } // switch
2422 handle_unusual:
2423 if ((tag == 0) || ((tag & 7) == 4)) {
2424 CHK_(ptr);
2425 ctx->SetLastTag(tag);
2426 goto message_done;
2427 }
2428 ptr = UnknownFieldParse(
2429 tag,
2430 _internal_metadata_.mutable_unknown_fields<std::string>(),
2431 ptr, ctx);
2432 CHK_(ptr != nullptr);
2433 } // while
2434 message_done:
2435 _impl_._has_bits_.Or(has_bits);
2436 return ptr;
2437 failure:
2438 ptr = nullptr;
2439 goto message_done;
2440 #undef CHK_
2441 }
2442
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const2443 ::uint8_t* TrustyIrqFtraceEvent::_InternalSerialize(
2444 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
2445 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.TrustyIrqFtraceEvent)
2446 ::uint32_t cached_has_bits = 0;
2447 (void) cached_has_bits;
2448
2449 cached_has_bits = _impl_._has_bits_[0];
2450 // optional int32 irq = 1;
2451 if (cached_has_bits & 0x00000001u) {
2452 target = stream->EnsureSpace(target);
2453 target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_irq(), target);
2454 }
2455
2456 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2457 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
2458 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
2459 }
2460 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.TrustyIrqFtraceEvent)
2461 return target;
2462 }
2463
ByteSizeLong() const2464 size_t TrustyIrqFtraceEvent::ByteSizeLong() const {
2465 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.TrustyIrqFtraceEvent)
2466 size_t total_size = 0;
2467
2468 ::uint32_t cached_has_bits = 0;
2469 // Prevent compiler warnings about cached_has_bits being unused
2470 (void) cached_has_bits;
2471
2472 // optional int32 irq = 1;
2473 cached_has_bits = _impl_._has_bits_[0];
2474 if (cached_has_bits & 0x00000001u) {
2475 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_irq());
2476 }
2477
2478 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2479 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
2480 }
2481 int cached_size = ::_pbi::ToCachedSize(total_size);
2482 SetCachedSize(cached_size);
2483 return total_size;
2484 }
2485
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)2486 void TrustyIrqFtraceEvent::CheckTypeAndMergeFrom(
2487 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
2488 MergeFrom(*::_pbi::DownCast<const TrustyIrqFtraceEvent*>(
2489 &from));
2490 }
2491
MergeFrom(const TrustyIrqFtraceEvent & from)2492 void TrustyIrqFtraceEvent::MergeFrom(const TrustyIrqFtraceEvent& from) {
2493 TrustyIrqFtraceEvent* const _this = this;
2494 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.TrustyIrqFtraceEvent)
2495 GOOGLE_DCHECK_NE(&from, _this);
2496 ::uint32_t cached_has_bits = 0;
2497 (void) cached_has_bits;
2498
2499 if (from._internal_has_irq()) {
2500 _this->_internal_set_irq(from._internal_irq());
2501 }
2502 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2503 }
2504
CopyFrom(const TrustyIrqFtraceEvent & from)2505 void TrustyIrqFtraceEvent::CopyFrom(const TrustyIrqFtraceEvent& from) {
2506 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.TrustyIrqFtraceEvent)
2507 if (&from == this) return;
2508 Clear();
2509 MergeFrom(from);
2510 }
2511
IsInitialized() const2512 bool TrustyIrqFtraceEvent::IsInitialized() const {
2513 return true;
2514 }
2515
InternalSwap(TrustyIrqFtraceEvent * other)2516 void TrustyIrqFtraceEvent::InternalSwap(TrustyIrqFtraceEvent* other) {
2517 using std::swap;
2518 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2519 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
2520 swap(_impl_.irq_, other->_impl_.irq_);
2521 }
2522
GetTypeName() const2523 std::string TrustyIrqFtraceEvent::GetTypeName() const {
2524 return "perfetto.protos.TrustyIrqFtraceEvent";
2525 }
2526
2527
2528 // ===================================================================
2529
2530 class TrustyIpcHandleEventFtraceEvent::_Internal {
2531 public:
2532 using HasBits = decltype(std::declval<TrustyIpcHandleEventFtraceEvent>()._impl_._has_bits_);
set_has_chan(HasBits * has_bits)2533 static void set_has_chan(HasBits* has_bits) {
2534 (*has_bits)[0] |= 2u;
2535 }
set_has_event_id(HasBits * has_bits)2536 static void set_has_event_id(HasBits* has_bits) {
2537 (*has_bits)[0] |= 4u;
2538 }
set_has_srv_name(HasBits * has_bits)2539 static void set_has_srv_name(HasBits* has_bits) {
2540 (*has_bits)[0] |= 1u;
2541 }
2542 };
2543
TrustyIpcHandleEventFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)2544 TrustyIpcHandleEventFtraceEvent::TrustyIpcHandleEventFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2545 bool is_message_owned)
2546 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
2547 SharedCtor(arena, is_message_owned);
2548 // @@protoc_insertion_point(arena_constructor:perfetto.protos.TrustyIpcHandleEventFtraceEvent)
2549 }
TrustyIpcHandleEventFtraceEvent(const TrustyIpcHandleEventFtraceEvent & from)2550 TrustyIpcHandleEventFtraceEvent::TrustyIpcHandleEventFtraceEvent(const TrustyIpcHandleEventFtraceEvent& from)
2551 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
2552 TrustyIpcHandleEventFtraceEvent* const _this = this; (void)_this;
2553 new (&_impl_) Impl_{
2554 decltype(_impl_._has_bits_){from._impl_._has_bits_}
2555 , /*decltype(_impl_._cached_size_)*/{}
2556 , decltype(_impl_.srv_name_){}
2557 , decltype(_impl_.chan_){}
2558 , decltype(_impl_.event_id_){}};
2559
2560 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2561 _impl_.srv_name_.InitDefault();
2562 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2563 _impl_.srv_name_.Set("", GetArenaForAllocation());
2564 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2565 if (from._internal_has_srv_name()) {
2566 _this->_impl_.srv_name_.Set(from._internal_srv_name(),
2567 _this->GetArenaForAllocation());
2568 }
2569 ::memcpy(&_impl_.chan_, &from._impl_.chan_,
2570 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.event_id_) -
2571 reinterpret_cast<char*>(&_impl_.chan_)) + sizeof(_impl_.event_id_));
2572 // @@protoc_insertion_point(copy_constructor:perfetto.protos.TrustyIpcHandleEventFtraceEvent)
2573 }
2574
SharedCtor(::_pb::Arena * arena,bool is_message_owned)2575 inline void TrustyIpcHandleEventFtraceEvent::SharedCtor(
2576 ::_pb::Arena* arena, bool is_message_owned) {
2577 (void)arena;
2578 (void)is_message_owned;
2579 new (&_impl_) Impl_{
2580 decltype(_impl_._has_bits_){}
2581 , /*decltype(_impl_._cached_size_)*/{}
2582 , decltype(_impl_.srv_name_){}
2583 , decltype(_impl_.chan_){0u}
2584 , decltype(_impl_.event_id_){0u}
2585 };
2586 _impl_.srv_name_.InitDefault();
2587 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2588 _impl_.srv_name_.Set("", GetArenaForAllocation());
2589 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2590 }
2591
~TrustyIpcHandleEventFtraceEvent()2592 TrustyIpcHandleEventFtraceEvent::~TrustyIpcHandleEventFtraceEvent() {
2593 // @@protoc_insertion_point(destructor:perfetto.protos.TrustyIpcHandleEventFtraceEvent)
2594 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
2595 (void)arena;
2596 return;
2597 }
2598 SharedDtor();
2599 }
2600
SharedDtor()2601 inline void TrustyIpcHandleEventFtraceEvent::SharedDtor() {
2602 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
2603 _impl_.srv_name_.Destroy();
2604 }
2605
SetCachedSize(int size) const2606 void TrustyIpcHandleEventFtraceEvent::SetCachedSize(int size) const {
2607 _impl_._cached_size_.Set(size);
2608 }
2609
Clear()2610 void TrustyIpcHandleEventFtraceEvent::Clear() {
2611 // @@protoc_insertion_point(message_clear_start:perfetto.protos.TrustyIpcHandleEventFtraceEvent)
2612 ::uint32_t cached_has_bits = 0;
2613 // Prevent compiler warnings about cached_has_bits being unused
2614 (void) cached_has_bits;
2615
2616 cached_has_bits = _impl_._has_bits_[0];
2617 if (cached_has_bits & 0x00000001u) {
2618 _impl_.srv_name_.ClearNonDefaultToEmpty();
2619 }
2620 if (cached_has_bits & 0x00000006u) {
2621 ::memset(&_impl_.chan_, 0, static_cast<size_t>(
2622 reinterpret_cast<char*>(&_impl_.event_id_) -
2623 reinterpret_cast<char*>(&_impl_.chan_)) + sizeof(_impl_.event_id_));
2624 }
2625 _impl_._has_bits_.Clear();
2626 _internal_metadata_.Clear<std::string>();
2627 }
2628
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)2629 const char* TrustyIpcHandleEventFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
2630 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
2631 _Internal::HasBits has_bits{};
2632 while (!ctx->Done(&ptr)) {
2633 ::uint32_t tag;
2634 ptr = ::_pbi::ReadTag(ptr, &tag);
2635 switch (tag >> 3) {
2636 // optional uint32 chan = 1;
2637 case 1:
2638 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
2639 _Internal::set_has_chan(&has_bits);
2640 _impl_.chan_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
2641 CHK_(ptr);
2642 } else {
2643 goto handle_unusual;
2644 }
2645 continue;
2646 // optional uint32 event_id = 2;
2647 case 2:
2648 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
2649 _Internal::set_has_event_id(&has_bits);
2650 _impl_.event_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
2651 CHK_(ptr);
2652 } else {
2653 goto handle_unusual;
2654 }
2655 continue;
2656 // optional string srv_name = 3;
2657 case 3:
2658 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
2659 auto str = _internal_mutable_srv_name();
2660 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
2661 CHK_(ptr);
2662 } else {
2663 goto handle_unusual;
2664 }
2665 continue;
2666 default:
2667 goto handle_unusual;
2668 } // switch
2669 handle_unusual:
2670 if ((tag == 0) || ((tag & 7) == 4)) {
2671 CHK_(ptr);
2672 ctx->SetLastTag(tag);
2673 goto message_done;
2674 }
2675 ptr = UnknownFieldParse(
2676 tag,
2677 _internal_metadata_.mutable_unknown_fields<std::string>(),
2678 ptr, ctx);
2679 CHK_(ptr != nullptr);
2680 } // while
2681 message_done:
2682 _impl_._has_bits_.Or(has_bits);
2683 return ptr;
2684 failure:
2685 ptr = nullptr;
2686 goto message_done;
2687 #undef CHK_
2688 }
2689
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const2690 ::uint8_t* TrustyIpcHandleEventFtraceEvent::_InternalSerialize(
2691 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
2692 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.TrustyIpcHandleEventFtraceEvent)
2693 ::uint32_t cached_has_bits = 0;
2694 (void) cached_has_bits;
2695
2696 cached_has_bits = _impl_._has_bits_[0];
2697 // optional uint32 chan = 1;
2698 if (cached_has_bits & 0x00000002u) {
2699 target = stream->EnsureSpace(target);
2700 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_chan(), target);
2701 }
2702
2703 // optional uint32 event_id = 2;
2704 if (cached_has_bits & 0x00000004u) {
2705 target = stream->EnsureSpace(target);
2706 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_event_id(), target);
2707 }
2708
2709 // optional string srv_name = 3;
2710 if (cached_has_bits & 0x00000001u) {
2711 target = stream->WriteStringMaybeAliased(
2712 3, this->_internal_srv_name(), target);
2713 }
2714
2715 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2716 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
2717 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
2718 }
2719 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.TrustyIpcHandleEventFtraceEvent)
2720 return target;
2721 }
2722
ByteSizeLong() const2723 size_t TrustyIpcHandleEventFtraceEvent::ByteSizeLong() const {
2724 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.TrustyIpcHandleEventFtraceEvent)
2725 size_t total_size = 0;
2726
2727 ::uint32_t cached_has_bits = 0;
2728 // Prevent compiler warnings about cached_has_bits being unused
2729 (void) cached_has_bits;
2730
2731 cached_has_bits = _impl_._has_bits_[0];
2732 if (cached_has_bits & 0x00000007u) {
2733 // optional string srv_name = 3;
2734 if (cached_has_bits & 0x00000001u) {
2735 total_size += 1 +
2736 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
2737 this->_internal_srv_name());
2738 }
2739
2740 // optional uint32 chan = 1;
2741 if (cached_has_bits & 0x00000002u) {
2742 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_chan());
2743 }
2744
2745 // optional uint32 event_id = 2;
2746 if (cached_has_bits & 0x00000004u) {
2747 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_event_id());
2748 }
2749
2750 }
2751 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2752 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
2753 }
2754 int cached_size = ::_pbi::ToCachedSize(total_size);
2755 SetCachedSize(cached_size);
2756 return total_size;
2757 }
2758
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)2759 void TrustyIpcHandleEventFtraceEvent::CheckTypeAndMergeFrom(
2760 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
2761 MergeFrom(*::_pbi::DownCast<const TrustyIpcHandleEventFtraceEvent*>(
2762 &from));
2763 }
2764
MergeFrom(const TrustyIpcHandleEventFtraceEvent & from)2765 void TrustyIpcHandleEventFtraceEvent::MergeFrom(const TrustyIpcHandleEventFtraceEvent& from) {
2766 TrustyIpcHandleEventFtraceEvent* const _this = this;
2767 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.TrustyIpcHandleEventFtraceEvent)
2768 GOOGLE_DCHECK_NE(&from, _this);
2769 ::uint32_t cached_has_bits = 0;
2770 (void) cached_has_bits;
2771
2772 cached_has_bits = from._impl_._has_bits_[0];
2773 if (cached_has_bits & 0x00000007u) {
2774 if (cached_has_bits & 0x00000001u) {
2775 _this->_internal_set_srv_name(from._internal_srv_name());
2776 }
2777 if (cached_has_bits & 0x00000002u) {
2778 _this->_impl_.chan_ = from._impl_.chan_;
2779 }
2780 if (cached_has_bits & 0x00000004u) {
2781 _this->_impl_.event_id_ = from._impl_.event_id_;
2782 }
2783 _this->_impl_._has_bits_[0] |= cached_has_bits;
2784 }
2785 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2786 }
2787
CopyFrom(const TrustyIpcHandleEventFtraceEvent & from)2788 void TrustyIpcHandleEventFtraceEvent::CopyFrom(const TrustyIpcHandleEventFtraceEvent& from) {
2789 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.TrustyIpcHandleEventFtraceEvent)
2790 if (&from == this) return;
2791 Clear();
2792 MergeFrom(from);
2793 }
2794
IsInitialized() const2795 bool TrustyIpcHandleEventFtraceEvent::IsInitialized() const {
2796 return true;
2797 }
2798
InternalSwap(TrustyIpcHandleEventFtraceEvent * other)2799 void TrustyIpcHandleEventFtraceEvent::InternalSwap(TrustyIpcHandleEventFtraceEvent* other) {
2800 using std::swap;
2801 auto* lhs_arena = GetArenaForAllocation();
2802 auto* rhs_arena = other->GetArenaForAllocation();
2803 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2804 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
2805 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
2806 &_impl_.srv_name_, lhs_arena,
2807 &other->_impl_.srv_name_, rhs_arena
2808 );
2809 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
2810 PROTOBUF_FIELD_OFFSET(TrustyIpcHandleEventFtraceEvent, _impl_.event_id_)
2811 + sizeof(TrustyIpcHandleEventFtraceEvent::_impl_.event_id_) // NOLINT
2812 - PROTOBUF_FIELD_OFFSET(TrustyIpcHandleEventFtraceEvent, _impl_.chan_)>(
2813 reinterpret_cast<char*>(&_impl_.chan_),
2814 reinterpret_cast<char*>(&other->_impl_.chan_));
2815 }
2816
GetTypeName() const2817 std::string TrustyIpcHandleEventFtraceEvent::GetTypeName() const {
2818 return "perfetto.protos.TrustyIpcHandleEventFtraceEvent";
2819 }
2820
2821
2822 // ===================================================================
2823
2824 class TrustyIpcConnectFtraceEvent::_Internal {
2825 public:
2826 using HasBits = decltype(std::declval<TrustyIpcConnectFtraceEvent>()._impl_._has_bits_);
set_has_chan(HasBits * has_bits)2827 static void set_has_chan(HasBits* has_bits) {
2828 (*has_bits)[0] |= 2u;
2829 }
set_has_port(HasBits * has_bits)2830 static void set_has_port(HasBits* has_bits) {
2831 (*has_bits)[0] |= 1u;
2832 }
set_has_state(HasBits * has_bits)2833 static void set_has_state(HasBits* has_bits) {
2834 (*has_bits)[0] |= 4u;
2835 }
2836 };
2837
TrustyIpcConnectFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)2838 TrustyIpcConnectFtraceEvent::TrustyIpcConnectFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2839 bool is_message_owned)
2840 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
2841 SharedCtor(arena, is_message_owned);
2842 // @@protoc_insertion_point(arena_constructor:perfetto.protos.TrustyIpcConnectFtraceEvent)
2843 }
TrustyIpcConnectFtraceEvent(const TrustyIpcConnectFtraceEvent & from)2844 TrustyIpcConnectFtraceEvent::TrustyIpcConnectFtraceEvent(const TrustyIpcConnectFtraceEvent& from)
2845 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
2846 TrustyIpcConnectFtraceEvent* const _this = this; (void)_this;
2847 new (&_impl_) Impl_{
2848 decltype(_impl_._has_bits_){from._impl_._has_bits_}
2849 , /*decltype(_impl_._cached_size_)*/{}
2850 , decltype(_impl_.port_){}
2851 , decltype(_impl_.chan_){}
2852 , decltype(_impl_.state_){}};
2853
2854 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2855 _impl_.port_.InitDefault();
2856 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2857 _impl_.port_.Set("", GetArenaForAllocation());
2858 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2859 if (from._internal_has_port()) {
2860 _this->_impl_.port_.Set(from._internal_port(),
2861 _this->GetArenaForAllocation());
2862 }
2863 ::memcpy(&_impl_.chan_, &from._impl_.chan_,
2864 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.state_) -
2865 reinterpret_cast<char*>(&_impl_.chan_)) + sizeof(_impl_.state_));
2866 // @@protoc_insertion_point(copy_constructor:perfetto.protos.TrustyIpcConnectFtraceEvent)
2867 }
2868
SharedCtor(::_pb::Arena * arena,bool is_message_owned)2869 inline void TrustyIpcConnectFtraceEvent::SharedCtor(
2870 ::_pb::Arena* arena, bool is_message_owned) {
2871 (void)arena;
2872 (void)is_message_owned;
2873 new (&_impl_) Impl_{
2874 decltype(_impl_._has_bits_){}
2875 , /*decltype(_impl_._cached_size_)*/{}
2876 , decltype(_impl_.port_){}
2877 , decltype(_impl_.chan_){0u}
2878 , decltype(_impl_.state_){0}
2879 };
2880 _impl_.port_.InitDefault();
2881 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2882 _impl_.port_.Set("", GetArenaForAllocation());
2883 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2884 }
2885
~TrustyIpcConnectFtraceEvent()2886 TrustyIpcConnectFtraceEvent::~TrustyIpcConnectFtraceEvent() {
2887 // @@protoc_insertion_point(destructor:perfetto.protos.TrustyIpcConnectFtraceEvent)
2888 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
2889 (void)arena;
2890 return;
2891 }
2892 SharedDtor();
2893 }
2894
SharedDtor()2895 inline void TrustyIpcConnectFtraceEvent::SharedDtor() {
2896 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
2897 _impl_.port_.Destroy();
2898 }
2899
SetCachedSize(int size) const2900 void TrustyIpcConnectFtraceEvent::SetCachedSize(int size) const {
2901 _impl_._cached_size_.Set(size);
2902 }
2903
Clear()2904 void TrustyIpcConnectFtraceEvent::Clear() {
2905 // @@protoc_insertion_point(message_clear_start:perfetto.protos.TrustyIpcConnectFtraceEvent)
2906 ::uint32_t cached_has_bits = 0;
2907 // Prevent compiler warnings about cached_has_bits being unused
2908 (void) cached_has_bits;
2909
2910 cached_has_bits = _impl_._has_bits_[0];
2911 if (cached_has_bits & 0x00000001u) {
2912 _impl_.port_.ClearNonDefaultToEmpty();
2913 }
2914 if (cached_has_bits & 0x00000006u) {
2915 ::memset(&_impl_.chan_, 0, static_cast<size_t>(
2916 reinterpret_cast<char*>(&_impl_.state_) -
2917 reinterpret_cast<char*>(&_impl_.chan_)) + sizeof(_impl_.state_));
2918 }
2919 _impl_._has_bits_.Clear();
2920 _internal_metadata_.Clear<std::string>();
2921 }
2922
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)2923 const char* TrustyIpcConnectFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
2924 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
2925 _Internal::HasBits has_bits{};
2926 while (!ctx->Done(&ptr)) {
2927 ::uint32_t tag;
2928 ptr = ::_pbi::ReadTag(ptr, &tag);
2929 switch (tag >> 3) {
2930 // optional uint32 chan = 1;
2931 case 1:
2932 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
2933 _Internal::set_has_chan(&has_bits);
2934 _impl_.chan_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
2935 CHK_(ptr);
2936 } else {
2937 goto handle_unusual;
2938 }
2939 continue;
2940 // optional string port = 2;
2941 case 2:
2942 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
2943 auto str = _internal_mutable_port();
2944 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
2945 CHK_(ptr);
2946 } else {
2947 goto handle_unusual;
2948 }
2949 continue;
2950 // optional int32 state = 3;
2951 case 3:
2952 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
2953 _Internal::set_has_state(&has_bits);
2954 _impl_.state_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
2955 CHK_(ptr);
2956 } else {
2957 goto handle_unusual;
2958 }
2959 continue;
2960 default:
2961 goto handle_unusual;
2962 } // switch
2963 handle_unusual:
2964 if ((tag == 0) || ((tag & 7) == 4)) {
2965 CHK_(ptr);
2966 ctx->SetLastTag(tag);
2967 goto message_done;
2968 }
2969 ptr = UnknownFieldParse(
2970 tag,
2971 _internal_metadata_.mutable_unknown_fields<std::string>(),
2972 ptr, ctx);
2973 CHK_(ptr != nullptr);
2974 } // while
2975 message_done:
2976 _impl_._has_bits_.Or(has_bits);
2977 return ptr;
2978 failure:
2979 ptr = nullptr;
2980 goto message_done;
2981 #undef CHK_
2982 }
2983
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const2984 ::uint8_t* TrustyIpcConnectFtraceEvent::_InternalSerialize(
2985 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
2986 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.TrustyIpcConnectFtraceEvent)
2987 ::uint32_t cached_has_bits = 0;
2988 (void) cached_has_bits;
2989
2990 cached_has_bits = _impl_._has_bits_[0];
2991 // optional uint32 chan = 1;
2992 if (cached_has_bits & 0x00000002u) {
2993 target = stream->EnsureSpace(target);
2994 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_chan(), target);
2995 }
2996
2997 // optional string port = 2;
2998 if (cached_has_bits & 0x00000001u) {
2999 target = stream->WriteStringMaybeAliased(
3000 2, this->_internal_port(), target);
3001 }
3002
3003 // optional int32 state = 3;
3004 if (cached_has_bits & 0x00000004u) {
3005 target = stream->EnsureSpace(target);
3006 target = ::_pbi::WireFormatLite::WriteInt32ToArray(3, this->_internal_state(), target);
3007 }
3008
3009 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
3010 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
3011 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
3012 }
3013 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.TrustyIpcConnectFtraceEvent)
3014 return target;
3015 }
3016
ByteSizeLong() const3017 size_t TrustyIpcConnectFtraceEvent::ByteSizeLong() const {
3018 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.TrustyIpcConnectFtraceEvent)
3019 size_t total_size = 0;
3020
3021 ::uint32_t cached_has_bits = 0;
3022 // Prevent compiler warnings about cached_has_bits being unused
3023 (void) cached_has_bits;
3024
3025 cached_has_bits = _impl_._has_bits_[0];
3026 if (cached_has_bits & 0x00000007u) {
3027 // optional string port = 2;
3028 if (cached_has_bits & 0x00000001u) {
3029 total_size += 1 +
3030 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
3031 this->_internal_port());
3032 }
3033
3034 // optional uint32 chan = 1;
3035 if (cached_has_bits & 0x00000002u) {
3036 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_chan());
3037 }
3038
3039 // optional int32 state = 3;
3040 if (cached_has_bits & 0x00000004u) {
3041 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_state());
3042 }
3043
3044 }
3045 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
3046 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
3047 }
3048 int cached_size = ::_pbi::ToCachedSize(total_size);
3049 SetCachedSize(cached_size);
3050 return total_size;
3051 }
3052
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)3053 void TrustyIpcConnectFtraceEvent::CheckTypeAndMergeFrom(
3054 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
3055 MergeFrom(*::_pbi::DownCast<const TrustyIpcConnectFtraceEvent*>(
3056 &from));
3057 }
3058
MergeFrom(const TrustyIpcConnectFtraceEvent & from)3059 void TrustyIpcConnectFtraceEvent::MergeFrom(const TrustyIpcConnectFtraceEvent& from) {
3060 TrustyIpcConnectFtraceEvent* const _this = this;
3061 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.TrustyIpcConnectFtraceEvent)
3062 GOOGLE_DCHECK_NE(&from, _this);
3063 ::uint32_t cached_has_bits = 0;
3064 (void) cached_has_bits;
3065
3066 cached_has_bits = from._impl_._has_bits_[0];
3067 if (cached_has_bits & 0x00000007u) {
3068 if (cached_has_bits & 0x00000001u) {
3069 _this->_internal_set_port(from._internal_port());
3070 }
3071 if (cached_has_bits & 0x00000002u) {
3072 _this->_impl_.chan_ = from._impl_.chan_;
3073 }
3074 if (cached_has_bits & 0x00000004u) {
3075 _this->_impl_.state_ = from._impl_.state_;
3076 }
3077 _this->_impl_._has_bits_[0] |= cached_has_bits;
3078 }
3079 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
3080 }
3081
CopyFrom(const TrustyIpcConnectFtraceEvent & from)3082 void TrustyIpcConnectFtraceEvent::CopyFrom(const TrustyIpcConnectFtraceEvent& from) {
3083 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.TrustyIpcConnectFtraceEvent)
3084 if (&from == this) return;
3085 Clear();
3086 MergeFrom(from);
3087 }
3088
IsInitialized() const3089 bool TrustyIpcConnectFtraceEvent::IsInitialized() const {
3090 return true;
3091 }
3092
InternalSwap(TrustyIpcConnectFtraceEvent * other)3093 void TrustyIpcConnectFtraceEvent::InternalSwap(TrustyIpcConnectFtraceEvent* other) {
3094 using std::swap;
3095 auto* lhs_arena = GetArenaForAllocation();
3096 auto* rhs_arena = other->GetArenaForAllocation();
3097 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
3098 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
3099 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
3100 &_impl_.port_, lhs_arena,
3101 &other->_impl_.port_, rhs_arena
3102 );
3103 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
3104 PROTOBUF_FIELD_OFFSET(TrustyIpcConnectFtraceEvent, _impl_.state_)
3105 + sizeof(TrustyIpcConnectFtraceEvent::_impl_.state_) // NOLINT
3106 - PROTOBUF_FIELD_OFFSET(TrustyIpcConnectFtraceEvent, _impl_.chan_)>(
3107 reinterpret_cast<char*>(&_impl_.chan_),
3108 reinterpret_cast<char*>(&other->_impl_.chan_));
3109 }
3110
GetTypeName() const3111 std::string TrustyIpcConnectFtraceEvent::GetTypeName() const {
3112 return "perfetto.protos.TrustyIpcConnectFtraceEvent";
3113 }
3114
3115
3116 // ===================================================================
3117
3118 class TrustyIpcConnectEndFtraceEvent::_Internal {
3119 public:
3120 using HasBits = decltype(std::declval<TrustyIpcConnectEndFtraceEvent>()._impl_._has_bits_);
set_has_chan(HasBits * has_bits)3121 static void set_has_chan(HasBits* has_bits) {
3122 (*has_bits)[0] |= 1u;
3123 }
set_has_err(HasBits * has_bits)3124 static void set_has_err(HasBits* has_bits) {
3125 (*has_bits)[0] |= 2u;
3126 }
set_has_state(HasBits * has_bits)3127 static void set_has_state(HasBits* has_bits) {
3128 (*has_bits)[0] |= 4u;
3129 }
3130 };
3131
TrustyIpcConnectEndFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)3132 TrustyIpcConnectEndFtraceEvent::TrustyIpcConnectEndFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
3133 bool is_message_owned)
3134 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
3135 SharedCtor(arena, is_message_owned);
3136 // @@protoc_insertion_point(arena_constructor:perfetto.protos.TrustyIpcConnectEndFtraceEvent)
3137 }
TrustyIpcConnectEndFtraceEvent(const TrustyIpcConnectEndFtraceEvent & from)3138 TrustyIpcConnectEndFtraceEvent::TrustyIpcConnectEndFtraceEvent(const TrustyIpcConnectEndFtraceEvent& from)
3139 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
3140 TrustyIpcConnectEndFtraceEvent* const _this = this; (void)_this;
3141 new (&_impl_) Impl_{
3142 decltype(_impl_._has_bits_){from._impl_._has_bits_}
3143 , /*decltype(_impl_._cached_size_)*/{}
3144 , decltype(_impl_.chan_){}
3145 , decltype(_impl_.err_){}
3146 , decltype(_impl_.state_){}};
3147
3148 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
3149 ::memcpy(&_impl_.chan_, &from._impl_.chan_,
3150 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.state_) -
3151 reinterpret_cast<char*>(&_impl_.chan_)) + sizeof(_impl_.state_));
3152 // @@protoc_insertion_point(copy_constructor:perfetto.protos.TrustyIpcConnectEndFtraceEvent)
3153 }
3154
SharedCtor(::_pb::Arena * arena,bool is_message_owned)3155 inline void TrustyIpcConnectEndFtraceEvent::SharedCtor(
3156 ::_pb::Arena* arena, bool is_message_owned) {
3157 (void)arena;
3158 (void)is_message_owned;
3159 new (&_impl_) Impl_{
3160 decltype(_impl_._has_bits_){}
3161 , /*decltype(_impl_._cached_size_)*/{}
3162 , decltype(_impl_.chan_){0u}
3163 , decltype(_impl_.err_){0}
3164 , decltype(_impl_.state_){0}
3165 };
3166 }
3167
~TrustyIpcConnectEndFtraceEvent()3168 TrustyIpcConnectEndFtraceEvent::~TrustyIpcConnectEndFtraceEvent() {
3169 // @@protoc_insertion_point(destructor:perfetto.protos.TrustyIpcConnectEndFtraceEvent)
3170 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
3171 (void)arena;
3172 return;
3173 }
3174 SharedDtor();
3175 }
3176
SharedDtor()3177 inline void TrustyIpcConnectEndFtraceEvent::SharedDtor() {
3178 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
3179 }
3180
SetCachedSize(int size) const3181 void TrustyIpcConnectEndFtraceEvent::SetCachedSize(int size) const {
3182 _impl_._cached_size_.Set(size);
3183 }
3184
Clear()3185 void TrustyIpcConnectEndFtraceEvent::Clear() {
3186 // @@protoc_insertion_point(message_clear_start:perfetto.protos.TrustyIpcConnectEndFtraceEvent)
3187 ::uint32_t cached_has_bits = 0;
3188 // Prevent compiler warnings about cached_has_bits being unused
3189 (void) cached_has_bits;
3190
3191 cached_has_bits = _impl_._has_bits_[0];
3192 if (cached_has_bits & 0x00000007u) {
3193 ::memset(&_impl_.chan_, 0, static_cast<size_t>(
3194 reinterpret_cast<char*>(&_impl_.state_) -
3195 reinterpret_cast<char*>(&_impl_.chan_)) + sizeof(_impl_.state_));
3196 }
3197 _impl_._has_bits_.Clear();
3198 _internal_metadata_.Clear<std::string>();
3199 }
3200
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)3201 const char* TrustyIpcConnectEndFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
3202 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
3203 _Internal::HasBits has_bits{};
3204 while (!ctx->Done(&ptr)) {
3205 ::uint32_t tag;
3206 ptr = ::_pbi::ReadTag(ptr, &tag);
3207 switch (tag >> 3) {
3208 // optional uint32 chan = 1;
3209 case 1:
3210 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
3211 _Internal::set_has_chan(&has_bits);
3212 _impl_.chan_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
3213 CHK_(ptr);
3214 } else {
3215 goto handle_unusual;
3216 }
3217 continue;
3218 // optional int32 err = 2;
3219 case 2:
3220 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
3221 _Internal::set_has_err(&has_bits);
3222 _impl_.err_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
3223 CHK_(ptr);
3224 } else {
3225 goto handle_unusual;
3226 }
3227 continue;
3228 // optional int32 state = 3;
3229 case 3:
3230 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
3231 _Internal::set_has_state(&has_bits);
3232 _impl_.state_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
3233 CHK_(ptr);
3234 } else {
3235 goto handle_unusual;
3236 }
3237 continue;
3238 default:
3239 goto handle_unusual;
3240 } // switch
3241 handle_unusual:
3242 if ((tag == 0) || ((tag & 7) == 4)) {
3243 CHK_(ptr);
3244 ctx->SetLastTag(tag);
3245 goto message_done;
3246 }
3247 ptr = UnknownFieldParse(
3248 tag,
3249 _internal_metadata_.mutable_unknown_fields<std::string>(),
3250 ptr, ctx);
3251 CHK_(ptr != nullptr);
3252 } // while
3253 message_done:
3254 _impl_._has_bits_.Or(has_bits);
3255 return ptr;
3256 failure:
3257 ptr = nullptr;
3258 goto message_done;
3259 #undef CHK_
3260 }
3261
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const3262 ::uint8_t* TrustyIpcConnectEndFtraceEvent::_InternalSerialize(
3263 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
3264 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.TrustyIpcConnectEndFtraceEvent)
3265 ::uint32_t cached_has_bits = 0;
3266 (void) cached_has_bits;
3267
3268 cached_has_bits = _impl_._has_bits_[0];
3269 // optional uint32 chan = 1;
3270 if (cached_has_bits & 0x00000001u) {
3271 target = stream->EnsureSpace(target);
3272 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_chan(), target);
3273 }
3274
3275 // optional int32 err = 2;
3276 if (cached_has_bits & 0x00000002u) {
3277 target = stream->EnsureSpace(target);
3278 target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_err(), target);
3279 }
3280
3281 // optional int32 state = 3;
3282 if (cached_has_bits & 0x00000004u) {
3283 target = stream->EnsureSpace(target);
3284 target = ::_pbi::WireFormatLite::WriteInt32ToArray(3, this->_internal_state(), target);
3285 }
3286
3287 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
3288 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
3289 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
3290 }
3291 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.TrustyIpcConnectEndFtraceEvent)
3292 return target;
3293 }
3294
ByteSizeLong() const3295 size_t TrustyIpcConnectEndFtraceEvent::ByteSizeLong() const {
3296 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.TrustyIpcConnectEndFtraceEvent)
3297 size_t total_size = 0;
3298
3299 ::uint32_t cached_has_bits = 0;
3300 // Prevent compiler warnings about cached_has_bits being unused
3301 (void) cached_has_bits;
3302
3303 cached_has_bits = _impl_._has_bits_[0];
3304 if (cached_has_bits & 0x00000007u) {
3305 // optional uint32 chan = 1;
3306 if (cached_has_bits & 0x00000001u) {
3307 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_chan());
3308 }
3309
3310 // optional int32 err = 2;
3311 if (cached_has_bits & 0x00000002u) {
3312 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_err());
3313 }
3314
3315 // optional int32 state = 3;
3316 if (cached_has_bits & 0x00000004u) {
3317 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_state());
3318 }
3319
3320 }
3321 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
3322 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
3323 }
3324 int cached_size = ::_pbi::ToCachedSize(total_size);
3325 SetCachedSize(cached_size);
3326 return total_size;
3327 }
3328
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)3329 void TrustyIpcConnectEndFtraceEvent::CheckTypeAndMergeFrom(
3330 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
3331 MergeFrom(*::_pbi::DownCast<const TrustyIpcConnectEndFtraceEvent*>(
3332 &from));
3333 }
3334
MergeFrom(const TrustyIpcConnectEndFtraceEvent & from)3335 void TrustyIpcConnectEndFtraceEvent::MergeFrom(const TrustyIpcConnectEndFtraceEvent& from) {
3336 TrustyIpcConnectEndFtraceEvent* const _this = this;
3337 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.TrustyIpcConnectEndFtraceEvent)
3338 GOOGLE_DCHECK_NE(&from, _this);
3339 ::uint32_t cached_has_bits = 0;
3340 (void) cached_has_bits;
3341
3342 cached_has_bits = from._impl_._has_bits_[0];
3343 if (cached_has_bits & 0x00000007u) {
3344 if (cached_has_bits & 0x00000001u) {
3345 _this->_impl_.chan_ = from._impl_.chan_;
3346 }
3347 if (cached_has_bits & 0x00000002u) {
3348 _this->_impl_.err_ = from._impl_.err_;
3349 }
3350 if (cached_has_bits & 0x00000004u) {
3351 _this->_impl_.state_ = from._impl_.state_;
3352 }
3353 _this->_impl_._has_bits_[0] |= cached_has_bits;
3354 }
3355 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
3356 }
3357
CopyFrom(const TrustyIpcConnectEndFtraceEvent & from)3358 void TrustyIpcConnectEndFtraceEvent::CopyFrom(const TrustyIpcConnectEndFtraceEvent& from) {
3359 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.TrustyIpcConnectEndFtraceEvent)
3360 if (&from == this) return;
3361 Clear();
3362 MergeFrom(from);
3363 }
3364
IsInitialized() const3365 bool TrustyIpcConnectEndFtraceEvent::IsInitialized() const {
3366 return true;
3367 }
3368
InternalSwap(TrustyIpcConnectEndFtraceEvent * other)3369 void TrustyIpcConnectEndFtraceEvent::InternalSwap(TrustyIpcConnectEndFtraceEvent* other) {
3370 using std::swap;
3371 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
3372 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
3373 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
3374 PROTOBUF_FIELD_OFFSET(TrustyIpcConnectEndFtraceEvent, _impl_.state_)
3375 + sizeof(TrustyIpcConnectEndFtraceEvent::_impl_.state_) // NOLINT
3376 - PROTOBUF_FIELD_OFFSET(TrustyIpcConnectEndFtraceEvent, _impl_.chan_)>(
3377 reinterpret_cast<char*>(&_impl_.chan_),
3378 reinterpret_cast<char*>(&other->_impl_.chan_));
3379 }
3380
GetTypeName() const3381 std::string TrustyIpcConnectEndFtraceEvent::GetTypeName() const {
3382 return "perfetto.protos.TrustyIpcConnectEndFtraceEvent";
3383 }
3384
3385
3386 // ===================================================================
3387
3388 class TrustyIpcWriteFtraceEvent::_Internal {
3389 public:
3390 using HasBits = decltype(std::declval<TrustyIpcWriteFtraceEvent>()._impl_._has_bits_);
set_has_buf_id(HasBits * has_bits)3391 static void set_has_buf_id(HasBits* has_bits) {
3392 (*has_bits)[0] |= 2u;
3393 }
set_has_chan(HasBits * has_bits)3394 static void set_has_chan(HasBits* has_bits) {
3395 (*has_bits)[0] |= 4u;
3396 }
set_has_kind_shm(HasBits * has_bits)3397 static void set_has_kind_shm(HasBits* has_bits) {
3398 (*has_bits)[0] |= 8u;
3399 }
set_has_len_or_err(HasBits * has_bits)3400 static void set_has_len_or_err(HasBits* has_bits) {
3401 (*has_bits)[0] |= 32u;
3402 }
set_has_shm_cnt(HasBits * has_bits)3403 static void set_has_shm_cnt(HasBits* has_bits) {
3404 (*has_bits)[0] |= 16u;
3405 }
set_has_srv_name(HasBits * has_bits)3406 static void set_has_srv_name(HasBits* has_bits) {
3407 (*has_bits)[0] |= 1u;
3408 }
3409 };
3410
TrustyIpcWriteFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)3411 TrustyIpcWriteFtraceEvent::TrustyIpcWriteFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
3412 bool is_message_owned)
3413 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
3414 SharedCtor(arena, is_message_owned);
3415 // @@protoc_insertion_point(arena_constructor:perfetto.protos.TrustyIpcWriteFtraceEvent)
3416 }
TrustyIpcWriteFtraceEvent(const TrustyIpcWriteFtraceEvent & from)3417 TrustyIpcWriteFtraceEvent::TrustyIpcWriteFtraceEvent(const TrustyIpcWriteFtraceEvent& from)
3418 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
3419 TrustyIpcWriteFtraceEvent* const _this = this; (void)_this;
3420 new (&_impl_) Impl_{
3421 decltype(_impl_._has_bits_){from._impl_._has_bits_}
3422 , /*decltype(_impl_._cached_size_)*/{}
3423 , decltype(_impl_.srv_name_){}
3424 , decltype(_impl_.buf_id_){}
3425 , decltype(_impl_.chan_){}
3426 , decltype(_impl_.kind_shm_){}
3427 , decltype(_impl_.shm_cnt_){}
3428 , decltype(_impl_.len_or_err_){}};
3429
3430 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
3431 _impl_.srv_name_.InitDefault();
3432 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3433 _impl_.srv_name_.Set("", GetArenaForAllocation());
3434 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3435 if (from._internal_has_srv_name()) {
3436 _this->_impl_.srv_name_.Set(from._internal_srv_name(),
3437 _this->GetArenaForAllocation());
3438 }
3439 ::memcpy(&_impl_.buf_id_, &from._impl_.buf_id_,
3440 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.len_or_err_) -
3441 reinterpret_cast<char*>(&_impl_.buf_id_)) + sizeof(_impl_.len_or_err_));
3442 // @@protoc_insertion_point(copy_constructor:perfetto.protos.TrustyIpcWriteFtraceEvent)
3443 }
3444
SharedCtor(::_pb::Arena * arena,bool is_message_owned)3445 inline void TrustyIpcWriteFtraceEvent::SharedCtor(
3446 ::_pb::Arena* arena, bool is_message_owned) {
3447 (void)arena;
3448 (void)is_message_owned;
3449 new (&_impl_) Impl_{
3450 decltype(_impl_._has_bits_){}
3451 , /*decltype(_impl_._cached_size_)*/{}
3452 , decltype(_impl_.srv_name_){}
3453 , decltype(_impl_.buf_id_){::uint64_t{0u}}
3454 , decltype(_impl_.chan_){0u}
3455 , decltype(_impl_.kind_shm_){0}
3456 , decltype(_impl_.shm_cnt_){::uint64_t{0u}}
3457 , decltype(_impl_.len_or_err_){0}
3458 };
3459 _impl_.srv_name_.InitDefault();
3460 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3461 _impl_.srv_name_.Set("", GetArenaForAllocation());
3462 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3463 }
3464
~TrustyIpcWriteFtraceEvent()3465 TrustyIpcWriteFtraceEvent::~TrustyIpcWriteFtraceEvent() {
3466 // @@protoc_insertion_point(destructor:perfetto.protos.TrustyIpcWriteFtraceEvent)
3467 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
3468 (void)arena;
3469 return;
3470 }
3471 SharedDtor();
3472 }
3473
SharedDtor()3474 inline void TrustyIpcWriteFtraceEvent::SharedDtor() {
3475 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
3476 _impl_.srv_name_.Destroy();
3477 }
3478
SetCachedSize(int size) const3479 void TrustyIpcWriteFtraceEvent::SetCachedSize(int size) const {
3480 _impl_._cached_size_.Set(size);
3481 }
3482
Clear()3483 void TrustyIpcWriteFtraceEvent::Clear() {
3484 // @@protoc_insertion_point(message_clear_start:perfetto.protos.TrustyIpcWriteFtraceEvent)
3485 ::uint32_t cached_has_bits = 0;
3486 // Prevent compiler warnings about cached_has_bits being unused
3487 (void) cached_has_bits;
3488
3489 cached_has_bits = _impl_._has_bits_[0];
3490 if (cached_has_bits & 0x00000001u) {
3491 _impl_.srv_name_.ClearNonDefaultToEmpty();
3492 }
3493 if (cached_has_bits & 0x0000003eu) {
3494 ::memset(&_impl_.buf_id_, 0, static_cast<size_t>(
3495 reinterpret_cast<char*>(&_impl_.len_or_err_) -
3496 reinterpret_cast<char*>(&_impl_.buf_id_)) + sizeof(_impl_.len_or_err_));
3497 }
3498 _impl_._has_bits_.Clear();
3499 _internal_metadata_.Clear<std::string>();
3500 }
3501
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)3502 const char* TrustyIpcWriteFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
3503 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
3504 _Internal::HasBits has_bits{};
3505 while (!ctx->Done(&ptr)) {
3506 ::uint32_t tag;
3507 ptr = ::_pbi::ReadTag(ptr, &tag);
3508 switch (tag >> 3) {
3509 // optional uint64 buf_id = 1;
3510 case 1:
3511 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
3512 _Internal::set_has_buf_id(&has_bits);
3513 _impl_.buf_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
3514 CHK_(ptr);
3515 } else {
3516 goto handle_unusual;
3517 }
3518 continue;
3519 // optional uint32 chan = 2;
3520 case 2:
3521 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
3522 _Internal::set_has_chan(&has_bits);
3523 _impl_.chan_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
3524 CHK_(ptr);
3525 } else {
3526 goto handle_unusual;
3527 }
3528 continue;
3529 // optional int32 kind_shm = 3;
3530 case 3:
3531 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
3532 _Internal::set_has_kind_shm(&has_bits);
3533 _impl_.kind_shm_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
3534 CHK_(ptr);
3535 } else {
3536 goto handle_unusual;
3537 }
3538 continue;
3539 // optional int32 len_or_err = 4;
3540 case 4:
3541 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
3542 _Internal::set_has_len_or_err(&has_bits);
3543 _impl_.len_or_err_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
3544 CHK_(ptr);
3545 } else {
3546 goto handle_unusual;
3547 }
3548 continue;
3549 // optional uint64 shm_cnt = 5;
3550 case 5:
3551 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
3552 _Internal::set_has_shm_cnt(&has_bits);
3553 _impl_.shm_cnt_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
3554 CHK_(ptr);
3555 } else {
3556 goto handle_unusual;
3557 }
3558 continue;
3559 // optional string srv_name = 6;
3560 case 6:
3561 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 50)) {
3562 auto str = _internal_mutable_srv_name();
3563 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
3564 CHK_(ptr);
3565 } else {
3566 goto handle_unusual;
3567 }
3568 continue;
3569 default:
3570 goto handle_unusual;
3571 } // switch
3572 handle_unusual:
3573 if ((tag == 0) || ((tag & 7) == 4)) {
3574 CHK_(ptr);
3575 ctx->SetLastTag(tag);
3576 goto message_done;
3577 }
3578 ptr = UnknownFieldParse(
3579 tag,
3580 _internal_metadata_.mutable_unknown_fields<std::string>(),
3581 ptr, ctx);
3582 CHK_(ptr != nullptr);
3583 } // while
3584 message_done:
3585 _impl_._has_bits_.Or(has_bits);
3586 return ptr;
3587 failure:
3588 ptr = nullptr;
3589 goto message_done;
3590 #undef CHK_
3591 }
3592
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const3593 ::uint8_t* TrustyIpcWriteFtraceEvent::_InternalSerialize(
3594 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
3595 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.TrustyIpcWriteFtraceEvent)
3596 ::uint32_t cached_has_bits = 0;
3597 (void) cached_has_bits;
3598
3599 cached_has_bits = _impl_._has_bits_[0];
3600 // optional uint64 buf_id = 1;
3601 if (cached_has_bits & 0x00000002u) {
3602 target = stream->EnsureSpace(target);
3603 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_buf_id(), target);
3604 }
3605
3606 // optional uint32 chan = 2;
3607 if (cached_has_bits & 0x00000004u) {
3608 target = stream->EnsureSpace(target);
3609 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_chan(), target);
3610 }
3611
3612 // optional int32 kind_shm = 3;
3613 if (cached_has_bits & 0x00000008u) {
3614 target = stream->EnsureSpace(target);
3615 target = ::_pbi::WireFormatLite::WriteInt32ToArray(3, this->_internal_kind_shm(), target);
3616 }
3617
3618 // optional int32 len_or_err = 4;
3619 if (cached_has_bits & 0x00000020u) {
3620 target = stream->EnsureSpace(target);
3621 target = ::_pbi::WireFormatLite::WriteInt32ToArray(4, this->_internal_len_or_err(), target);
3622 }
3623
3624 // optional uint64 shm_cnt = 5;
3625 if (cached_has_bits & 0x00000010u) {
3626 target = stream->EnsureSpace(target);
3627 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(5, this->_internal_shm_cnt(), target);
3628 }
3629
3630 // optional string srv_name = 6;
3631 if (cached_has_bits & 0x00000001u) {
3632 target = stream->WriteStringMaybeAliased(
3633 6, this->_internal_srv_name(), target);
3634 }
3635
3636 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
3637 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
3638 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
3639 }
3640 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.TrustyIpcWriteFtraceEvent)
3641 return target;
3642 }
3643
ByteSizeLong() const3644 size_t TrustyIpcWriteFtraceEvent::ByteSizeLong() const {
3645 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.TrustyIpcWriteFtraceEvent)
3646 size_t total_size = 0;
3647
3648 ::uint32_t cached_has_bits = 0;
3649 // Prevent compiler warnings about cached_has_bits being unused
3650 (void) cached_has_bits;
3651
3652 cached_has_bits = _impl_._has_bits_[0];
3653 if (cached_has_bits & 0x0000003fu) {
3654 // optional string srv_name = 6;
3655 if (cached_has_bits & 0x00000001u) {
3656 total_size += 1 +
3657 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
3658 this->_internal_srv_name());
3659 }
3660
3661 // optional uint64 buf_id = 1;
3662 if (cached_has_bits & 0x00000002u) {
3663 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_buf_id());
3664 }
3665
3666 // optional uint32 chan = 2;
3667 if (cached_has_bits & 0x00000004u) {
3668 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_chan());
3669 }
3670
3671 // optional int32 kind_shm = 3;
3672 if (cached_has_bits & 0x00000008u) {
3673 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_kind_shm());
3674 }
3675
3676 // optional uint64 shm_cnt = 5;
3677 if (cached_has_bits & 0x00000010u) {
3678 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_shm_cnt());
3679 }
3680
3681 // optional int32 len_or_err = 4;
3682 if (cached_has_bits & 0x00000020u) {
3683 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_len_or_err());
3684 }
3685
3686 }
3687 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
3688 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
3689 }
3690 int cached_size = ::_pbi::ToCachedSize(total_size);
3691 SetCachedSize(cached_size);
3692 return total_size;
3693 }
3694
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)3695 void TrustyIpcWriteFtraceEvent::CheckTypeAndMergeFrom(
3696 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
3697 MergeFrom(*::_pbi::DownCast<const TrustyIpcWriteFtraceEvent*>(
3698 &from));
3699 }
3700
MergeFrom(const TrustyIpcWriteFtraceEvent & from)3701 void TrustyIpcWriteFtraceEvent::MergeFrom(const TrustyIpcWriteFtraceEvent& from) {
3702 TrustyIpcWriteFtraceEvent* const _this = this;
3703 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.TrustyIpcWriteFtraceEvent)
3704 GOOGLE_DCHECK_NE(&from, _this);
3705 ::uint32_t cached_has_bits = 0;
3706 (void) cached_has_bits;
3707
3708 cached_has_bits = from._impl_._has_bits_[0];
3709 if (cached_has_bits & 0x0000003fu) {
3710 if (cached_has_bits & 0x00000001u) {
3711 _this->_internal_set_srv_name(from._internal_srv_name());
3712 }
3713 if (cached_has_bits & 0x00000002u) {
3714 _this->_impl_.buf_id_ = from._impl_.buf_id_;
3715 }
3716 if (cached_has_bits & 0x00000004u) {
3717 _this->_impl_.chan_ = from._impl_.chan_;
3718 }
3719 if (cached_has_bits & 0x00000008u) {
3720 _this->_impl_.kind_shm_ = from._impl_.kind_shm_;
3721 }
3722 if (cached_has_bits & 0x00000010u) {
3723 _this->_impl_.shm_cnt_ = from._impl_.shm_cnt_;
3724 }
3725 if (cached_has_bits & 0x00000020u) {
3726 _this->_impl_.len_or_err_ = from._impl_.len_or_err_;
3727 }
3728 _this->_impl_._has_bits_[0] |= cached_has_bits;
3729 }
3730 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
3731 }
3732
CopyFrom(const TrustyIpcWriteFtraceEvent & from)3733 void TrustyIpcWriteFtraceEvent::CopyFrom(const TrustyIpcWriteFtraceEvent& from) {
3734 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.TrustyIpcWriteFtraceEvent)
3735 if (&from == this) return;
3736 Clear();
3737 MergeFrom(from);
3738 }
3739
IsInitialized() const3740 bool TrustyIpcWriteFtraceEvent::IsInitialized() const {
3741 return true;
3742 }
3743
InternalSwap(TrustyIpcWriteFtraceEvent * other)3744 void TrustyIpcWriteFtraceEvent::InternalSwap(TrustyIpcWriteFtraceEvent* other) {
3745 using std::swap;
3746 auto* lhs_arena = GetArenaForAllocation();
3747 auto* rhs_arena = other->GetArenaForAllocation();
3748 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
3749 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
3750 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
3751 &_impl_.srv_name_, lhs_arena,
3752 &other->_impl_.srv_name_, rhs_arena
3753 );
3754 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
3755 PROTOBUF_FIELD_OFFSET(TrustyIpcWriteFtraceEvent, _impl_.len_or_err_)
3756 + sizeof(TrustyIpcWriteFtraceEvent::_impl_.len_or_err_) // NOLINT
3757 - PROTOBUF_FIELD_OFFSET(TrustyIpcWriteFtraceEvent, _impl_.buf_id_)>(
3758 reinterpret_cast<char*>(&_impl_.buf_id_),
3759 reinterpret_cast<char*>(&other->_impl_.buf_id_));
3760 }
3761
GetTypeName() const3762 std::string TrustyIpcWriteFtraceEvent::GetTypeName() const {
3763 return "perfetto.protos.TrustyIpcWriteFtraceEvent";
3764 }
3765
3766
3767 // ===================================================================
3768
3769 class TrustyIpcPollFtraceEvent::_Internal {
3770 public:
3771 using HasBits = decltype(std::declval<TrustyIpcPollFtraceEvent>()._impl_._has_bits_);
set_has_chan(HasBits * has_bits)3772 static void set_has_chan(HasBits* has_bits) {
3773 (*has_bits)[0] |= 2u;
3774 }
set_has_poll_mask(HasBits * has_bits)3775 static void set_has_poll_mask(HasBits* has_bits) {
3776 (*has_bits)[0] |= 4u;
3777 }
set_has_srv_name(HasBits * has_bits)3778 static void set_has_srv_name(HasBits* has_bits) {
3779 (*has_bits)[0] |= 1u;
3780 }
3781 };
3782
TrustyIpcPollFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)3783 TrustyIpcPollFtraceEvent::TrustyIpcPollFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
3784 bool is_message_owned)
3785 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
3786 SharedCtor(arena, is_message_owned);
3787 // @@protoc_insertion_point(arena_constructor:perfetto.protos.TrustyIpcPollFtraceEvent)
3788 }
TrustyIpcPollFtraceEvent(const TrustyIpcPollFtraceEvent & from)3789 TrustyIpcPollFtraceEvent::TrustyIpcPollFtraceEvent(const TrustyIpcPollFtraceEvent& from)
3790 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
3791 TrustyIpcPollFtraceEvent* const _this = this; (void)_this;
3792 new (&_impl_) Impl_{
3793 decltype(_impl_._has_bits_){from._impl_._has_bits_}
3794 , /*decltype(_impl_._cached_size_)*/{}
3795 , decltype(_impl_.srv_name_){}
3796 , decltype(_impl_.chan_){}
3797 , decltype(_impl_.poll_mask_){}};
3798
3799 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
3800 _impl_.srv_name_.InitDefault();
3801 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3802 _impl_.srv_name_.Set("", GetArenaForAllocation());
3803 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3804 if (from._internal_has_srv_name()) {
3805 _this->_impl_.srv_name_.Set(from._internal_srv_name(),
3806 _this->GetArenaForAllocation());
3807 }
3808 ::memcpy(&_impl_.chan_, &from._impl_.chan_,
3809 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.poll_mask_) -
3810 reinterpret_cast<char*>(&_impl_.chan_)) + sizeof(_impl_.poll_mask_));
3811 // @@protoc_insertion_point(copy_constructor:perfetto.protos.TrustyIpcPollFtraceEvent)
3812 }
3813
SharedCtor(::_pb::Arena * arena,bool is_message_owned)3814 inline void TrustyIpcPollFtraceEvent::SharedCtor(
3815 ::_pb::Arena* arena, bool is_message_owned) {
3816 (void)arena;
3817 (void)is_message_owned;
3818 new (&_impl_) Impl_{
3819 decltype(_impl_._has_bits_){}
3820 , /*decltype(_impl_._cached_size_)*/{}
3821 , decltype(_impl_.srv_name_){}
3822 , decltype(_impl_.chan_){0u}
3823 , decltype(_impl_.poll_mask_){0u}
3824 };
3825 _impl_.srv_name_.InitDefault();
3826 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3827 _impl_.srv_name_.Set("", GetArenaForAllocation());
3828 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3829 }
3830
~TrustyIpcPollFtraceEvent()3831 TrustyIpcPollFtraceEvent::~TrustyIpcPollFtraceEvent() {
3832 // @@protoc_insertion_point(destructor:perfetto.protos.TrustyIpcPollFtraceEvent)
3833 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
3834 (void)arena;
3835 return;
3836 }
3837 SharedDtor();
3838 }
3839
SharedDtor()3840 inline void TrustyIpcPollFtraceEvent::SharedDtor() {
3841 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
3842 _impl_.srv_name_.Destroy();
3843 }
3844
SetCachedSize(int size) const3845 void TrustyIpcPollFtraceEvent::SetCachedSize(int size) const {
3846 _impl_._cached_size_.Set(size);
3847 }
3848
Clear()3849 void TrustyIpcPollFtraceEvent::Clear() {
3850 // @@protoc_insertion_point(message_clear_start:perfetto.protos.TrustyIpcPollFtraceEvent)
3851 ::uint32_t cached_has_bits = 0;
3852 // Prevent compiler warnings about cached_has_bits being unused
3853 (void) cached_has_bits;
3854
3855 cached_has_bits = _impl_._has_bits_[0];
3856 if (cached_has_bits & 0x00000001u) {
3857 _impl_.srv_name_.ClearNonDefaultToEmpty();
3858 }
3859 if (cached_has_bits & 0x00000006u) {
3860 ::memset(&_impl_.chan_, 0, static_cast<size_t>(
3861 reinterpret_cast<char*>(&_impl_.poll_mask_) -
3862 reinterpret_cast<char*>(&_impl_.chan_)) + sizeof(_impl_.poll_mask_));
3863 }
3864 _impl_._has_bits_.Clear();
3865 _internal_metadata_.Clear<std::string>();
3866 }
3867
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)3868 const char* TrustyIpcPollFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
3869 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
3870 _Internal::HasBits has_bits{};
3871 while (!ctx->Done(&ptr)) {
3872 ::uint32_t tag;
3873 ptr = ::_pbi::ReadTag(ptr, &tag);
3874 switch (tag >> 3) {
3875 // optional uint32 chan = 1;
3876 case 1:
3877 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
3878 _Internal::set_has_chan(&has_bits);
3879 _impl_.chan_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
3880 CHK_(ptr);
3881 } else {
3882 goto handle_unusual;
3883 }
3884 continue;
3885 // optional uint32 poll_mask = 2;
3886 case 2:
3887 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
3888 _Internal::set_has_poll_mask(&has_bits);
3889 _impl_.poll_mask_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
3890 CHK_(ptr);
3891 } else {
3892 goto handle_unusual;
3893 }
3894 continue;
3895 // optional string srv_name = 3;
3896 case 3:
3897 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
3898 auto str = _internal_mutable_srv_name();
3899 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
3900 CHK_(ptr);
3901 } else {
3902 goto handle_unusual;
3903 }
3904 continue;
3905 default:
3906 goto handle_unusual;
3907 } // switch
3908 handle_unusual:
3909 if ((tag == 0) || ((tag & 7) == 4)) {
3910 CHK_(ptr);
3911 ctx->SetLastTag(tag);
3912 goto message_done;
3913 }
3914 ptr = UnknownFieldParse(
3915 tag,
3916 _internal_metadata_.mutable_unknown_fields<std::string>(),
3917 ptr, ctx);
3918 CHK_(ptr != nullptr);
3919 } // while
3920 message_done:
3921 _impl_._has_bits_.Or(has_bits);
3922 return ptr;
3923 failure:
3924 ptr = nullptr;
3925 goto message_done;
3926 #undef CHK_
3927 }
3928
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const3929 ::uint8_t* TrustyIpcPollFtraceEvent::_InternalSerialize(
3930 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
3931 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.TrustyIpcPollFtraceEvent)
3932 ::uint32_t cached_has_bits = 0;
3933 (void) cached_has_bits;
3934
3935 cached_has_bits = _impl_._has_bits_[0];
3936 // optional uint32 chan = 1;
3937 if (cached_has_bits & 0x00000002u) {
3938 target = stream->EnsureSpace(target);
3939 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_chan(), target);
3940 }
3941
3942 // optional uint32 poll_mask = 2;
3943 if (cached_has_bits & 0x00000004u) {
3944 target = stream->EnsureSpace(target);
3945 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_poll_mask(), target);
3946 }
3947
3948 // optional string srv_name = 3;
3949 if (cached_has_bits & 0x00000001u) {
3950 target = stream->WriteStringMaybeAliased(
3951 3, this->_internal_srv_name(), target);
3952 }
3953
3954 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
3955 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
3956 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
3957 }
3958 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.TrustyIpcPollFtraceEvent)
3959 return target;
3960 }
3961
ByteSizeLong() const3962 size_t TrustyIpcPollFtraceEvent::ByteSizeLong() const {
3963 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.TrustyIpcPollFtraceEvent)
3964 size_t total_size = 0;
3965
3966 ::uint32_t cached_has_bits = 0;
3967 // Prevent compiler warnings about cached_has_bits being unused
3968 (void) cached_has_bits;
3969
3970 cached_has_bits = _impl_._has_bits_[0];
3971 if (cached_has_bits & 0x00000007u) {
3972 // optional string srv_name = 3;
3973 if (cached_has_bits & 0x00000001u) {
3974 total_size += 1 +
3975 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
3976 this->_internal_srv_name());
3977 }
3978
3979 // optional uint32 chan = 1;
3980 if (cached_has_bits & 0x00000002u) {
3981 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_chan());
3982 }
3983
3984 // optional uint32 poll_mask = 2;
3985 if (cached_has_bits & 0x00000004u) {
3986 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_poll_mask());
3987 }
3988
3989 }
3990 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
3991 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
3992 }
3993 int cached_size = ::_pbi::ToCachedSize(total_size);
3994 SetCachedSize(cached_size);
3995 return total_size;
3996 }
3997
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)3998 void TrustyIpcPollFtraceEvent::CheckTypeAndMergeFrom(
3999 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
4000 MergeFrom(*::_pbi::DownCast<const TrustyIpcPollFtraceEvent*>(
4001 &from));
4002 }
4003
MergeFrom(const TrustyIpcPollFtraceEvent & from)4004 void TrustyIpcPollFtraceEvent::MergeFrom(const TrustyIpcPollFtraceEvent& from) {
4005 TrustyIpcPollFtraceEvent* const _this = this;
4006 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.TrustyIpcPollFtraceEvent)
4007 GOOGLE_DCHECK_NE(&from, _this);
4008 ::uint32_t cached_has_bits = 0;
4009 (void) cached_has_bits;
4010
4011 cached_has_bits = from._impl_._has_bits_[0];
4012 if (cached_has_bits & 0x00000007u) {
4013 if (cached_has_bits & 0x00000001u) {
4014 _this->_internal_set_srv_name(from._internal_srv_name());
4015 }
4016 if (cached_has_bits & 0x00000002u) {
4017 _this->_impl_.chan_ = from._impl_.chan_;
4018 }
4019 if (cached_has_bits & 0x00000004u) {
4020 _this->_impl_.poll_mask_ = from._impl_.poll_mask_;
4021 }
4022 _this->_impl_._has_bits_[0] |= cached_has_bits;
4023 }
4024 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
4025 }
4026
CopyFrom(const TrustyIpcPollFtraceEvent & from)4027 void TrustyIpcPollFtraceEvent::CopyFrom(const TrustyIpcPollFtraceEvent& from) {
4028 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.TrustyIpcPollFtraceEvent)
4029 if (&from == this) return;
4030 Clear();
4031 MergeFrom(from);
4032 }
4033
IsInitialized() const4034 bool TrustyIpcPollFtraceEvent::IsInitialized() const {
4035 return true;
4036 }
4037
InternalSwap(TrustyIpcPollFtraceEvent * other)4038 void TrustyIpcPollFtraceEvent::InternalSwap(TrustyIpcPollFtraceEvent* other) {
4039 using std::swap;
4040 auto* lhs_arena = GetArenaForAllocation();
4041 auto* rhs_arena = other->GetArenaForAllocation();
4042 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
4043 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
4044 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
4045 &_impl_.srv_name_, lhs_arena,
4046 &other->_impl_.srv_name_, rhs_arena
4047 );
4048 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
4049 PROTOBUF_FIELD_OFFSET(TrustyIpcPollFtraceEvent, _impl_.poll_mask_)
4050 + sizeof(TrustyIpcPollFtraceEvent::_impl_.poll_mask_) // NOLINT
4051 - PROTOBUF_FIELD_OFFSET(TrustyIpcPollFtraceEvent, _impl_.chan_)>(
4052 reinterpret_cast<char*>(&_impl_.chan_),
4053 reinterpret_cast<char*>(&other->_impl_.chan_));
4054 }
4055
GetTypeName() const4056 std::string TrustyIpcPollFtraceEvent::GetTypeName() const {
4057 return "perfetto.protos.TrustyIpcPollFtraceEvent";
4058 }
4059
4060
4061 // ===================================================================
4062
4063 class TrustyIpcReadFtraceEvent::_Internal {
4064 public:
4065 using HasBits = decltype(std::declval<TrustyIpcReadFtraceEvent>()._impl_._has_bits_);
set_has_chan(HasBits * has_bits)4066 static void set_has_chan(HasBits* has_bits) {
4067 (*has_bits)[0] |= 2u;
4068 }
set_has_srv_name(HasBits * has_bits)4069 static void set_has_srv_name(HasBits* has_bits) {
4070 (*has_bits)[0] |= 1u;
4071 }
4072 };
4073
TrustyIpcReadFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)4074 TrustyIpcReadFtraceEvent::TrustyIpcReadFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
4075 bool is_message_owned)
4076 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
4077 SharedCtor(arena, is_message_owned);
4078 // @@protoc_insertion_point(arena_constructor:perfetto.protos.TrustyIpcReadFtraceEvent)
4079 }
TrustyIpcReadFtraceEvent(const TrustyIpcReadFtraceEvent & from)4080 TrustyIpcReadFtraceEvent::TrustyIpcReadFtraceEvent(const TrustyIpcReadFtraceEvent& from)
4081 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
4082 TrustyIpcReadFtraceEvent* const _this = this; (void)_this;
4083 new (&_impl_) Impl_{
4084 decltype(_impl_._has_bits_){from._impl_._has_bits_}
4085 , /*decltype(_impl_._cached_size_)*/{}
4086 , decltype(_impl_.srv_name_){}
4087 , decltype(_impl_.chan_){}};
4088
4089 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
4090 _impl_.srv_name_.InitDefault();
4091 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4092 _impl_.srv_name_.Set("", GetArenaForAllocation());
4093 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4094 if (from._internal_has_srv_name()) {
4095 _this->_impl_.srv_name_.Set(from._internal_srv_name(),
4096 _this->GetArenaForAllocation());
4097 }
4098 _this->_impl_.chan_ = from._impl_.chan_;
4099 // @@protoc_insertion_point(copy_constructor:perfetto.protos.TrustyIpcReadFtraceEvent)
4100 }
4101
SharedCtor(::_pb::Arena * arena,bool is_message_owned)4102 inline void TrustyIpcReadFtraceEvent::SharedCtor(
4103 ::_pb::Arena* arena, bool is_message_owned) {
4104 (void)arena;
4105 (void)is_message_owned;
4106 new (&_impl_) Impl_{
4107 decltype(_impl_._has_bits_){}
4108 , /*decltype(_impl_._cached_size_)*/{}
4109 , decltype(_impl_.srv_name_){}
4110 , decltype(_impl_.chan_){0u}
4111 };
4112 _impl_.srv_name_.InitDefault();
4113 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4114 _impl_.srv_name_.Set("", GetArenaForAllocation());
4115 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4116 }
4117
~TrustyIpcReadFtraceEvent()4118 TrustyIpcReadFtraceEvent::~TrustyIpcReadFtraceEvent() {
4119 // @@protoc_insertion_point(destructor:perfetto.protos.TrustyIpcReadFtraceEvent)
4120 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
4121 (void)arena;
4122 return;
4123 }
4124 SharedDtor();
4125 }
4126
SharedDtor()4127 inline void TrustyIpcReadFtraceEvent::SharedDtor() {
4128 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
4129 _impl_.srv_name_.Destroy();
4130 }
4131
SetCachedSize(int size) const4132 void TrustyIpcReadFtraceEvent::SetCachedSize(int size) const {
4133 _impl_._cached_size_.Set(size);
4134 }
4135
Clear()4136 void TrustyIpcReadFtraceEvent::Clear() {
4137 // @@protoc_insertion_point(message_clear_start:perfetto.protos.TrustyIpcReadFtraceEvent)
4138 ::uint32_t cached_has_bits = 0;
4139 // Prevent compiler warnings about cached_has_bits being unused
4140 (void) cached_has_bits;
4141
4142 cached_has_bits = _impl_._has_bits_[0];
4143 if (cached_has_bits & 0x00000001u) {
4144 _impl_.srv_name_.ClearNonDefaultToEmpty();
4145 }
4146 _impl_.chan_ = 0u;
4147 _impl_._has_bits_.Clear();
4148 _internal_metadata_.Clear<std::string>();
4149 }
4150
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)4151 const char* TrustyIpcReadFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
4152 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
4153 _Internal::HasBits has_bits{};
4154 while (!ctx->Done(&ptr)) {
4155 ::uint32_t tag;
4156 ptr = ::_pbi::ReadTag(ptr, &tag);
4157 switch (tag >> 3) {
4158 // optional uint32 chan = 1;
4159 case 1:
4160 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
4161 _Internal::set_has_chan(&has_bits);
4162 _impl_.chan_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
4163 CHK_(ptr);
4164 } else {
4165 goto handle_unusual;
4166 }
4167 continue;
4168 // optional string srv_name = 2;
4169 case 2:
4170 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
4171 auto str = _internal_mutable_srv_name();
4172 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
4173 CHK_(ptr);
4174 } else {
4175 goto handle_unusual;
4176 }
4177 continue;
4178 default:
4179 goto handle_unusual;
4180 } // switch
4181 handle_unusual:
4182 if ((tag == 0) || ((tag & 7) == 4)) {
4183 CHK_(ptr);
4184 ctx->SetLastTag(tag);
4185 goto message_done;
4186 }
4187 ptr = UnknownFieldParse(
4188 tag,
4189 _internal_metadata_.mutable_unknown_fields<std::string>(),
4190 ptr, ctx);
4191 CHK_(ptr != nullptr);
4192 } // while
4193 message_done:
4194 _impl_._has_bits_.Or(has_bits);
4195 return ptr;
4196 failure:
4197 ptr = nullptr;
4198 goto message_done;
4199 #undef CHK_
4200 }
4201
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const4202 ::uint8_t* TrustyIpcReadFtraceEvent::_InternalSerialize(
4203 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
4204 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.TrustyIpcReadFtraceEvent)
4205 ::uint32_t cached_has_bits = 0;
4206 (void) cached_has_bits;
4207
4208 cached_has_bits = _impl_._has_bits_[0];
4209 // optional uint32 chan = 1;
4210 if (cached_has_bits & 0x00000002u) {
4211 target = stream->EnsureSpace(target);
4212 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_chan(), target);
4213 }
4214
4215 // optional string srv_name = 2;
4216 if (cached_has_bits & 0x00000001u) {
4217 target = stream->WriteStringMaybeAliased(
4218 2, this->_internal_srv_name(), target);
4219 }
4220
4221 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
4222 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
4223 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
4224 }
4225 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.TrustyIpcReadFtraceEvent)
4226 return target;
4227 }
4228
ByteSizeLong() const4229 size_t TrustyIpcReadFtraceEvent::ByteSizeLong() const {
4230 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.TrustyIpcReadFtraceEvent)
4231 size_t total_size = 0;
4232
4233 ::uint32_t cached_has_bits = 0;
4234 // Prevent compiler warnings about cached_has_bits being unused
4235 (void) cached_has_bits;
4236
4237 cached_has_bits = _impl_._has_bits_[0];
4238 if (cached_has_bits & 0x00000003u) {
4239 // optional string srv_name = 2;
4240 if (cached_has_bits & 0x00000001u) {
4241 total_size += 1 +
4242 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
4243 this->_internal_srv_name());
4244 }
4245
4246 // optional uint32 chan = 1;
4247 if (cached_has_bits & 0x00000002u) {
4248 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_chan());
4249 }
4250
4251 }
4252 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
4253 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
4254 }
4255 int cached_size = ::_pbi::ToCachedSize(total_size);
4256 SetCachedSize(cached_size);
4257 return total_size;
4258 }
4259
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)4260 void TrustyIpcReadFtraceEvent::CheckTypeAndMergeFrom(
4261 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
4262 MergeFrom(*::_pbi::DownCast<const TrustyIpcReadFtraceEvent*>(
4263 &from));
4264 }
4265
MergeFrom(const TrustyIpcReadFtraceEvent & from)4266 void TrustyIpcReadFtraceEvent::MergeFrom(const TrustyIpcReadFtraceEvent& from) {
4267 TrustyIpcReadFtraceEvent* const _this = this;
4268 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.TrustyIpcReadFtraceEvent)
4269 GOOGLE_DCHECK_NE(&from, _this);
4270 ::uint32_t cached_has_bits = 0;
4271 (void) cached_has_bits;
4272
4273 cached_has_bits = from._impl_._has_bits_[0];
4274 if (cached_has_bits & 0x00000003u) {
4275 if (cached_has_bits & 0x00000001u) {
4276 _this->_internal_set_srv_name(from._internal_srv_name());
4277 }
4278 if (cached_has_bits & 0x00000002u) {
4279 _this->_impl_.chan_ = from._impl_.chan_;
4280 }
4281 _this->_impl_._has_bits_[0] |= cached_has_bits;
4282 }
4283 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
4284 }
4285
CopyFrom(const TrustyIpcReadFtraceEvent & from)4286 void TrustyIpcReadFtraceEvent::CopyFrom(const TrustyIpcReadFtraceEvent& from) {
4287 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.TrustyIpcReadFtraceEvent)
4288 if (&from == this) return;
4289 Clear();
4290 MergeFrom(from);
4291 }
4292
IsInitialized() const4293 bool TrustyIpcReadFtraceEvent::IsInitialized() const {
4294 return true;
4295 }
4296
InternalSwap(TrustyIpcReadFtraceEvent * other)4297 void TrustyIpcReadFtraceEvent::InternalSwap(TrustyIpcReadFtraceEvent* other) {
4298 using std::swap;
4299 auto* lhs_arena = GetArenaForAllocation();
4300 auto* rhs_arena = other->GetArenaForAllocation();
4301 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
4302 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
4303 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
4304 &_impl_.srv_name_, lhs_arena,
4305 &other->_impl_.srv_name_, rhs_arena
4306 );
4307 swap(_impl_.chan_, other->_impl_.chan_);
4308 }
4309
GetTypeName() const4310 std::string TrustyIpcReadFtraceEvent::GetTypeName() const {
4311 return "perfetto.protos.TrustyIpcReadFtraceEvent";
4312 }
4313
4314
4315 // ===================================================================
4316
4317 class TrustyIpcReadEndFtraceEvent::_Internal {
4318 public:
4319 using HasBits = decltype(std::declval<TrustyIpcReadEndFtraceEvent>()._impl_._has_bits_);
set_has_buf_id(HasBits * has_bits)4320 static void set_has_buf_id(HasBits* has_bits) {
4321 (*has_bits)[0] |= 2u;
4322 }
set_has_chan(HasBits * has_bits)4323 static void set_has_chan(HasBits* has_bits) {
4324 (*has_bits)[0] |= 4u;
4325 }
set_has_len_or_err(HasBits * has_bits)4326 static void set_has_len_or_err(HasBits* has_bits) {
4327 (*has_bits)[0] |= 8u;
4328 }
set_has_shm_cnt(HasBits * has_bits)4329 static void set_has_shm_cnt(HasBits* has_bits) {
4330 (*has_bits)[0] |= 16u;
4331 }
set_has_srv_name(HasBits * has_bits)4332 static void set_has_srv_name(HasBits* has_bits) {
4333 (*has_bits)[0] |= 1u;
4334 }
4335 };
4336
TrustyIpcReadEndFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)4337 TrustyIpcReadEndFtraceEvent::TrustyIpcReadEndFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
4338 bool is_message_owned)
4339 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
4340 SharedCtor(arena, is_message_owned);
4341 // @@protoc_insertion_point(arena_constructor:perfetto.protos.TrustyIpcReadEndFtraceEvent)
4342 }
TrustyIpcReadEndFtraceEvent(const TrustyIpcReadEndFtraceEvent & from)4343 TrustyIpcReadEndFtraceEvent::TrustyIpcReadEndFtraceEvent(const TrustyIpcReadEndFtraceEvent& from)
4344 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
4345 TrustyIpcReadEndFtraceEvent* const _this = this; (void)_this;
4346 new (&_impl_) Impl_{
4347 decltype(_impl_._has_bits_){from._impl_._has_bits_}
4348 , /*decltype(_impl_._cached_size_)*/{}
4349 , decltype(_impl_.srv_name_){}
4350 , decltype(_impl_.buf_id_){}
4351 , decltype(_impl_.chan_){}
4352 , decltype(_impl_.len_or_err_){}
4353 , decltype(_impl_.shm_cnt_){}};
4354
4355 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
4356 _impl_.srv_name_.InitDefault();
4357 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4358 _impl_.srv_name_.Set("", GetArenaForAllocation());
4359 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4360 if (from._internal_has_srv_name()) {
4361 _this->_impl_.srv_name_.Set(from._internal_srv_name(),
4362 _this->GetArenaForAllocation());
4363 }
4364 ::memcpy(&_impl_.buf_id_, &from._impl_.buf_id_,
4365 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.shm_cnt_) -
4366 reinterpret_cast<char*>(&_impl_.buf_id_)) + sizeof(_impl_.shm_cnt_));
4367 // @@protoc_insertion_point(copy_constructor:perfetto.protos.TrustyIpcReadEndFtraceEvent)
4368 }
4369
SharedCtor(::_pb::Arena * arena,bool is_message_owned)4370 inline void TrustyIpcReadEndFtraceEvent::SharedCtor(
4371 ::_pb::Arena* arena, bool is_message_owned) {
4372 (void)arena;
4373 (void)is_message_owned;
4374 new (&_impl_) Impl_{
4375 decltype(_impl_._has_bits_){}
4376 , /*decltype(_impl_._cached_size_)*/{}
4377 , decltype(_impl_.srv_name_){}
4378 , decltype(_impl_.buf_id_){::uint64_t{0u}}
4379 , decltype(_impl_.chan_){0u}
4380 , decltype(_impl_.len_or_err_){0}
4381 , decltype(_impl_.shm_cnt_){::uint64_t{0u}}
4382 };
4383 _impl_.srv_name_.InitDefault();
4384 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4385 _impl_.srv_name_.Set("", GetArenaForAllocation());
4386 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4387 }
4388
~TrustyIpcReadEndFtraceEvent()4389 TrustyIpcReadEndFtraceEvent::~TrustyIpcReadEndFtraceEvent() {
4390 // @@protoc_insertion_point(destructor:perfetto.protos.TrustyIpcReadEndFtraceEvent)
4391 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
4392 (void)arena;
4393 return;
4394 }
4395 SharedDtor();
4396 }
4397
SharedDtor()4398 inline void TrustyIpcReadEndFtraceEvent::SharedDtor() {
4399 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
4400 _impl_.srv_name_.Destroy();
4401 }
4402
SetCachedSize(int size) const4403 void TrustyIpcReadEndFtraceEvent::SetCachedSize(int size) const {
4404 _impl_._cached_size_.Set(size);
4405 }
4406
Clear()4407 void TrustyIpcReadEndFtraceEvent::Clear() {
4408 // @@protoc_insertion_point(message_clear_start:perfetto.protos.TrustyIpcReadEndFtraceEvent)
4409 ::uint32_t cached_has_bits = 0;
4410 // Prevent compiler warnings about cached_has_bits being unused
4411 (void) cached_has_bits;
4412
4413 cached_has_bits = _impl_._has_bits_[0];
4414 if (cached_has_bits & 0x00000001u) {
4415 _impl_.srv_name_.ClearNonDefaultToEmpty();
4416 }
4417 if (cached_has_bits & 0x0000001eu) {
4418 ::memset(&_impl_.buf_id_, 0, static_cast<size_t>(
4419 reinterpret_cast<char*>(&_impl_.shm_cnt_) -
4420 reinterpret_cast<char*>(&_impl_.buf_id_)) + sizeof(_impl_.shm_cnt_));
4421 }
4422 _impl_._has_bits_.Clear();
4423 _internal_metadata_.Clear<std::string>();
4424 }
4425
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)4426 const char* TrustyIpcReadEndFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
4427 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
4428 _Internal::HasBits has_bits{};
4429 while (!ctx->Done(&ptr)) {
4430 ::uint32_t tag;
4431 ptr = ::_pbi::ReadTag(ptr, &tag);
4432 switch (tag >> 3) {
4433 // optional uint64 buf_id = 1;
4434 case 1:
4435 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
4436 _Internal::set_has_buf_id(&has_bits);
4437 _impl_.buf_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
4438 CHK_(ptr);
4439 } else {
4440 goto handle_unusual;
4441 }
4442 continue;
4443 // optional uint32 chan = 2;
4444 case 2:
4445 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
4446 _Internal::set_has_chan(&has_bits);
4447 _impl_.chan_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
4448 CHK_(ptr);
4449 } else {
4450 goto handle_unusual;
4451 }
4452 continue;
4453 // optional int32 len_or_err = 3;
4454 case 3:
4455 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
4456 _Internal::set_has_len_or_err(&has_bits);
4457 _impl_.len_or_err_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
4458 CHK_(ptr);
4459 } else {
4460 goto handle_unusual;
4461 }
4462 continue;
4463 // optional uint64 shm_cnt = 4;
4464 case 4:
4465 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
4466 _Internal::set_has_shm_cnt(&has_bits);
4467 _impl_.shm_cnt_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
4468 CHK_(ptr);
4469 } else {
4470 goto handle_unusual;
4471 }
4472 continue;
4473 // optional string srv_name = 5;
4474 case 5:
4475 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 42)) {
4476 auto str = _internal_mutable_srv_name();
4477 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
4478 CHK_(ptr);
4479 } else {
4480 goto handle_unusual;
4481 }
4482 continue;
4483 default:
4484 goto handle_unusual;
4485 } // switch
4486 handle_unusual:
4487 if ((tag == 0) || ((tag & 7) == 4)) {
4488 CHK_(ptr);
4489 ctx->SetLastTag(tag);
4490 goto message_done;
4491 }
4492 ptr = UnknownFieldParse(
4493 tag,
4494 _internal_metadata_.mutable_unknown_fields<std::string>(),
4495 ptr, ctx);
4496 CHK_(ptr != nullptr);
4497 } // while
4498 message_done:
4499 _impl_._has_bits_.Or(has_bits);
4500 return ptr;
4501 failure:
4502 ptr = nullptr;
4503 goto message_done;
4504 #undef CHK_
4505 }
4506
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const4507 ::uint8_t* TrustyIpcReadEndFtraceEvent::_InternalSerialize(
4508 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
4509 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.TrustyIpcReadEndFtraceEvent)
4510 ::uint32_t cached_has_bits = 0;
4511 (void) cached_has_bits;
4512
4513 cached_has_bits = _impl_._has_bits_[0];
4514 // optional uint64 buf_id = 1;
4515 if (cached_has_bits & 0x00000002u) {
4516 target = stream->EnsureSpace(target);
4517 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_buf_id(), target);
4518 }
4519
4520 // optional uint32 chan = 2;
4521 if (cached_has_bits & 0x00000004u) {
4522 target = stream->EnsureSpace(target);
4523 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_chan(), target);
4524 }
4525
4526 // optional int32 len_or_err = 3;
4527 if (cached_has_bits & 0x00000008u) {
4528 target = stream->EnsureSpace(target);
4529 target = ::_pbi::WireFormatLite::WriteInt32ToArray(3, this->_internal_len_or_err(), target);
4530 }
4531
4532 // optional uint64 shm_cnt = 4;
4533 if (cached_has_bits & 0x00000010u) {
4534 target = stream->EnsureSpace(target);
4535 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(4, this->_internal_shm_cnt(), target);
4536 }
4537
4538 // optional string srv_name = 5;
4539 if (cached_has_bits & 0x00000001u) {
4540 target = stream->WriteStringMaybeAliased(
4541 5, this->_internal_srv_name(), target);
4542 }
4543
4544 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
4545 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
4546 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
4547 }
4548 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.TrustyIpcReadEndFtraceEvent)
4549 return target;
4550 }
4551
ByteSizeLong() const4552 size_t TrustyIpcReadEndFtraceEvent::ByteSizeLong() const {
4553 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.TrustyIpcReadEndFtraceEvent)
4554 size_t total_size = 0;
4555
4556 ::uint32_t cached_has_bits = 0;
4557 // Prevent compiler warnings about cached_has_bits being unused
4558 (void) cached_has_bits;
4559
4560 cached_has_bits = _impl_._has_bits_[0];
4561 if (cached_has_bits & 0x0000001fu) {
4562 // optional string srv_name = 5;
4563 if (cached_has_bits & 0x00000001u) {
4564 total_size += 1 +
4565 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
4566 this->_internal_srv_name());
4567 }
4568
4569 // optional uint64 buf_id = 1;
4570 if (cached_has_bits & 0x00000002u) {
4571 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_buf_id());
4572 }
4573
4574 // optional uint32 chan = 2;
4575 if (cached_has_bits & 0x00000004u) {
4576 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_chan());
4577 }
4578
4579 // optional int32 len_or_err = 3;
4580 if (cached_has_bits & 0x00000008u) {
4581 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_len_or_err());
4582 }
4583
4584 // optional uint64 shm_cnt = 4;
4585 if (cached_has_bits & 0x00000010u) {
4586 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_shm_cnt());
4587 }
4588
4589 }
4590 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
4591 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
4592 }
4593 int cached_size = ::_pbi::ToCachedSize(total_size);
4594 SetCachedSize(cached_size);
4595 return total_size;
4596 }
4597
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)4598 void TrustyIpcReadEndFtraceEvent::CheckTypeAndMergeFrom(
4599 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
4600 MergeFrom(*::_pbi::DownCast<const TrustyIpcReadEndFtraceEvent*>(
4601 &from));
4602 }
4603
MergeFrom(const TrustyIpcReadEndFtraceEvent & from)4604 void TrustyIpcReadEndFtraceEvent::MergeFrom(const TrustyIpcReadEndFtraceEvent& from) {
4605 TrustyIpcReadEndFtraceEvent* const _this = this;
4606 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.TrustyIpcReadEndFtraceEvent)
4607 GOOGLE_DCHECK_NE(&from, _this);
4608 ::uint32_t cached_has_bits = 0;
4609 (void) cached_has_bits;
4610
4611 cached_has_bits = from._impl_._has_bits_[0];
4612 if (cached_has_bits & 0x0000001fu) {
4613 if (cached_has_bits & 0x00000001u) {
4614 _this->_internal_set_srv_name(from._internal_srv_name());
4615 }
4616 if (cached_has_bits & 0x00000002u) {
4617 _this->_impl_.buf_id_ = from._impl_.buf_id_;
4618 }
4619 if (cached_has_bits & 0x00000004u) {
4620 _this->_impl_.chan_ = from._impl_.chan_;
4621 }
4622 if (cached_has_bits & 0x00000008u) {
4623 _this->_impl_.len_or_err_ = from._impl_.len_or_err_;
4624 }
4625 if (cached_has_bits & 0x00000010u) {
4626 _this->_impl_.shm_cnt_ = from._impl_.shm_cnt_;
4627 }
4628 _this->_impl_._has_bits_[0] |= cached_has_bits;
4629 }
4630 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
4631 }
4632
CopyFrom(const TrustyIpcReadEndFtraceEvent & from)4633 void TrustyIpcReadEndFtraceEvent::CopyFrom(const TrustyIpcReadEndFtraceEvent& from) {
4634 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.TrustyIpcReadEndFtraceEvent)
4635 if (&from == this) return;
4636 Clear();
4637 MergeFrom(from);
4638 }
4639
IsInitialized() const4640 bool TrustyIpcReadEndFtraceEvent::IsInitialized() const {
4641 return true;
4642 }
4643
InternalSwap(TrustyIpcReadEndFtraceEvent * other)4644 void TrustyIpcReadEndFtraceEvent::InternalSwap(TrustyIpcReadEndFtraceEvent* other) {
4645 using std::swap;
4646 auto* lhs_arena = GetArenaForAllocation();
4647 auto* rhs_arena = other->GetArenaForAllocation();
4648 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
4649 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
4650 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
4651 &_impl_.srv_name_, lhs_arena,
4652 &other->_impl_.srv_name_, rhs_arena
4653 );
4654 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
4655 PROTOBUF_FIELD_OFFSET(TrustyIpcReadEndFtraceEvent, _impl_.shm_cnt_)
4656 + sizeof(TrustyIpcReadEndFtraceEvent::_impl_.shm_cnt_) // NOLINT
4657 - PROTOBUF_FIELD_OFFSET(TrustyIpcReadEndFtraceEvent, _impl_.buf_id_)>(
4658 reinterpret_cast<char*>(&_impl_.buf_id_),
4659 reinterpret_cast<char*>(&other->_impl_.buf_id_));
4660 }
4661
GetTypeName() const4662 std::string TrustyIpcReadEndFtraceEvent::GetTypeName() const {
4663 return "perfetto.protos.TrustyIpcReadEndFtraceEvent";
4664 }
4665
4666
4667 // ===================================================================
4668
4669 class TrustyIpcRxFtraceEvent::_Internal {
4670 public:
4671 using HasBits = decltype(std::declval<TrustyIpcRxFtraceEvent>()._impl_._has_bits_);
set_has_buf_id(HasBits * has_bits)4672 static void set_has_buf_id(HasBits* has_bits) {
4673 (*has_bits)[0] |= 2u;
4674 }
set_has_chan(HasBits * has_bits)4675 static void set_has_chan(HasBits* has_bits) {
4676 (*has_bits)[0] |= 4u;
4677 }
set_has_srv_name(HasBits * has_bits)4678 static void set_has_srv_name(HasBits* has_bits) {
4679 (*has_bits)[0] |= 1u;
4680 }
4681 };
4682
TrustyIpcRxFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)4683 TrustyIpcRxFtraceEvent::TrustyIpcRxFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
4684 bool is_message_owned)
4685 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
4686 SharedCtor(arena, is_message_owned);
4687 // @@protoc_insertion_point(arena_constructor:perfetto.protos.TrustyIpcRxFtraceEvent)
4688 }
TrustyIpcRxFtraceEvent(const TrustyIpcRxFtraceEvent & from)4689 TrustyIpcRxFtraceEvent::TrustyIpcRxFtraceEvent(const TrustyIpcRxFtraceEvent& from)
4690 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
4691 TrustyIpcRxFtraceEvent* const _this = this; (void)_this;
4692 new (&_impl_) Impl_{
4693 decltype(_impl_._has_bits_){from._impl_._has_bits_}
4694 , /*decltype(_impl_._cached_size_)*/{}
4695 , decltype(_impl_.srv_name_){}
4696 , decltype(_impl_.buf_id_){}
4697 , decltype(_impl_.chan_){}};
4698
4699 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
4700 _impl_.srv_name_.InitDefault();
4701 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4702 _impl_.srv_name_.Set("", GetArenaForAllocation());
4703 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4704 if (from._internal_has_srv_name()) {
4705 _this->_impl_.srv_name_.Set(from._internal_srv_name(),
4706 _this->GetArenaForAllocation());
4707 }
4708 ::memcpy(&_impl_.buf_id_, &from._impl_.buf_id_,
4709 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.chan_) -
4710 reinterpret_cast<char*>(&_impl_.buf_id_)) + sizeof(_impl_.chan_));
4711 // @@protoc_insertion_point(copy_constructor:perfetto.protos.TrustyIpcRxFtraceEvent)
4712 }
4713
SharedCtor(::_pb::Arena * arena,bool is_message_owned)4714 inline void TrustyIpcRxFtraceEvent::SharedCtor(
4715 ::_pb::Arena* arena, bool is_message_owned) {
4716 (void)arena;
4717 (void)is_message_owned;
4718 new (&_impl_) Impl_{
4719 decltype(_impl_._has_bits_){}
4720 , /*decltype(_impl_._cached_size_)*/{}
4721 , decltype(_impl_.srv_name_){}
4722 , decltype(_impl_.buf_id_){::uint64_t{0u}}
4723 , decltype(_impl_.chan_){0u}
4724 };
4725 _impl_.srv_name_.InitDefault();
4726 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4727 _impl_.srv_name_.Set("", GetArenaForAllocation());
4728 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4729 }
4730
~TrustyIpcRxFtraceEvent()4731 TrustyIpcRxFtraceEvent::~TrustyIpcRxFtraceEvent() {
4732 // @@protoc_insertion_point(destructor:perfetto.protos.TrustyIpcRxFtraceEvent)
4733 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
4734 (void)arena;
4735 return;
4736 }
4737 SharedDtor();
4738 }
4739
SharedDtor()4740 inline void TrustyIpcRxFtraceEvent::SharedDtor() {
4741 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
4742 _impl_.srv_name_.Destroy();
4743 }
4744
SetCachedSize(int size) const4745 void TrustyIpcRxFtraceEvent::SetCachedSize(int size) const {
4746 _impl_._cached_size_.Set(size);
4747 }
4748
Clear()4749 void TrustyIpcRxFtraceEvent::Clear() {
4750 // @@protoc_insertion_point(message_clear_start:perfetto.protos.TrustyIpcRxFtraceEvent)
4751 ::uint32_t cached_has_bits = 0;
4752 // Prevent compiler warnings about cached_has_bits being unused
4753 (void) cached_has_bits;
4754
4755 cached_has_bits = _impl_._has_bits_[0];
4756 if (cached_has_bits & 0x00000001u) {
4757 _impl_.srv_name_.ClearNonDefaultToEmpty();
4758 }
4759 if (cached_has_bits & 0x00000006u) {
4760 ::memset(&_impl_.buf_id_, 0, static_cast<size_t>(
4761 reinterpret_cast<char*>(&_impl_.chan_) -
4762 reinterpret_cast<char*>(&_impl_.buf_id_)) + sizeof(_impl_.chan_));
4763 }
4764 _impl_._has_bits_.Clear();
4765 _internal_metadata_.Clear<std::string>();
4766 }
4767
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)4768 const char* TrustyIpcRxFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
4769 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
4770 _Internal::HasBits has_bits{};
4771 while (!ctx->Done(&ptr)) {
4772 ::uint32_t tag;
4773 ptr = ::_pbi::ReadTag(ptr, &tag);
4774 switch (tag >> 3) {
4775 // optional uint64 buf_id = 1;
4776 case 1:
4777 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
4778 _Internal::set_has_buf_id(&has_bits);
4779 _impl_.buf_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
4780 CHK_(ptr);
4781 } else {
4782 goto handle_unusual;
4783 }
4784 continue;
4785 // optional uint32 chan = 2;
4786 case 2:
4787 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
4788 _Internal::set_has_chan(&has_bits);
4789 _impl_.chan_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
4790 CHK_(ptr);
4791 } else {
4792 goto handle_unusual;
4793 }
4794 continue;
4795 // optional string srv_name = 3;
4796 case 3:
4797 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
4798 auto str = _internal_mutable_srv_name();
4799 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
4800 CHK_(ptr);
4801 } else {
4802 goto handle_unusual;
4803 }
4804 continue;
4805 default:
4806 goto handle_unusual;
4807 } // switch
4808 handle_unusual:
4809 if ((tag == 0) || ((tag & 7) == 4)) {
4810 CHK_(ptr);
4811 ctx->SetLastTag(tag);
4812 goto message_done;
4813 }
4814 ptr = UnknownFieldParse(
4815 tag,
4816 _internal_metadata_.mutable_unknown_fields<std::string>(),
4817 ptr, ctx);
4818 CHK_(ptr != nullptr);
4819 } // while
4820 message_done:
4821 _impl_._has_bits_.Or(has_bits);
4822 return ptr;
4823 failure:
4824 ptr = nullptr;
4825 goto message_done;
4826 #undef CHK_
4827 }
4828
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const4829 ::uint8_t* TrustyIpcRxFtraceEvent::_InternalSerialize(
4830 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
4831 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.TrustyIpcRxFtraceEvent)
4832 ::uint32_t cached_has_bits = 0;
4833 (void) cached_has_bits;
4834
4835 cached_has_bits = _impl_._has_bits_[0];
4836 // optional uint64 buf_id = 1;
4837 if (cached_has_bits & 0x00000002u) {
4838 target = stream->EnsureSpace(target);
4839 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_buf_id(), target);
4840 }
4841
4842 // optional uint32 chan = 2;
4843 if (cached_has_bits & 0x00000004u) {
4844 target = stream->EnsureSpace(target);
4845 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_chan(), target);
4846 }
4847
4848 // optional string srv_name = 3;
4849 if (cached_has_bits & 0x00000001u) {
4850 target = stream->WriteStringMaybeAliased(
4851 3, this->_internal_srv_name(), target);
4852 }
4853
4854 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
4855 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
4856 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
4857 }
4858 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.TrustyIpcRxFtraceEvent)
4859 return target;
4860 }
4861
ByteSizeLong() const4862 size_t TrustyIpcRxFtraceEvent::ByteSizeLong() const {
4863 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.TrustyIpcRxFtraceEvent)
4864 size_t total_size = 0;
4865
4866 ::uint32_t cached_has_bits = 0;
4867 // Prevent compiler warnings about cached_has_bits being unused
4868 (void) cached_has_bits;
4869
4870 cached_has_bits = _impl_._has_bits_[0];
4871 if (cached_has_bits & 0x00000007u) {
4872 // optional string srv_name = 3;
4873 if (cached_has_bits & 0x00000001u) {
4874 total_size += 1 +
4875 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
4876 this->_internal_srv_name());
4877 }
4878
4879 // optional uint64 buf_id = 1;
4880 if (cached_has_bits & 0x00000002u) {
4881 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_buf_id());
4882 }
4883
4884 // optional uint32 chan = 2;
4885 if (cached_has_bits & 0x00000004u) {
4886 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_chan());
4887 }
4888
4889 }
4890 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
4891 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
4892 }
4893 int cached_size = ::_pbi::ToCachedSize(total_size);
4894 SetCachedSize(cached_size);
4895 return total_size;
4896 }
4897
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)4898 void TrustyIpcRxFtraceEvent::CheckTypeAndMergeFrom(
4899 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
4900 MergeFrom(*::_pbi::DownCast<const TrustyIpcRxFtraceEvent*>(
4901 &from));
4902 }
4903
MergeFrom(const TrustyIpcRxFtraceEvent & from)4904 void TrustyIpcRxFtraceEvent::MergeFrom(const TrustyIpcRxFtraceEvent& from) {
4905 TrustyIpcRxFtraceEvent* const _this = this;
4906 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.TrustyIpcRxFtraceEvent)
4907 GOOGLE_DCHECK_NE(&from, _this);
4908 ::uint32_t cached_has_bits = 0;
4909 (void) cached_has_bits;
4910
4911 cached_has_bits = from._impl_._has_bits_[0];
4912 if (cached_has_bits & 0x00000007u) {
4913 if (cached_has_bits & 0x00000001u) {
4914 _this->_internal_set_srv_name(from._internal_srv_name());
4915 }
4916 if (cached_has_bits & 0x00000002u) {
4917 _this->_impl_.buf_id_ = from._impl_.buf_id_;
4918 }
4919 if (cached_has_bits & 0x00000004u) {
4920 _this->_impl_.chan_ = from._impl_.chan_;
4921 }
4922 _this->_impl_._has_bits_[0] |= cached_has_bits;
4923 }
4924 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
4925 }
4926
CopyFrom(const TrustyIpcRxFtraceEvent & from)4927 void TrustyIpcRxFtraceEvent::CopyFrom(const TrustyIpcRxFtraceEvent& from) {
4928 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.TrustyIpcRxFtraceEvent)
4929 if (&from == this) return;
4930 Clear();
4931 MergeFrom(from);
4932 }
4933
IsInitialized() const4934 bool TrustyIpcRxFtraceEvent::IsInitialized() const {
4935 return true;
4936 }
4937
InternalSwap(TrustyIpcRxFtraceEvent * other)4938 void TrustyIpcRxFtraceEvent::InternalSwap(TrustyIpcRxFtraceEvent* other) {
4939 using std::swap;
4940 auto* lhs_arena = GetArenaForAllocation();
4941 auto* rhs_arena = other->GetArenaForAllocation();
4942 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
4943 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
4944 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
4945 &_impl_.srv_name_, lhs_arena,
4946 &other->_impl_.srv_name_, rhs_arena
4947 );
4948 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
4949 PROTOBUF_FIELD_OFFSET(TrustyIpcRxFtraceEvent, _impl_.chan_)
4950 + sizeof(TrustyIpcRxFtraceEvent::_impl_.chan_) // NOLINT
4951 - PROTOBUF_FIELD_OFFSET(TrustyIpcRxFtraceEvent, _impl_.buf_id_)>(
4952 reinterpret_cast<char*>(&_impl_.buf_id_),
4953 reinterpret_cast<char*>(&other->_impl_.buf_id_));
4954 }
4955
GetTypeName() const4956 std::string TrustyIpcRxFtraceEvent::GetTypeName() const {
4957 return "perfetto.protos.TrustyIpcRxFtraceEvent";
4958 }
4959
4960
4961 // ===================================================================
4962
4963 class TrustyEnqueueNopFtraceEvent::_Internal {
4964 public:
4965 using HasBits = decltype(std::declval<TrustyEnqueueNopFtraceEvent>()._impl_._has_bits_);
set_has_arg1(HasBits * has_bits)4966 static void set_has_arg1(HasBits* has_bits) {
4967 (*has_bits)[0] |= 1u;
4968 }
set_has_arg2(HasBits * has_bits)4969 static void set_has_arg2(HasBits* has_bits) {
4970 (*has_bits)[0] |= 2u;
4971 }
set_has_arg3(HasBits * has_bits)4972 static void set_has_arg3(HasBits* has_bits) {
4973 (*has_bits)[0] |= 4u;
4974 }
4975 };
4976
TrustyEnqueueNopFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)4977 TrustyEnqueueNopFtraceEvent::TrustyEnqueueNopFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
4978 bool is_message_owned)
4979 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
4980 SharedCtor(arena, is_message_owned);
4981 // @@protoc_insertion_point(arena_constructor:perfetto.protos.TrustyEnqueueNopFtraceEvent)
4982 }
TrustyEnqueueNopFtraceEvent(const TrustyEnqueueNopFtraceEvent & from)4983 TrustyEnqueueNopFtraceEvent::TrustyEnqueueNopFtraceEvent(const TrustyEnqueueNopFtraceEvent& from)
4984 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
4985 TrustyEnqueueNopFtraceEvent* const _this = this; (void)_this;
4986 new (&_impl_) Impl_{
4987 decltype(_impl_._has_bits_){from._impl_._has_bits_}
4988 , /*decltype(_impl_._cached_size_)*/{}
4989 , decltype(_impl_.arg1_){}
4990 , decltype(_impl_.arg2_){}
4991 , decltype(_impl_.arg3_){}};
4992
4993 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
4994 ::memcpy(&_impl_.arg1_, &from._impl_.arg1_,
4995 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.arg3_) -
4996 reinterpret_cast<char*>(&_impl_.arg1_)) + sizeof(_impl_.arg3_));
4997 // @@protoc_insertion_point(copy_constructor:perfetto.protos.TrustyEnqueueNopFtraceEvent)
4998 }
4999
SharedCtor(::_pb::Arena * arena,bool is_message_owned)5000 inline void TrustyEnqueueNopFtraceEvent::SharedCtor(
5001 ::_pb::Arena* arena, bool is_message_owned) {
5002 (void)arena;
5003 (void)is_message_owned;
5004 new (&_impl_) Impl_{
5005 decltype(_impl_._has_bits_){}
5006 , /*decltype(_impl_._cached_size_)*/{}
5007 , decltype(_impl_.arg1_){0u}
5008 , decltype(_impl_.arg2_){0u}
5009 , decltype(_impl_.arg3_){0u}
5010 };
5011 }
5012
~TrustyEnqueueNopFtraceEvent()5013 TrustyEnqueueNopFtraceEvent::~TrustyEnqueueNopFtraceEvent() {
5014 // @@protoc_insertion_point(destructor:perfetto.protos.TrustyEnqueueNopFtraceEvent)
5015 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
5016 (void)arena;
5017 return;
5018 }
5019 SharedDtor();
5020 }
5021
SharedDtor()5022 inline void TrustyEnqueueNopFtraceEvent::SharedDtor() {
5023 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
5024 }
5025
SetCachedSize(int size) const5026 void TrustyEnqueueNopFtraceEvent::SetCachedSize(int size) const {
5027 _impl_._cached_size_.Set(size);
5028 }
5029
Clear()5030 void TrustyEnqueueNopFtraceEvent::Clear() {
5031 // @@protoc_insertion_point(message_clear_start:perfetto.protos.TrustyEnqueueNopFtraceEvent)
5032 ::uint32_t cached_has_bits = 0;
5033 // Prevent compiler warnings about cached_has_bits being unused
5034 (void) cached_has_bits;
5035
5036 cached_has_bits = _impl_._has_bits_[0];
5037 if (cached_has_bits & 0x00000007u) {
5038 ::memset(&_impl_.arg1_, 0, static_cast<size_t>(
5039 reinterpret_cast<char*>(&_impl_.arg3_) -
5040 reinterpret_cast<char*>(&_impl_.arg1_)) + sizeof(_impl_.arg3_));
5041 }
5042 _impl_._has_bits_.Clear();
5043 _internal_metadata_.Clear<std::string>();
5044 }
5045
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)5046 const char* TrustyEnqueueNopFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
5047 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
5048 _Internal::HasBits has_bits{};
5049 while (!ctx->Done(&ptr)) {
5050 ::uint32_t tag;
5051 ptr = ::_pbi::ReadTag(ptr, &tag);
5052 switch (tag >> 3) {
5053 // optional uint32 arg1 = 1;
5054 case 1:
5055 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
5056 _Internal::set_has_arg1(&has_bits);
5057 _impl_.arg1_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
5058 CHK_(ptr);
5059 } else {
5060 goto handle_unusual;
5061 }
5062 continue;
5063 // optional uint32 arg2 = 2;
5064 case 2:
5065 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
5066 _Internal::set_has_arg2(&has_bits);
5067 _impl_.arg2_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
5068 CHK_(ptr);
5069 } else {
5070 goto handle_unusual;
5071 }
5072 continue;
5073 // optional uint32 arg3 = 3;
5074 case 3:
5075 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
5076 _Internal::set_has_arg3(&has_bits);
5077 _impl_.arg3_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
5078 CHK_(ptr);
5079 } else {
5080 goto handle_unusual;
5081 }
5082 continue;
5083 default:
5084 goto handle_unusual;
5085 } // switch
5086 handle_unusual:
5087 if ((tag == 0) || ((tag & 7) == 4)) {
5088 CHK_(ptr);
5089 ctx->SetLastTag(tag);
5090 goto message_done;
5091 }
5092 ptr = UnknownFieldParse(
5093 tag,
5094 _internal_metadata_.mutable_unknown_fields<std::string>(),
5095 ptr, ctx);
5096 CHK_(ptr != nullptr);
5097 } // while
5098 message_done:
5099 _impl_._has_bits_.Or(has_bits);
5100 return ptr;
5101 failure:
5102 ptr = nullptr;
5103 goto message_done;
5104 #undef CHK_
5105 }
5106
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const5107 ::uint8_t* TrustyEnqueueNopFtraceEvent::_InternalSerialize(
5108 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
5109 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.TrustyEnqueueNopFtraceEvent)
5110 ::uint32_t cached_has_bits = 0;
5111 (void) cached_has_bits;
5112
5113 cached_has_bits = _impl_._has_bits_[0];
5114 // optional uint32 arg1 = 1;
5115 if (cached_has_bits & 0x00000001u) {
5116 target = stream->EnsureSpace(target);
5117 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_arg1(), target);
5118 }
5119
5120 // optional uint32 arg2 = 2;
5121 if (cached_has_bits & 0x00000002u) {
5122 target = stream->EnsureSpace(target);
5123 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_arg2(), target);
5124 }
5125
5126 // optional uint32 arg3 = 3;
5127 if (cached_has_bits & 0x00000004u) {
5128 target = stream->EnsureSpace(target);
5129 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_arg3(), target);
5130 }
5131
5132 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
5133 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
5134 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
5135 }
5136 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.TrustyEnqueueNopFtraceEvent)
5137 return target;
5138 }
5139
ByteSizeLong() const5140 size_t TrustyEnqueueNopFtraceEvent::ByteSizeLong() const {
5141 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.TrustyEnqueueNopFtraceEvent)
5142 size_t total_size = 0;
5143
5144 ::uint32_t cached_has_bits = 0;
5145 // Prevent compiler warnings about cached_has_bits being unused
5146 (void) cached_has_bits;
5147
5148 cached_has_bits = _impl_._has_bits_[0];
5149 if (cached_has_bits & 0x00000007u) {
5150 // optional uint32 arg1 = 1;
5151 if (cached_has_bits & 0x00000001u) {
5152 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_arg1());
5153 }
5154
5155 // optional uint32 arg2 = 2;
5156 if (cached_has_bits & 0x00000002u) {
5157 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_arg2());
5158 }
5159
5160 // optional uint32 arg3 = 3;
5161 if (cached_has_bits & 0x00000004u) {
5162 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_arg3());
5163 }
5164
5165 }
5166 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
5167 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
5168 }
5169 int cached_size = ::_pbi::ToCachedSize(total_size);
5170 SetCachedSize(cached_size);
5171 return total_size;
5172 }
5173
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)5174 void TrustyEnqueueNopFtraceEvent::CheckTypeAndMergeFrom(
5175 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
5176 MergeFrom(*::_pbi::DownCast<const TrustyEnqueueNopFtraceEvent*>(
5177 &from));
5178 }
5179
MergeFrom(const TrustyEnqueueNopFtraceEvent & from)5180 void TrustyEnqueueNopFtraceEvent::MergeFrom(const TrustyEnqueueNopFtraceEvent& from) {
5181 TrustyEnqueueNopFtraceEvent* const _this = this;
5182 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.TrustyEnqueueNopFtraceEvent)
5183 GOOGLE_DCHECK_NE(&from, _this);
5184 ::uint32_t cached_has_bits = 0;
5185 (void) cached_has_bits;
5186
5187 cached_has_bits = from._impl_._has_bits_[0];
5188 if (cached_has_bits & 0x00000007u) {
5189 if (cached_has_bits & 0x00000001u) {
5190 _this->_impl_.arg1_ = from._impl_.arg1_;
5191 }
5192 if (cached_has_bits & 0x00000002u) {
5193 _this->_impl_.arg2_ = from._impl_.arg2_;
5194 }
5195 if (cached_has_bits & 0x00000004u) {
5196 _this->_impl_.arg3_ = from._impl_.arg3_;
5197 }
5198 _this->_impl_._has_bits_[0] |= cached_has_bits;
5199 }
5200 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
5201 }
5202
CopyFrom(const TrustyEnqueueNopFtraceEvent & from)5203 void TrustyEnqueueNopFtraceEvent::CopyFrom(const TrustyEnqueueNopFtraceEvent& from) {
5204 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.TrustyEnqueueNopFtraceEvent)
5205 if (&from == this) return;
5206 Clear();
5207 MergeFrom(from);
5208 }
5209
IsInitialized() const5210 bool TrustyEnqueueNopFtraceEvent::IsInitialized() const {
5211 return true;
5212 }
5213
InternalSwap(TrustyEnqueueNopFtraceEvent * other)5214 void TrustyEnqueueNopFtraceEvent::InternalSwap(TrustyEnqueueNopFtraceEvent* other) {
5215 using std::swap;
5216 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
5217 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
5218 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
5219 PROTOBUF_FIELD_OFFSET(TrustyEnqueueNopFtraceEvent, _impl_.arg3_)
5220 + sizeof(TrustyEnqueueNopFtraceEvent::_impl_.arg3_) // NOLINT
5221 - PROTOBUF_FIELD_OFFSET(TrustyEnqueueNopFtraceEvent, _impl_.arg1_)>(
5222 reinterpret_cast<char*>(&_impl_.arg1_),
5223 reinterpret_cast<char*>(&other->_impl_.arg1_));
5224 }
5225
GetTypeName() const5226 std::string TrustyEnqueueNopFtraceEvent::GetTypeName() const {
5227 return "perfetto.protos.TrustyEnqueueNopFtraceEvent";
5228 }
5229
5230
5231 // @@protoc_insertion_point(namespace_scope)
5232 } // namespace protos
5233 } // namespace perfetto
5234 PROTOBUF_NAMESPACE_OPEN
5235 template<> PROTOBUF_NOINLINE ::perfetto::protos::TrustySmcFtraceEvent*
CreateMaybeMessage(Arena * arena)5236 Arena::CreateMaybeMessage< ::perfetto::protos::TrustySmcFtraceEvent >(Arena* arena) {
5237 return Arena::CreateMessageInternal< ::perfetto::protos::TrustySmcFtraceEvent >(arena);
5238 }
5239 template<> PROTOBUF_NOINLINE ::perfetto::protos::TrustySmcDoneFtraceEvent*
CreateMaybeMessage(Arena * arena)5240 Arena::CreateMaybeMessage< ::perfetto::protos::TrustySmcDoneFtraceEvent >(Arena* arena) {
5241 return Arena::CreateMessageInternal< ::perfetto::protos::TrustySmcDoneFtraceEvent >(arena);
5242 }
5243 template<> PROTOBUF_NOINLINE ::perfetto::protos::TrustyStdCall32FtraceEvent*
CreateMaybeMessage(Arena * arena)5244 Arena::CreateMaybeMessage< ::perfetto::protos::TrustyStdCall32FtraceEvent >(Arena* arena) {
5245 return Arena::CreateMessageInternal< ::perfetto::protos::TrustyStdCall32FtraceEvent >(arena);
5246 }
5247 template<> PROTOBUF_NOINLINE ::perfetto::protos::TrustyStdCall32DoneFtraceEvent*
CreateMaybeMessage(Arena * arena)5248 Arena::CreateMaybeMessage< ::perfetto::protos::TrustyStdCall32DoneFtraceEvent >(Arena* arena) {
5249 return Arena::CreateMessageInternal< ::perfetto::protos::TrustyStdCall32DoneFtraceEvent >(arena);
5250 }
5251 template<> PROTOBUF_NOINLINE ::perfetto::protos::TrustyShareMemoryFtraceEvent*
CreateMaybeMessage(Arena * arena)5252 Arena::CreateMaybeMessage< ::perfetto::protos::TrustyShareMemoryFtraceEvent >(Arena* arena) {
5253 return Arena::CreateMessageInternal< ::perfetto::protos::TrustyShareMemoryFtraceEvent >(arena);
5254 }
5255 template<> PROTOBUF_NOINLINE ::perfetto::protos::TrustyShareMemoryDoneFtraceEvent*
CreateMaybeMessage(Arena * arena)5256 Arena::CreateMaybeMessage< ::perfetto::protos::TrustyShareMemoryDoneFtraceEvent >(Arena* arena) {
5257 return Arena::CreateMessageInternal< ::perfetto::protos::TrustyShareMemoryDoneFtraceEvent >(arena);
5258 }
5259 template<> PROTOBUF_NOINLINE ::perfetto::protos::TrustyReclaimMemoryFtraceEvent*
CreateMaybeMessage(Arena * arena)5260 Arena::CreateMaybeMessage< ::perfetto::protos::TrustyReclaimMemoryFtraceEvent >(Arena* arena) {
5261 return Arena::CreateMessageInternal< ::perfetto::protos::TrustyReclaimMemoryFtraceEvent >(arena);
5262 }
5263 template<> PROTOBUF_NOINLINE ::perfetto::protos::TrustyReclaimMemoryDoneFtraceEvent*
CreateMaybeMessage(Arena * arena)5264 Arena::CreateMaybeMessage< ::perfetto::protos::TrustyReclaimMemoryDoneFtraceEvent >(Arena* arena) {
5265 return Arena::CreateMessageInternal< ::perfetto::protos::TrustyReclaimMemoryDoneFtraceEvent >(arena);
5266 }
5267 template<> PROTOBUF_NOINLINE ::perfetto::protos::TrustyIrqFtraceEvent*
CreateMaybeMessage(Arena * arena)5268 Arena::CreateMaybeMessage< ::perfetto::protos::TrustyIrqFtraceEvent >(Arena* arena) {
5269 return Arena::CreateMessageInternal< ::perfetto::protos::TrustyIrqFtraceEvent >(arena);
5270 }
5271 template<> PROTOBUF_NOINLINE ::perfetto::protos::TrustyIpcHandleEventFtraceEvent*
CreateMaybeMessage(Arena * arena)5272 Arena::CreateMaybeMessage< ::perfetto::protos::TrustyIpcHandleEventFtraceEvent >(Arena* arena) {
5273 return Arena::CreateMessageInternal< ::perfetto::protos::TrustyIpcHandleEventFtraceEvent >(arena);
5274 }
5275 template<> PROTOBUF_NOINLINE ::perfetto::protos::TrustyIpcConnectFtraceEvent*
CreateMaybeMessage(Arena * arena)5276 Arena::CreateMaybeMessage< ::perfetto::protos::TrustyIpcConnectFtraceEvent >(Arena* arena) {
5277 return Arena::CreateMessageInternal< ::perfetto::protos::TrustyIpcConnectFtraceEvent >(arena);
5278 }
5279 template<> PROTOBUF_NOINLINE ::perfetto::protos::TrustyIpcConnectEndFtraceEvent*
CreateMaybeMessage(Arena * arena)5280 Arena::CreateMaybeMessage< ::perfetto::protos::TrustyIpcConnectEndFtraceEvent >(Arena* arena) {
5281 return Arena::CreateMessageInternal< ::perfetto::protos::TrustyIpcConnectEndFtraceEvent >(arena);
5282 }
5283 template<> PROTOBUF_NOINLINE ::perfetto::protos::TrustyIpcWriteFtraceEvent*
CreateMaybeMessage(Arena * arena)5284 Arena::CreateMaybeMessage< ::perfetto::protos::TrustyIpcWriteFtraceEvent >(Arena* arena) {
5285 return Arena::CreateMessageInternal< ::perfetto::protos::TrustyIpcWriteFtraceEvent >(arena);
5286 }
5287 template<> PROTOBUF_NOINLINE ::perfetto::protos::TrustyIpcPollFtraceEvent*
CreateMaybeMessage(Arena * arena)5288 Arena::CreateMaybeMessage< ::perfetto::protos::TrustyIpcPollFtraceEvent >(Arena* arena) {
5289 return Arena::CreateMessageInternal< ::perfetto::protos::TrustyIpcPollFtraceEvent >(arena);
5290 }
5291 template<> PROTOBUF_NOINLINE ::perfetto::protos::TrustyIpcReadFtraceEvent*
CreateMaybeMessage(Arena * arena)5292 Arena::CreateMaybeMessage< ::perfetto::protos::TrustyIpcReadFtraceEvent >(Arena* arena) {
5293 return Arena::CreateMessageInternal< ::perfetto::protos::TrustyIpcReadFtraceEvent >(arena);
5294 }
5295 template<> PROTOBUF_NOINLINE ::perfetto::protos::TrustyIpcReadEndFtraceEvent*
CreateMaybeMessage(Arena * arena)5296 Arena::CreateMaybeMessage< ::perfetto::protos::TrustyIpcReadEndFtraceEvent >(Arena* arena) {
5297 return Arena::CreateMessageInternal< ::perfetto::protos::TrustyIpcReadEndFtraceEvent >(arena);
5298 }
5299 template<> PROTOBUF_NOINLINE ::perfetto::protos::TrustyIpcRxFtraceEvent*
CreateMaybeMessage(Arena * arena)5300 Arena::CreateMaybeMessage< ::perfetto::protos::TrustyIpcRxFtraceEvent >(Arena* arena) {
5301 return Arena::CreateMessageInternal< ::perfetto::protos::TrustyIpcRxFtraceEvent >(arena);
5302 }
5303 template<> PROTOBUF_NOINLINE ::perfetto::protos::TrustyEnqueueNopFtraceEvent*
CreateMaybeMessage(Arena * arena)5304 Arena::CreateMaybeMessage< ::perfetto::protos::TrustyEnqueueNopFtraceEvent >(Arena* arena) {
5305 return Arena::CreateMessageInternal< ::perfetto::protos::TrustyEnqueueNopFtraceEvent >(arena);
5306 }
5307 PROTOBUF_NAMESPACE_CLOSE
5308
5309 // @@protoc_insertion_point(global_scope)
5310 #include <google/protobuf/port_undef.inc>
5311