1 // Generated by the protocol buffer compiler.  DO NOT EDIT!
2 // source: protos/perfetto/trace/ftrace/block.proto
3 
4 #include "protos/perfetto/trace/ftrace/block.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 {
BlockRqIssueFtraceEvent(::_pbi::ConstantInitialized)23 PROTOBUF_CONSTEXPR BlockRqIssueFtraceEvent::BlockRqIssueFtraceEvent(
24     ::_pbi::ConstantInitialized): _impl_{
25     /*decltype(_impl_._has_bits_)*/{}
26   , /*decltype(_impl_._cached_size_)*/{}
27   , /*decltype(_impl_.rwbs_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
28   , /*decltype(_impl_.comm_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
29   , /*decltype(_impl_.cmd_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
30   , /*decltype(_impl_.dev_)*/::uint64_t{0u}
31   , /*decltype(_impl_.sector_)*/::uint64_t{0u}
32   , /*decltype(_impl_.nr_sector_)*/0u
33   , /*decltype(_impl_.bytes_)*/0u} {}
34 struct BlockRqIssueFtraceEventDefaultTypeInternal {
BlockRqIssueFtraceEventDefaultTypeInternalperfetto::protos::BlockRqIssueFtraceEventDefaultTypeInternal35   PROTOBUF_CONSTEXPR BlockRqIssueFtraceEventDefaultTypeInternal()
36       : _instance(::_pbi::ConstantInitialized{}) {}
~BlockRqIssueFtraceEventDefaultTypeInternalperfetto::protos::BlockRqIssueFtraceEventDefaultTypeInternal37   ~BlockRqIssueFtraceEventDefaultTypeInternal() {}
38   union {  // NOLINT(misc-non-private-member-variables-in-classes)
39     BlockRqIssueFtraceEvent _instance;
40   };
41 };
42 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BlockRqIssueFtraceEventDefaultTypeInternal _BlockRqIssueFtraceEvent_default_instance_;
BlockBioBackmergeFtraceEvent(::_pbi::ConstantInitialized)43 PROTOBUF_CONSTEXPR BlockBioBackmergeFtraceEvent::BlockBioBackmergeFtraceEvent(
44     ::_pbi::ConstantInitialized): _impl_{
45     /*decltype(_impl_._has_bits_)*/{}
46   , /*decltype(_impl_._cached_size_)*/{}
47   , /*decltype(_impl_.rwbs_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
48   , /*decltype(_impl_.comm_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
49   , /*decltype(_impl_.dev_)*/::uint64_t{0u}
50   , /*decltype(_impl_.sector_)*/::uint64_t{0u}
51   , /*decltype(_impl_.nr_sector_)*/0u} {}
52 struct BlockBioBackmergeFtraceEventDefaultTypeInternal {
BlockBioBackmergeFtraceEventDefaultTypeInternalperfetto::protos::BlockBioBackmergeFtraceEventDefaultTypeInternal53   PROTOBUF_CONSTEXPR BlockBioBackmergeFtraceEventDefaultTypeInternal()
54       : _instance(::_pbi::ConstantInitialized{}) {}
~BlockBioBackmergeFtraceEventDefaultTypeInternalperfetto::protos::BlockBioBackmergeFtraceEventDefaultTypeInternal55   ~BlockBioBackmergeFtraceEventDefaultTypeInternal() {}
56   union {  // NOLINT(misc-non-private-member-variables-in-classes)
57     BlockBioBackmergeFtraceEvent _instance;
58   };
59 };
60 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BlockBioBackmergeFtraceEventDefaultTypeInternal _BlockBioBackmergeFtraceEvent_default_instance_;
BlockBioBounceFtraceEvent(::_pbi::ConstantInitialized)61 PROTOBUF_CONSTEXPR BlockBioBounceFtraceEvent::BlockBioBounceFtraceEvent(
62     ::_pbi::ConstantInitialized): _impl_{
63     /*decltype(_impl_._has_bits_)*/{}
64   , /*decltype(_impl_._cached_size_)*/{}
65   , /*decltype(_impl_.rwbs_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
66   , /*decltype(_impl_.comm_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
67   , /*decltype(_impl_.dev_)*/::uint64_t{0u}
68   , /*decltype(_impl_.sector_)*/::uint64_t{0u}
69   , /*decltype(_impl_.nr_sector_)*/0u} {}
70 struct BlockBioBounceFtraceEventDefaultTypeInternal {
BlockBioBounceFtraceEventDefaultTypeInternalperfetto::protos::BlockBioBounceFtraceEventDefaultTypeInternal71   PROTOBUF_CONSTEXPR BlockBioBounceFtraceEventDefaultTypeInternal()
72       : _instance(::_pbi::ConstantInitialized{}) {}
~BlockBioBounceFtraceEventDefaultTypeInternalperfetto::protos::BlockBioBounceFtraceEventDefaultTypeInternal73   ~BlockBioBounceFtraceEventDefaultTypeInternal() {}
74   union {  // NOLINT(misc-non-private-member-variables-in-classes)
75     BlockBioBounceFtraceEvent _instance;
76   };
77 };
78 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BlockBioBounceFtraceEventDefaultTypeInternal _BlockBioBounceFtraceEvent_default_instance_;
BlockBioCompleteFtraceEvent(::_pbi::ConstantInitialized)79 PROTOBUF_CONSTEXPR BlockBioCompleteFtraceEvent::BlockBioCompleteFtraceEvent(
80     ::_pbi::ConstantInitialized): _impl_{
81     /*decltype(_impl_._has_bits_)*/{}
82   , /*decltype(_impl_._cached_size_)*/{}
83   , /*decltype(_impl_.rwbs_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
84   , /*decltype(_impl_.dev_)*/::uint64_t{0u}
85   , /*decltype(_impl_.sector_)*/::uint64_t{0u}
86   , /*decltype(_impl_.nr_sector_)*/0u
87   , /*decltype(_impl_.error_)*/0} {}
88 struct BlockBioCompleteFtraceEventDefaultTypeInternal {
BlockBioCompleteFtraceEventDefaultTypeInternalperfetto::protos::BlockBioCompleteFtraceEventDefaultTypeInternal89   PROTOBUF_CONSTEXPR BlockBioCompleteFtraceEventDefaultTypeInternal()
90       : _instance(::_pbi::ConstantInitialized{}) {}
~BlockBioCompleteFtraceEventDefaultTypeInternalperfetto::protos::BlockBioCompleteFtraceEventDefaultTypeInternal91   ~BlockBioCompleteFtraceEventDefaultTypeInternal() {}
92   union {  // NOLINT(misc-non-private-member-variables-in-classes)
93     BlockBioCompleteFtraceEvent _instance;
94   };
95 };
96 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BlockBioCompleteFtraceEventDefaultTypeInternal _BlockBioCompleteFtraceEvent_default_instance_;
BlockBioFrontmergeFtraceEvent(::_pbi::ConstantInitialized)97 PROTOBUF_CONSTEXPR BlockBioFrontmergeFtraceEvent::BlockBioFrontmergeFtraceEvent(
98     ::_pbi::ConstantInitialized): _impl_{
99     /*decltype(_impl_._has_bits_)*/{}
100   , /*decltype(_impl_._cached_size_)*/{}
101   , /*decltype(_impl_.rwbs_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
102   , /*decltype(_impl_.comm_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
103   , /*decltype(_impl_.dev_)*/::uint64_t{0u}
104   , /*decltype(_impl_.sector_)*/::uint64_t{0u}
105   , /*decltype(_impl_.nr_sector_)*/0u} {}
106 struct BlockBioFrontmergeFtraceEventDefaultTypeInternal {
BlockBioFrontmergeFtraceEventDefaultTypeInternalperfetto::protos::BlockBioFrontmergeFtraceEventDefaultTypeInternal107   PROTOBUF_CONSTEXPR BlockBioFrontmergeFtraceEventDefaultTypeInternal()
108       : _instance(::_pbi::ConstantInitialized{}) {}
~BlockBioFrontmergeFtraceEventDefaultTypeInternalperfetto::protos::BlockBioFrontmergeFtraceEventDefaultTypeInternal109   ~BlockBioFrontmergeFtraceEventDefaultTypeInternal() {}
110   union {  // NOLINT(misc-non-private-member-variables-in-classes)
111     BlockBioFrontmergeFtraceEvent _instance;
112   };
113 };
114 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BlockBioFrontmergeFtraceEventDefaultTypeInternal _BlockBioFrontmergeFtraceEvent_default_instance_;
BlockBioQueueFtraceEvent(::_pbi::ConstantInitialized)115 PROTOBUF_CONSTEXPR BlockBioQueueFtraceEvent::BlockBioQueueFtraceEvent(
116     ::_pbi::ConstantInitialized): _impl_{
117     /*decltype(_impl_._has_bits_)*/{}
118   , /*decltype(_impl_._cached_size_)*/{}
119   , /*decltype(_impl_.rwbs_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
120   , /*decltype(_impl_.comm_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
121   , /*decltype(_impl_.dev_)*/::uint64_t{0u}
122   , /*decltype(_impl_.sector_)*/::uint64_t{0u}
123   , /*decltype(_impl_.nr_sector_)*/0u} {}
124 struct BlockBioQueueFtraceEventDefaultTypeInternal {
BlockBioQueueFtraceEventDefaultTypeInternalperfetto::protos::BlockBioQueueFtraceEventDefaultTypeInternal125   PROTOBUF_CONSTEXPR BlockBioQueueFtraceEventDefaultTypeInternal()
126       : _instance(::_pbi::ConstantInitialized{}) {}
~BlockBioQueueFtraceEventDefaultTypeInternalperfetto::protos::BlockBioQueueFtraceEventDefaultTypeInternal127   ~BlockBioQueueFtraceEventDefaultTypeInternal() {}
128   union {  // NOLINT(misc-non-private-member-variables-in-classes)
129     BlockBioQueueFtraceEvent _instance;
130   };
131 };
132 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BlockBioQueueFtraceEventDefaultTypeInternal _BlockBioQueueFtraceEvent_default_instance_;
BlockBioRemapFtraceEvent(::_pbi::ConstantInitialized)133 PROTOBUF_CONSTEXPR BlockBioRemapFtraceEvent::BlockBioRemapFtraceEvent(
134     ::_pbi::ConstantInitialized): _impl_{
135     /*decltype(_impl_._has_bits_)*/{}
136   , /*decltype(_impl_._cached_size_)*/{}
137   , /*decltype(_impl_.rwbs_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
138   , /*decltype(_impl_.dev_)*/::uint64_t{0u}
139   , /*decltype(_impl_.sector_)*/::uint64_t{0u}
140   , /*decltype(_impl_.old_dev_)*/::uint64_t{0u}
141   , /*decltype(_impl_.old_sector_)*/::uint64_t{0u}
142   , /*decltype(_impl_.nr_sector_)*/0u} {}
143 struct BlockBioRemapFtraceEventDefaultTypeInternal {
BlockBioRemapFtraceEventDefaultTypeInternalperfetto::protos::BlockBioRemapFtraceEventDefaultTypeInternal144   PROTOBUF_CONSTEXPR BlockBioRemapFtraceEventDefaultTypeInternal()
145       : _instance(::_pbi::ConstantInitialized{}) {}
~BlockBioRemapFtraceEventDefaultTypeInternalperfetto::protos::BlockBioRemapFtraceEventDefaultTypeInternal146   ~BlockBioRemapFtraceEventDefaultTypeInternal() {}
147   union {  // NOLINT(misc-non-private-member-variables-in-classes)
148     BlockBioRemapFtraceEvent _instance;
149   };
150 };
151 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BlockBioRemapFtraceEventDefaultTypeInternal _BlockBioRemapFtraceEvent_default_instance_;
BlockDirtyBufferFtraceEvent(::_pbi::ConstantInitialized)152 PROTOBUF_CONSTEXPR BlockDirtyBufferFtraceEvent::BlockDirtyBufferFtraceEvent(
153     ::_pbi::ConstantInitialized): _impl_{
154     /*decltype(_impl_._has_bits_)*/{}
155   , /*decltype(_impl_._cached_size_)*/{}
156   , /*decltype(_impl_.dev_)*/::uint64_t{0u}
157   , /*decltype(_impl_.sector_)*/::uint64_t{0u}
158   , /*decltype(_impl_.size_)*/::uint64_t{0u}} {}
159 struct BlockDirtyBufferFtraceEventDefaultTypeInternal {
BlockDirtyBufferFtraceEventDefaultTypeInternalperfetto::protos::BlockDirtyBufferFtraceEventDefaultTypeInternal160   PROTOBUF_CONSTEXPR BlockDirtyBufferFtraceEventDefaultTypeInternal()
161       : _instance(::_pbi::ConstantInitialized{}) {}
~BlockDirtyBufferFtraceEventDefaultTypeInternalperfetto::protos::BlockDirtyBufferFtraceEventDefaultTypeInternal162   ~BlockDirtyBufferFtraceEventDefaultTypeInternal() {}
163   union {  // NOLINT(misc-non-private-member-variables-in-classes)
164     BlockDirtyBufferFtraceEvent _instance;
165   };
166 };
167 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BlockDirtyBufferFtraceEventDefaultTypeInternal _BlockDirtyBufferFtraceEvent_default_instance_;
BlockGetrqFtraceEvent(::_pbi::ConstantInitialized)168 PROTOBUF_CONSTEXPR BlockGetrqFtraceEvent::BlockGetrqFtraceEvent(
169     ::_pbi::ConstantInitialized): _impl_{
170     /*decltype(_impl_._has_bits_)*/{}
171   , /*decltype(_impl_._cached_size_)*/{}
172   , /*decltype(_impl_.rwbs_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
173   , /*decltype(_impl_.comm_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
174   , /*decltype(_impl_.dev_)*/::uint64_t{0u}
175   , /*decltype(_impl_.sector_)*/::uint64_t{0u}
176   , /*decltype(_impl_.nr_sector_)*/0u} {}
177 struct BlockGetrqFtraceEventDefaultTypeInternal {
BlockGetrqFtraceEventDefaultTypeInternalperfetto::protos::BlockGetrqFtraceEventDefaultTypeInternal178   PROTOBUF_CONSTEXPR BlockGetrqFtraceEventDefaultTypeInternal()
179       : _instance(::_pbi::ConstantInitialized{}) {}
~BlockGetrqFtraceEventDefaultTypeInternalperfetto::protos::BlockGetrqFtraceEventDefaultTypeInternal180   ~BlockGetrqFtraceEventDefaultTypeInternal() {}
181   union {  // NOLINT(misc-non-private-member-variables-in-classes)
182     BlockGetrqFtraceEvent _instance;
183   };
184 };
185 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BlockGetrqFtraceEventDefaultTypeInternal _BlockGetrqFtraceEvent_default_instance_;
BlockPlugFtraceEvent(::_pbi::ConstantInitialized)186 PROTOBUF_CONSTEXPR BlockPlugFtraceEvent::BlockPlugFtraceEvent(
187     ::_pbi::ConstantInitialized): _impl_{
188     /*decltype(_impl_._has_bits_)*/{}
189   , /*decltype(_impl_._cached_size_)*/{}
190   , /*decltype(_impl_.comm_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {}
191 struct BlockPlugFtraceEventDefaultTypeInternal {
BlockPlugFtraceEventDefaultTypeInternalperfetto::protos::BlockPlugFtraceEventDefaultTypeInternal192   PROTOBUF_CONSTEXPR BlockPlugFtraceEventDefaultTypeInternal()
193       : _instance(::_pbi::ConstantInitialized{}) {}
~BlockPlugFtraceEventDefaultTypeInternalperfetto::protos::BlockPlugFtraceEventDefaultTypeInternal194   ~BlockPlugFtraceEventDefaultTypeInternal() {}
195   union {  // NOLINT(misc-non-private-member-variables-in-classes)
196     BlockPlugFtraceEvent _instance;
197   };
198 };
199 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BlockPlugFtraceEventDefaultTypeInternal _BlockPlugFtraceEvent_default_instance_;
BlockRqAbortFtraceEvent(::_pbi::ConstantInitialized)200 PROTOBUF_CONSTEXPR BlockRqAbortFtraceEvent::BlockRqAbortFtraceEvent(
201     ::_pbi::ConstantInitialized): _impl_{
202     /*decltype(_impl_._has_bits_)*/{}
203   , /*decltype(_impl_._cached_size_)*/{}
204   , /*decltype(_impl_.rwbs_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
205   , /*decltype(_impl_.cmd_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
206   , /*decltype(_impl_.dev_)*/::uint64_t{0u}
207   , /*decltype(_impl_.sector_)*/::uint64_t{0u}
208   , /*decltype(_impl_.nr_sector_)*/0u
209   , /*decltype(_impl_.errors_)*/0} {}
210 struct BlockRqAbortFtraceEventDefaultTypeInternal {
BlockRqAbortFtraceEventDefaultTypeInternalperfetto::protos::BlockRqAbortFtraceEventDefaultTypeInternal211   PROTOBUF_CONSTEXPR BlockRqAbortFtraceEventDefaultTypeInternal()
212       : _instance(::_pbi::ConstantInitialized{}) {}
~BlockRqAbortFtraceEventDefaultTypeInternalperfetto::protos::BlockRqAbortFtraceEventDefaultTypeInternal213   ~BlockRqAbortFtraceEventDefaultTypeInternal() {}
214   union {  // NOLINT(misc-non-private-member-variables-in-classes)
215     BlockRqAbortFtraceEvent _instance;
216   };
217 };
218 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BlockRqAbortFtraceEventDefaultTypeInternal _BlockRqAbortFtraceEvent_default_instance_;
BlockRqCompleteFtraceEvent(::_pbi::ConstantInitialized)219 PROTOBUF_CONSTEXPR BlockRqCompleteFtraceEvent::BlockRqCompleteFtraceEvent(
220     ::_pbi::ConstantInitialized): _impl_{
221     /*decltype(_impl_._has_bits_)*/{}
222   , /*decltype(_impl_._cached_size_)*/{}
223   , /*decltype(_impl_.rwbs_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
224   , /*decltype(_impl_.cmd_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
225   , /*decltype(_impl_.dev_)*/::uint64_t{0u}
226   , /*decltype(_impl_.sector_)*/::uint64_t{0u}
227   , /*decltype(_impl_.nr_sector_)*/0u
228   , /*decltype(_impl_.errors_)*/0
229   , /*decltype(_impl_.error_)*/0} {}
230 struct BlockRqCompleteFtraceEventDefaultTypeInternal {
BlockRqCompleteFtraceEventDefaultTypeInternalperfetto::protos::BlockRqCompleteFtraceEventDefaultTypeInternal231   PROTOBUF_CONSTEXPR BlockRqCompleteFtraceEventDefaultTypeInternal()
232       : _instance(::_pbi::ConstantInitialized{}) {}
~BlockRqCompleteFtraceEventDefaultTypeInternalperfetto::protos::BlockRqCompleteFtraceEventDefaultTypeInternal233   ~BlockRqCompleteFtraceEventDefaultTypeInternal() {}
234   union {  // NOLINT(misc-non-private-member-variables-in-classes)
235     BlockRqCompleteFtraceEvent _instance;
236   };
237 };
238 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BlockRqCompleteFtraceEventDefaultTypeInternal _BlockRqCompleteFtraceEvent_default_instance_;
BlockRqInsertFtraceEvent(::_pbi::ConstantInitialized)239 PROTOBUF_CONSTEXPR BlockRqInsertFtraceEvent::BlockRqInsertFtraceEvent(
240     ::_pbi::ConstantInitialized): _impl_{
241     /*decltype(_impl_._has_bits_)*/{}
242   , /*decltype(_impl_._cached_size_)*/{}
243   , /*decltype(_impl_.rwbs_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
244   , /*decltype(_impl_.comm_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
245   , /*decltype(_impl_.cmd_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
246   , /*decltype(_impl_.dev_)*/::uint64_t{0u}
247   , /*decltype(_impl_.sector_)*/::uint64_t{0u}
248   , /*decltype(_impl_.nr_sector_)*/0u
249   , /*decltype(_impl_.bytes_)*/0u} {}
250 struct BlockRqInsertFtraceEventDefaultTypeInternal {
BlockRqInsertFtraceEventDefaultTypeInternalperfetto::protos::BlockRqInsertFtraceEventDefaultTypeInternal251   PROTOBUF_CONSTEXPR BlockRqInsertFtraceEventDefaultTypeInternal()
252       : _instance(::_pbi::ConstantInitialized{}) {}
~BlockRqInsertFtraceEventDefaultTypeInternalperfetto::protos::BlockRqInsertFtraceEventDefaultTypeInternal253   ~BlockRqInsertFtraceEventDefaultTypeInternal() {}
254   union {  // NOLINT(misc-non-private-member-variables-in-classes)
255     BlockRqInsertFtraceEvent _instance;
256   };
257 };
258 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BlockRqInsertFtraceEventDefaultTypeInternal _BlockRqInsertFtraceEvent_default_instance_;
BlockRqRemapFtraceEvent(::_pbi::ConstantInitialized)259 PROTOBUF_CONSTEXPR BlockRqRemapFtraceEvent::BlockRqRemapFtraceEvent(
260     ::_pbi::ConstantInitialized): _impl_{
261     /*decltype(_impl_._has_bits_)*/{}
262   , /*decltype(_impl_._cached_size_)*/{}
263   , /*decltype(_impl_.rwbs_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
264   , /*decltype(_impl_.dev_)*/::uint64_t{0u}
265   , /*decltype(_impl_.sector_)*/::uint64_t{0u}
266   , /*decltype(_impl_.old_dev_)*/::uint64_t{0u}
267   , /*decltype(_impl_.nr_sector_)*/0u
268   , /*decltype(_impl_.nr_bios_)*/0u
269   , /*decltype(_impl_.old_sector_)*/::uint64_t{0u}} {}
270 struct BlockRqRemapFtraceEventDefaultTypeInternal {
BlockRqRemapFtraceEventDefaultTypeInternalperfetto::protos::BlockRqRemapFtraceEventDefaultTypeInternal271   PROTOBUF_CONSTEXPR BlockRqRemapFtraceEventDefaultTypeInternal()
272       : _instance(::_pbi::ConstantInitialized{}) {}
~BlockRqRemapFtraceEventDefaultTypeInternalperfetto::protos::BlockRqRemapFtraceEventDefaultTypeInternal273   ~BlockRqRemapFtraceEventDefaultTypeInternal() {}
274   union {  // NOLINT(misc-non-private-member-variables-in-classes)
275     BlockRqRemapFtraceEvent _instance;
276   };
277 };
278 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BlockRqRemapFtraceEventDefaultTypeInternal _BlockRqRemapFtraceEvent_default_instance_;
BlockRqRequeueFtraceEvent(::_pbi::ConstantInitialized)279 PROTOBUF_CONSTEXPR BlockRqRequeueFtraceEvent::BlockRqRequeueFtraceEvent(
280     ::_pbi::ConstantInitialized): _impl_{
281     /*decltype(_impl_._has_bits_)*/{}
282   , /*decltype(_impl_._cached_size_)*/{}
283   , /*decltype(_impl_.rwbs_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
284   , /*decltype(_impl_.cmd_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
285   , /*decltype(_impl_.dev_)*/::uint64_t{0u}
286   , /*decltype(_impl_.sector_)*/::uint64_t{0u}
287   , /*decltype(_impl_.nr_sector_)*/0u
288   , /*decltype(_impl_.errors_)*/0} {}
289 struct BlockRqRequeueFtraceEventDefaultTypeInternal {
BlockRqRequeueFtraceEventDefaultTypeInternalperfetto::protos::BlockRqRequeueFtraceEventDefaultTypeInternal290   PROTOBUF_CONSTEXPR BlockRqRequeueFtraceEventDefaultTypeInternal()
291       : _instance(::_pbi::ConstantInitialized{}) {}
~BlockRqRequeueFtraceEventDefaultTypeInternalperfetto::protos::BlockRqRequeueFtraceEventDefaultTypeInternal292   ~BlockRqRequeueFtraceEventDefaultTypeInternal() {}
293   union {  // NOLINT(misc-non-private-member-variables-in-classes)
294     BlockRqRequeueFtraceEvent _instance;
295   };
296 };
297 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BlockRqRequeueFtraceEventDefaultTypeInternal _BlockRqRequeueFtraceEvent_default_instance_;
BlockSleeprqFtraceEvent(::_pbi::ConstantInitialized)298 PROTOBUF_CONSTEXPR BlockSleeprqFtraceEvent::BlockSleeprqFtraceEvent(
299     ::_pbi::ConstantInitialized): _impl_{
300     /*decltype(_impl_._has_bits_)*/{}
301   , /*decltype(_impl_._cached_size_)*/{}
302   , /*decltype(_impl_.rwbs_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
303   , /*decltype(_impl_.comm_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
304   , /*decltype(_impl_.dev_)*/::uint64_t{0u}
305   , /*decltype(_impl_.sector_)*/::uint64_t{0u}
306   , /*decltype(_impl_.nr_sector_)*/0u} {}
307 struct BlockSleeprqFtraceEventDefaultTypeInternal {
BlockSleeprqFtraceEventDefaultTypeInternalperfetto::protos::BlockSleeprqFtraceEventDefaultTypeInternal308   PROTOBUF_CONSTEXPR BlockSleeprqFtraceEventDefaultTypeInternal()
309       : _instance(::_pbi::ConstantInitialized{}) {}
~BlockSleeprqFtraceEventDefaultTypeInternalperfetto::protos::BlockSleeprqFtraceEventDefaultTypeInternal310   ~BlockSleeprqFtraceEventDefaultTypeInternal() {}
311   union {  // NOLINT(misc-non-private-member-variables-in-classes)
312     BlockSleeprqFtraceEvent _instance;
313   };
314 };
315 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BlockSleeprqFtraceEventDefaultTypeInternal _BlockSleeprqFtraceEvent_default_instance_;
BlockSplitFtraceEvent(::_pbi::ConstantInitialized)316 PROTOBUF_CONSTEXPR BlockSplitFtraceEvent::BlockSplitFtraceEvent(
317     ::_pbi::ConstantInitialized): _impl_{
318     /*decltype(_impl_._has_bits_)*/{}
319   , /*decltype(_impl_._cached_size_)*/{}
320   , /*decltype(_impl_.rwbs_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
321   , /*decltype(_impl_.comm_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
322   , /*decltype(_impl_.dev_)*/::uint64_t{0u}
323   , /*decltype(_impl_.sector_)*/::uint64_t{0u}
324   , /*decltype(_impl_.new_sector_)*/::uint64_t{0u}} {}
325 struct BlockSplitFtraceEventDefaultTypeInternal {
BlockSplitFtraceEventDefaultTypeInternalperfetto::protos::BlockSplitFtraceEventDefaultTypeInternal326   PROTOBUF_CONSTEXPR BlockSplitFtraceEventDefaultTypeInternal()
327       : _instance(::_pbi::ConstantInitialized{}) {}
~BlockSplitFtraceEventDefaultTypeInternalperfetto::protos::BlockSplitFtraceEventDefaultTypeInternal328   ~BlockSplitFtraceEventDefaultTypeInternal() {}
329   union {  // NOLINT(misc-non-private-member-variables-in-classes)
330     BlockSplitFtraceEvent _instance;
331   };
332 };
333 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BlockSplitFtraceEventDefaultTypeInternal _BlockSplitFtraceEvent_default_instance_;
BlockTouchBufferFtraceEvent(::_pbi::ConstantInitialized)334 PROTOBUF_CONSTEXPR BlockTouchBufferFtraceEvent::BlockTouchBufferFtraceEvent(
335     ::_pbi::ConstantInitialized): _impl_{
336     /*decltype(_impl_._has_bits_)*/{}
337   , /*decltype(_impl_._cached_size_)*/{}
338   , /*decltype(_impl_.dev_)*/::uint64_t{0u}
339   , /*decltype(_impl_.sector_)*/::uint64_t{0u}
340   , /*decltype(_impl_.size_)*/::uint64_t{0u}} {}
341 struct BlockTouchBufferFtraceEventDefaultTypeInternal {
BlockTouchBufferFtraceEventDefaultTypeInternalperfetto::protos::BlockTouchBufferFtraceEventDefaultTypeInternal342   PROTOBUF_CONSTEXPR BlockTouchBufferFtraceEventDefaultTypeInternal()
343       : _instance(::_pbi::ConstantInitialized{}) {}
~BlockTouchBufferFtraceEventDefaultTypeInternalperfetto::protos::BlockTouchBufferFtraceEventDefaultTypeInternal344   ~BlockTouchBufferFtraceEventDefaultTypeInternal() {}
345   union {  // NOLINT(misc-non-private-member-variables-in-classes)
346     BlockTouchBufferFtraceEvent _instance;
347   };
348 };
349 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BlockTouchBufferFtraceEventDefaultTypeInternal _BlockTouchBufferFtraceEvent_default_instance_;
BlockUnplugFtraceEvent(::_pbi::ConstantInitialized)350 PROTOBUF_CONSTEXPR BlockUnplugFtraceEvent::BlockUnplugFtraceEvent(
351     ::_pbi::ConstantInitialized): _impl_{
352     /*decltype(_impl_._has_bits_)*/{}
353   , /*decltype(_impl_._cached_size_)*/{}
354   , /*decltype(_impl_.comm_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
355   , /*decltype(_impl_.nr_rq_)*/0} {}
356 struct BlockUnplugFtraceEventDefaultTypeInternal {
BlockUnplugFtraceEventDefaultTypeInternalperfetto::protos::BlockUnplugFtraceEventDefaultTypeInternal357   PROTOBUF_CONSTEXPR BlockUnplugFtraceEventDefaultTypeInternal()
358       : _instance(::_pbi::ConstantInitialized{}) {}
~BlockUnplugFtraceEventDefaultTypeInternalperfetto::protos::BlockUnplugFtraceEventDefaultTypeInternal359   ~BlockUnplugFtraceEventDefaultTypeInternal() {}
360   union {  // NOLINT(misc-non-private-member-variables-in-classes)
361     BlockUnplugFtraceEvent _instance;
362   };
363 };
364 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BlockUnplugFtraceEventDefaultTypeInternal _BlockUnplugFtraceEvent_default_instance_;
BlockIoStartFtraceEvent(::_pbi::ConstantInitialized)365 PROTOBUF_CONSTEXPR BlockIoStartFtraceEvent::BlockIoStartFtraceEvent(
366     ::_pbi::ConstantInitialized): _impl_{
367     /*decltype(_impl_._has_bits_)*/{}
368   , /*decltype(_impl_._cached_size_)*/{}
369   , /*decltype(_impl_.rwbs_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
370   , /*decltype(_impl_.comm_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
371   , /*decltype(_impl_.cmd_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
372   , /*decltype(_impl_.dev_)*/::uint64_t{0u}
373   , /*decltype(_impl_.sector_)*/::uint64_t{0u}
374   , /*decltype(_impl_.nr_sector_)*/0u
375   , /*decltype(_impl_.bytes_)*/0u
376   , /*decltype(_impl_.ioprio_)*/0u} {}
377 struct BlockIoStartFtraceEventDefaultTypeInternal {
BlockIoStartFtraceEventDefaultTypeInternalperfetto::protos::BlockIoStartFtraceEventDefaultTypeInternal378   PROTOBUF_CONSTEXPR BlockIoStartFtraceEventDefaultTypeInternal()
379       : _instance(::_pbi::ConstantInitialized{}) {}
~BlockIoStartFtraceEventDefaultTypeInternalperfetto::protos::BlockIoStartFtraceEventDefaultTypeInternal380   ~BlockIoStartFtraceEventDefaultTypeInternal() {}
381   union {  // NOLINT(misc-non-private-member-variables-in-classes)
382     BlockIoStartFtraceEvent _instance;
383   };
384 };
385 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BlockIoStartFtraceEventDefaultTypeInternal _BlockIoStartFtraceEvent_default_instance_;
BlockIoDoneFtraceEvent(::_pbi::ConstantInitialized)386 PROTOBUF_CONSTEXPR BlockIoDoneFtraceEvent::BlockIoDoneFtraceEvent(
387     ::_pbi::ConstantInitialized): _impl_{
388     /*decltype(_impl_._has_bits_)*/{}
389   , /*decltype(_impl_._cached_size_)*/{}
390   , /*decltype(_impl_.rwbs_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
391   , /*decltype(_impl_.comm_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
392   , /*decltype(_impl_.cmd_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
393   , /*decltype(_impl_.dev_)*/::uint64_t{0u}
394   , /*decltype(_impl_.sector_)*/::uint64_t{0u}
395   , /*decltype(_impl_.nr_sector_)*/0u
396   , /*decltype(_impl_.bytes_)*/0u
397   , /*decltype(_impl_.ioprio_)*/0u} {}
398 struct BlockIoDoneFtraceEventDefaultTypeInternal {
BlockIoDoneFtraceEventDefaultTypeInternalperfetto::protos::BlockIoDoneFtraceEventDefaultTypeInternal399   PROTOBUF_CONSTEXPR BlockIoDoneFtraceEventDefaultTypeInternal()
400       : _instance(::_pbi::ConstantInitialized{}) {}
~BlockIoDoneFtraceEventDefaultTypeInternalperfetto::protos::BlockIoDoneFtraceEventDefaultTypeInternal401   ~BlockIoDoneFtraceEventDefaultTypeInternal() {}
402   union {  // NOLINT(misc-non-private-member-variables-in-classes)
403     BlockIoDoneFtraceEvent _instance;
404   };
405 };
406 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BlockIoDoneFtraceEventDefaultTypeInternal _BlockIoDoneFtraceEvent_default_instance_;
407 }  // namespace protos
408 }  // namespace perfetto
409 namespace perfetto {
410 namespace protos {
411 
412 // ===================================================================
413 
414 class BlockRqIssueFtraceEvent::_Internal {
415  public:
416   using HasBits = decltype(std::declval<BlockRqIssueFtraceEvent>()._impl_._has_bits_);
set_has_dev(HasBits * has_bits)417   static void set_has_dev(HasBits* has_bits) {
418     (*has_bits)[0] |= 8u;
419   }
set_has_sector(HasBits * has_bits)420   static void set_has_sector(HasBits* has_bits) {
421     (*has_bits)[0] |= 16u;
422   }
set_has_nr_sector(HasBits * has_bits)423   static void set_has_nr_sector(HasBits* has_bits) {
424     (*has_bits)[0] |= 32u;
425   }
set_has_bytes(HasBits * has_bits)426   static void set_has_bytes(HasBits* has_bits) {
427     (*has_bits)[0] |= 64u;
428   }
set_has_rwbs(HasBits * has_bits)429   static void set_has_rwbs(HasBits* has_bits) {
430     (*has_bits)[0] |= 1u;
431   }
set_has_comm(HasBits * has_bits)432   static void set_has_comm(HasBits* has_bits) {
433     (*has_bits)[0] |= 2u;
434   }
set_has_cmd(HasBits * has_bits)435   static void set_has_cmd(HasBits* has_bits) {
436     (*has_bits)[0] |= 4u;
437   }
438 };
439 
BlockRqIssueFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)440 BlockRqIssueFtraceEvent::BlockRqIssueFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
441                          bool is_message_owned)
442   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
443   SharedCtor(arena, is_message_owned);
444   // @@protoc_insertion_point(arena_constructor:perfetto.protos.BlockRqIssueFtraceEvent)
445 }
BlockRqIssueFtraceEvent(const BlockRqIssueFtraceEvent & from)446 BlockRqIssueFtraceEvent::BlockRqIssueFtraceEvent(const BlockRqIssueFtraceEvent& from)
447   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
448   BlockRqIssueFtraceEvent* const _this = this; (void)_this;
449   new (&_impl_) Impl_{
450       decltype(_impl_._has_bits_){from._impl_._has_bits_}
451     , /*decltype(_impl_._cached_size_)*/{}
452     , decltype(_impl_.rwbs_){}
453     , decltype(_impl_.comm_){}
454     , decltype(_impl_.cmd_){}
455     , decltype(_impl_.dev_){}
456     , decltype(_impl_.sector_){}
457     , decltype(_impl_.nr_sector_){}
458     , decltype(_impl_.bytes_){}};
459 
460   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
461   _impl_.rwbs_.InitDefault();
462   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
463     _impl_.rwbs_.Set("", GetArenaForAllocation());
464   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
465   if (from._internal_has_rwbs()) {
466     _this->_impl_.rwbs_.Set(from._internal_rwbs(),
467       _this->GetArenaForAllocation());
468   }
469   _impl_.comm_.InitDefault();
470   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
471     _impl_.comm_.Set("", GetArenaForAllocation());
472   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
473   if (from._internal_has_comm()) {
474     _this->_impl_.comm_.Set(from._internal_comm(),
475       _this->GetArenaForAllocation());
476   }
477   _impl_.cmd_.InitDefault();
478   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
479     _impl_.cmd_.Set("", GetArenaForAllocation());
480   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
481   if (from._internal_has_cmd()) {
482     _this->_impl_.cmd_.Set(from._internal_cmd(),
483       _this->GetArenaForAllocation());
484   }
485   ::memcpy(&_impl_.dev_, &from._impl_.dev_,
486     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.bytes_) -
487     reinterpret_cast<char*>(&_impl_.dev_)) + sizeof(_impl_.bytes_));
488   // @@protoc_insertion_point(copy_constructor:perfetto.protos.BlockRqIssueFtraceEvent)
489 }
490 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)491 inline void BlockRqIssueFtraceEvent::SharedCtor(
492     ::_pb::Arena* arena, bool is_message_owned) {
493   (void)arena;
494   (void)is_message_owned;
495   new (&_impl_) Impl_{
496       decltype(_impl_._has_bits_){}
497     , /*decltype(_impl_._cached_size_)*/{}
498     , decltype(_impl_.rwbs_){}
499     , decltype(_impl_.comm_){}
500     , decltype(_impl_.cmd_){}
501     , decltype(_impl_.dev_){::uint64_t{0u}}
502     , decltype(_impl_.sector_){::uint64_t{0u}}
503     , decltype(_impl_.nr_sector_){0u}
504     , decltype(_impl_.bytes_){0u}
505   };
506   _impl_.rwbs_.InitDefault();
507   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
508     _impl_.rwbs_.Set("", GetArenaForAllocation());
509   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
510   _impl_.comm_.InitDefault();
511   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
512     _impl_.comm_.Set("", GetArenaForAllocation());
513   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
514   _impl_.cmd_.InitDefault();
515   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
516     _impl_.cmd_.Set("", GetArenaForAllocation());
517   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
518 }
519 
~BlockRqIssueFtraceEvent()520 BlockRqIssueFtraceEvent::~BlockRqIssueFtraceEvent() {
521   // @@protoc_insertion_point(destructor:perfetto.protos.BlockRqIssueFtraceEvent)
522   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
523   (void)arena;
524     return;
525   }
526   SharedDtor();
527 }
528 
SharedDtor()529 inline void BlockRqIssueFtraceEvent::SharedDtor() {
530   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
531   _impl_.rwbs_.Destroy();
532   _impl_.comm_.Destroy();
533   _impl_.cmd_.Destroy();
534 }
535 
SetCachedSize(int size) const536 void BlockRqIssueFtraceEvent::SetCachedSize(int size) const {
537   _impl_._cached_size_.Set(size);
538 }
539 
Clear()540 void BlockRqIssueFtraceEvent::Clear() {
541 // @@protoc_insertion_point(message_clear_start:perfetto.protos.BlockRqIssueFtraceEvent)
542   ::uint32_t cached_has_bits = 0;
543   // Prevent compiler warnings about cached_has_bits being unused
544   (void) cached_has_bits;
545 
546   cached_has_bits = _impl_._has_bits_[0];
547   if (cached_has_bits & 0x00000007u) {
548     if (cached_has_bits & 0x00000001u) {
549       _impl_.rwbs_.ClearNonDefaultToEmpty();
550     }
551     if (cached_has_bits & 0x00000002u) {
552       _impl_.comm_.ClearNonDefaultToEmpty();
553     }
554     if (cached_has_bits & 0x00000004u) {
555       _impl_.cmd_.ClearNonDefaultToEmpty();
556     }
557   }
558   if (cached_has_bits & 0x00000078u) {
559     ::memset(&_impl_.dev_, 0, static_cast<size_t>(
560         reinterpret_cast<char*>(&_impl_.bytes_) -
561         reinterpret_cast<char*>(&_impl_.dev_)) + sizeof(_impl_.bytes_));
562   }
563   _impl_._has_bits_.Clear();
564   _internal_metadata_.Clear<std::string>();
565 }
566 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)567 const char* BlockRqIssueFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
568 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
569   _Internal::HasBits has_bits{};
570   while (!ctx->Done(&ptr)) {
571     ::uint32_t tag;
572     ptr = ::_pbi::ReadTag(ptr, &tag);
573     switch (tag >> 3) {
574       // optional uint64 dev = 1;
575       case 1:
576         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
577           _Internal::set_has_dev(&has_bits);
578           _impl_.dev_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
579           CHK_(ptr);
580         } else {
581           goto handle_unusual;
582         }
583         continue;
584       // optional uint64 sector = 2;
585       case 2:
586         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
587           _Internal::set_has_sector(&has_bits);
588           _impl_.sector_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
589           CHK_(ptr);
590         } else {
591           goto handle_unusual;
592         }
593         continue;
594       // optional uint32 nr_sector = 3;
595       case 3:
596         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
597           _Internal::set_has_nr_sector(&has_bits);
598           _impl_.nr_sector_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
599           CHK_(ptr);
600         } else {
601           goto handle_unusual;
602         }
603         continue;
604       // optional uint32 bytes = 4;
605       case 4:
606         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
607           _Internal::set_has_bytes(&has_bits);
608           _impl_.bytes_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
609           CHK_(ptr);
610         } else {
611           goto handle_unusual;
612         }
613         continue;
614       // optional string rwbs = 5;
615       case 5:
616         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 42)) {
617           auto str = _internal_mutable_rwbs();
618           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
619           CHK_(ptr);
620         } else {
621           goto handle_unusual;
622         }
623         continue;
624       // optional string comm = 6;
625       case 6:
626         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 50)) {
627           auto str = _internal_mutable_comm();
628           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
629           CHK_(ptr);
630         } else {
631           goto handle_unusual;
632         }
633         continue;
634       // optional string cmd = 7;
635       case 7:
636         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 58)) {
637           auto str = _internal_mutable_cmd();
638           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
639           CHK_(ptr);
640         } else {
641           goto handle_unusual;
642         }
643         continue;
644       default:
645         goto handle_unusual;
646     }  // switch
647   handle_unusual:
648     if ((tag == 0) || ((tag & 7) == 4)) {
649       CHK_(ptr);
650       ctx->SetLastTag(tag);
651       goto message_done;
652     }
653     ptr = UnknownFieldParse(
654         tag,
655         _internal_metadata_.mutable_unknown_fields<std::string>(),
656         ptr, ctx);
657     CHK_(ptr != nullptr);
658   }  // while
659 message_done:
660   _impl_._has_bits_.Or(has_bits);
661   return ptr;
662 failure:
663   ptr = nullptr;
664   goto message_done;
665 #undef CHK_
666 }
667 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const668 ::uint8_t* BlockRqIssueFtraceEvent::_InternalSerialize(
669     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
670   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.BlockRqIssueFtraceEvent)
671   ::uint32_t cached_has_bits = 0;
672   (void) cached_has_bits;
673 
674   cached_has_bits = _impl_._has_bits_[0];
675   // optional uint64 dev = 1;
676   if (cached_has_bits & 0x00000008u) {
677     target = stream->EnsureSpace(target);
678     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_dev(), target);
679   }
680 
681   // optional uint64 sector = 2;
682   if (cached_has_bits & 0x00000010u) {
683     target = stream->EnsureSpace(target);
684     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(2, this->_internal_sector(), target);
685   }
686 
687   // optional uint32 nr_sector = 3;
688   if (cached_has_bits & 0x00000020u) {
689     target = stream->EnsureSpace(target);
690     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_nr_sector(), target);
691   }
692 
693   // optional uint32 bytes = 4;
694   if (cached_has_bits & 0x00000040u) {
695     target = stream->EnsureSpace(target);
696     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(4, this->_internal_bytes(), target);
697   }
698 
699   // optional string rwbs = 5;
700   if (cached_has_bits & 0x00000001u) {
701     target = stream->WriteStringMaybeAliased(
702         5, this->_internal_rwbs(), target);
703   }
704 
705   // optional string comm = 6;
706   if (cached_has_bits & 0x00000002u) {
707     target = stream->WriteStringMaybeAliased(
708         6, this->_internal_comm(), target);
709   }
710 
711   // optional string cmd = 7;
712   if (cached_has_bits & 0x00000004u) {
713     target = stream->WriteStringMaybeAliased(
714         7, this->_internal_cmd(), target);
715   }
716 
717   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
718     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
719         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
720   }
721   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.BlockRqIssueFtraceEvent)
722   return target;
723 }
724 
ByteSizeLong() const725 size_t BlockRqIssueFtraceEvent::ByteSizeLong() const {
726 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.BlockRqIssueFtraceEvent)
727   size_t total_size = 0;
728 
729   ::uint32_t cached_has_bits = 0;
730   // Prevent compiler warnings about cached_has_bits being unused
731   (void) cached_has_bits;
732 
733   cached_has_bits = _impl_._has_bits_[0];
734   if (cached_has_bits & 0x0000007fu) {
735     // optional string rwbs = 5;
736     if (cached_has_bits & 0x00000001u) {
737       total_size += 1 +
738         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
739           this->_internal_rwbs());
740     }
741 
742     // optional string comm = 6;
743     if (cached_has_bits & 0x00000002u) {
744       total_size += 1 +
745         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
746           this->_internal_comm());
747     }
748 
749     // optional string cmd = 7;
750     if (cached_has_bits & 0x00000004u) {
751       total_size += 1 +
752         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
753           this->_internal_cmd());
754     }
755 
756     // optional uint64 dev = 1;
757     if (cached_has_bits & 0x00000008u) {
758       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_dev());
759     }
760 
761     // optional uint64 sector = 2;
762     if (cached_has_bits & 0x00000010u) {
763       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_sector());
764     }
765 
766     // optional uint32 nr_sector = 3;
767     if (cached_has_bits & 0x00000020u) {
768       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_nr_sector());
769     }
770 
771     // optional uint32 bytes = 4;
772     if (cached_has_bits & 0x00000040u) {
773       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_bytes());
774     }
775 
776   }
777   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
778     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
779   }
780   int cached_size = ::_pbi::ToCachedSize(total_size);
781   SetCachedSize(cached_size);
782   return total_size;
783 }
784 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)785 void BlockRqIssueFtraceEvent::CheckTypeAndMergeFrom(
786     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
787   MergeFrom(*::_pbi::DownCast<const BlockRqIssueFtraceEvent*>(
788       &from));
789 }
790 
MergeFrom(const BlockRqIssueFtraceEvent & from)791 void BlockRqIssueFtraceEvent::MergeFrom(const BlockRqIssueFtraceEvent& from) {
792   BlockRqIssueFtraceEvent* const _this = this;
793   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.BlockRqIssueFtraceEvent)
794   GOOGLE_DCHECK_NE(&from, _this);
795   ::uint32_t cached_has_bits = 0;
796   (void) cached_has_bits;
797 
798   cached_has_bits = from._impl_._has_bits_[0];
799   if (cached_has_bits & 0x0000007fu) {
800     if (cached_has_bits & 0x00000001u) {
801       _this->_internal_set_rwbs(from._internal_rwbs());
802     }
803     if (cached_has_bits & 0x00000002u) {
804       _this->_internal_set_comm(from._internal_comm());
805     }
806     if (cached_has_bits & 0x00000004u) {
807       _this->_internal_set_cmd(from._internal_cmd());
808     }
809     if (cached_has_bits & 0x00000008u) {
810       _this->_impl_.dev_ = from._impl_.dev_;
811     }
812     if (cached_has_bits & 0x00000010u) {
813       _this->_impl_.sector_ = from._impl_.sector_;
814     }
815     if (cached_has_bits & 0x00000020u) {
816       _this->_impl_.nr_sector_ = from._impl_.nr_sector_;
817     }
818     if (cached_has_bits & 0x00000040u) {
819       _this->_impl_.bytes_ = from._impl_.bytes_;
820     }
821     _this->_impl_._has_bits_[0] |= cached_has_bits;
822   }
823   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
824 }
825 
CopyFrom(const BlockRqIssueFtraceEvent & from)826 void BlockRqIssueFtraceEvent::CopyFrom(const BlockRqIssueFtraceEvent& from) {
827 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.BlockRqIssueFtraceEvent)
828   if (&from == this) return;
829   Clear();
830   MergeFrom(from);
831 }
832 
IsInitialized() const833 bool BlockRqIssueFtraceEvent::IsInitialized() const {
834   return true;
835 }
836 
InternalSwap(BlockRqIssueFtraceEvent * other)837 void BlockRqIssueFtraceEvent::InternalSwap(BlockRqIssueFtraceEvent* other) {
838   using std::swap;
839   auto* lhs_arena = GetArenaForAllocation();
840   auto* rhs_arena = other->GetArenaForAllocation();
841   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
842   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
843   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
844       &_impl_.rwbs_, lhs_arena,
845       &other->_impl_.rwbs_, rhs_arena
846   );
847   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
848       &_impl_.comm_, lhs_arena,
849       &other->_impl_.comm_, rhs_arena
850   );
851   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
852       &_impl_.cmd_, lhs_arena,
853       &other->_impl_.cmd_, rhs_arena
854   );
855   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
856       PROTOBUF_FIELD_OFFSET(BlockRqIssueFtraceEvent, _impl_.bytes_)
857       + sizeof(BlockRqIssueFtraceEvent::_impl_.bytes_)  // NOLINT
858       - PROTOBUF_FIELD_OFFSET(BlockRqIssueFtraceEvent, _impl_.dev_)>(
859           reinterpret_cast<char*>(&_impl_.dev_),
860           reinterpret_cast<char*>(&other->_impl_.dev_));
861 }
862 
GetTypeName() const863 std::string BlockRqIssueFtraceEvent::GetTypeName() const {
864   return "perfetto.protos.BlockRqIssueFtraceEvent";
865 }
866 
867 
868 // ===================================================================
869 
870 class BlockBioBackmergeFtraceEvent::_Internal {
871  public:
872   using HasBits = decltype(std::declval<BlockBioBackmergeFtraceEvent>()._impl_._has_bits_);
set_has_dev(HasBits * has_bits)873   static void set_has_dev(HasBits* has_bits) {
874     (*has_bits)[0] |= 4u;
875   }
set_has_sector(HasBits * has_bits)876   static void set_has_sector(HasBits* has_bits) {
877     (*has_bits)[0] |= 8u;
878   }
set_has_nr_sector(HasBits * has_bits)879   static void set_has_nr_sector(HasBits* has_bits) {
880     (*has_bits)[0] |= 16u;
881   }
set_has_rwbs(HasBits * has_bits)882   static void set_has_rwbs(HasBits* has_bits) {
883     (*has_bits)[0] |= 1u;
884   }
set_has_comm(HasBits * has_bits)885   static void set_has_comm(HasBits* has_bits) {
886     (*has_bits)[0] |= 2u;
887   }
888 };
889 
BlockBioBackmergeFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)890 BlockBioBackmergeFtraceEvent::BlockBioBackmergeFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
891                          bool is_message_owned)
892   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
893   SharedCtor(arena, is_message_owned);
894   // @@protoc_insertion_point(arena_constructor:perfetto.protos.BlockBioBackmergeFtraceEvent)
895 }
BlockBioBackmergeFtraceEvent(const BlockBioBackmergeFtraceEvent & from)896 BlockBioBackmergeFtraceEvent::BlockBioBackmergeFtraceEvent(const BlockBioBackmergeFtraceEvent& from)
897   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
898   BlockBioBackmergeFtraceEvent* const _this = this; (void)_this;
899   new (&_impl_) Impl_{
900       decltype(_impl_._has_bits_){from._impl_._has_bits_}
901     , /*decltype(_impl_._cached_size_)*/{}
902     , decltype(_impl_.rwbs_){}
903     , decltype(_impl_.comm_){}
904     , decltype(_impl_.dev_){}
905     , decltype(_impl_.sector_){}
906     , decltype(_impl_.nr_sector_){}};
907 
908   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
909   _impl_.rwbs_.InitDefault();
910   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
911     _impl_.rwbs_.Set("", GetArenaForAllocation());
912   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
913   if (from._internal_has_rwbs()) {
914     _this->_impl_.rwbs_.Set(from._internal_rwbs(),
915       _this->GetArenaForAllocation());
916   }
917   _impl_.comm_.InitDefault();
918   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
919     _impl_.comm_.Set("", GetArenaForAllocation());
920   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
921   if (from._internal_has_comm()) {
922     _this->_impl_.comm_.Set(from._internal_comm(),
923       _this->GetArenaForAllocation());
924   }
925   ::memcpy(&_impl_.dev_, &from._impl_.dev_,
926     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.nr_sector_) -
927     reinterpret_cast<char*>(&_impl_.dev_)) + sizeof(_impl_.nr_sector_));
928   // @@protoc_insertion_point(copy_constructor:perfetto.protos.BlockBioBackmergeFtraceEvent)
929 }
930 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)931 inline void BlockBioBackmergeFtraceEvent::SharedCtor(
932     ::_pb::Arena* arena, bool is_message_owned) {
933   (void)arena;
934   (void)is_message_owned;
935   new (&_impl_) Impl_{
936       decltype(_impl_._has_bits_){}
937     , /*decltype(_impl_._cached_size_)*/{}
938     , decltype(_impl_.rwbs_){}
939     , decltype(_impl_.comm_){}
940     , decltype(_impl_.dev_){::uint64_t{0u}}
941     , decltype(_impl_.sector_){::uint64_t{0u}}
942     , decltype(_impl_.nr_sector_){0u}
943   };
944   _impl_.rwbs_.InitDefault();
945   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
946     _impl_.rwbs_.Set("", GetArenaForAllocation());
947   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
948   _impl_.comm_.InitDefault();
949   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
950     _impl_.comm_.Set("", GetArenaForAllocation());
951   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
952 }
953 
~BlockBioBackmergeFtraceEvent()954 BlockBioBackmergeFtraceEvent::~BlockBioBackmergeFtraceEvent() {
955   // @@protoc_insertion_point(destructor:perfetto.protos.BlockBioBackmergeFtraceEvent)
956   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
957   (void)arena;
958     return;
959   }
960   SharedDtor();
961 }
962 
SharedDtor()963 inline void BlockBioBackmergeFtraceEvent::SharedDtor() {
964   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
965   _impl_.rwbs_.Destroy();
966   _impl_.comm_.Destroy();
967 }
968 
SetCachedSize(int size) const969 void BlockBioBackmergeFtraceEvent::SetCachedSize(int size) const {
970   _impl_._cached_size_.Set(size);
971 }
972 
Clear()973 void BlockBioBackmergeFtraceEvent::Clear() {
974 // @@protoc_insertion_point(message_clear_start:perfetto.protos.BlockBioBackmergeFtraceEvent)
975   ::uint32_t cached_has_bits = 0;
976   // Prevent compiler warnings about cached_has_bits being unused
977   (void) cached_has_bits;
978 
979   cached_has_bits = _impl_._has_bits_[0];
980   if (cached_has_bits & 0x00000003u) {
981     if (cached_has_bits & 0x00000001u) {
982       _impl_.rwbs_.ClearNonDefaultToEmpty();
983     }
984     if (cached_has_bits & 0x00000002u) {
985       _impl_.comm_.ClearNonDefaultToEmpty();
986     }
987   }
988   if (cached_has_bits & 0x0000001cu) {
989     ::memset(&_impl_.dev_, 0, static_cast<size_t>(
990         reinterpret_cast<char*>(&_impl_.nr_sector_) -
991         reinterpret_cast<char*>(&_impl_.dev_)) + sizeof(_impl_.nr_sector_));
992   }
993   _impl_._has_bits_.Clear();
994   _internal_metadata_.Clear<std::string>();
995 }
996 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)997 const char* BlockBioBackmergeFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
998 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
999   _Internal::HasBits has_bits{};
1000   while (!ctx->Done(&ptr)) {
1001     ::uint32_t tag;
1002     ptr = ::_pbi::ReadTag(ptr, &tag);
1003     switch (tag >> 3) {
1004       // optional uint64 dev = 1;
1005       case 1:
1006         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
1007           _Internal::set_has_dev(&has_bits);
1008           _impl_.dev_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1009           CHK_(ptr);
1010         } else {
1011           goto handle_unusual;
1012         }
1013         continue;
1014       // optional uint64 sector = 2;
1015       case 2:
1016         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
1017           _Internal::set_has_sector(&has_bits);
1018           _impl_.sector_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1019           CHK_(ptr);
1020         } else {
1021           goto handle_unusual;
1022         }
1023         continue;
1024       // optional uint32 nr_sector = 3;
1025       case 3:
1026         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
1027           _Internal::set_has_nr_sector(&has_bits);
1028           _impl_.nr_sector_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1029           CHK_(ptr);
1030         } else {
1031           goto handle_unusual;
1032         }
1033         continue;
1034       // optional string rwbs = 4;
1035       case 4:
1036         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
1037           auto str = _internal_mutable_rwbs();
1038           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1039           CHK_(ptr);
1040         } else {
1041           goto handle_unusual;
1042         }
1043         continue;
1044       // optional string comm = 5;
1045       case 5:
1046         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 42)) {
1047           auto str = _internal_mutable_comm();
1048           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1049           CHK_(ptr);
1050         } else {
1051           goto handle_unusual;
1052         }
1053         continue;
1054       default:
1055         goto handle_unusual;
1056     }  // switch
1057   handle_unusual:
1058     if ((tag == 0) || ((tag & 7) == 4)) {
1059       CHK_(ptr);
1060       ctx->SetLastTag(tag);
1061       goto message_done;
1062     }
1063     ptr = UnknownFieldParse(
1064         tag,
1065         _internal_metadata_.mutable_unknown_fields<std::string>(),
1066         ptr, ctx);
1067     CHK_(ptr != nullptr);
1068   }  // while
1069 message_done:
1070   _impl_._has_bits_.Or(has_bits);
1071   return ptr;
1072 failure:
1073   ptr = nullptr;
1074   goto message_done;
1075 #undef CHK_
1076 }
1077 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1078 ::uint8_t* BlockBioBackmergeFtraceEvent::_InternalSerialize(
1079     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1080   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.BlockBioBackmergeFtraceEvent)
1081   ::uint32_t cached_has_bits = 0;
1082   (void) cached_has_bits;
1083 
1084   cached_has_bits = _impl_._has_bits_[0];
1085   // optional uint64 dev = 1;
1086   if (cached_has_bits & 0x00000004u) {
1087     target = stream->EnsureSpace(target);
1088     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_dev(), target);
1089   }
1090 
1091   // optional uint64 sector = 2;
1092   if (cached_has_bits & 0x00000008u) {
1093     target = stream->EnsureSpace(target);
1094     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(2, this->_internal_sector(), target);
1095   }
1096 
1097   // optional uint32 nr_sector = 3;
1098   if (cached_has_bits & 0x00000010u) {
1099     target = stream->EnsureSpace(target);
1100     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_nr_sector(), target);
1101   }
1102 
1103   // optional string rwbs = 4;
1104   if (cached_has_bits & 0x00000001u) {
1105     target = stream->WriteStringMaybeAliased(
1106         4, this->_internal_rwbs(), target);
1107   }
1108 
1109   // optional string comm = 5;
1110   if (cached_has_bits & 0x00000002u) {
1111     target = stream->WriteStringMaybeAliased(
1112         5, this->_internal_comm(), target);
1113   }
1114 
1115   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1116     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1117         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1118   }
1119   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.BlockBioBackmergeFtraceEvent)
1120   return target;
1121 }
1122 
ByteSizeLong() const1123 size_t BlockBioBackmergeFtraceEvent::ByteSizeLong() const {
1124 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.BlockBioBackmergeFtraceEvent)
1125   size_t total_size = 0;
1126 
1127   ::uint32_t cached_has_bits = 0;
1128   // Prevent compiler warnings about cached_has_bits being unused
1129   (void) cached_has_bits;
1130 
1131   cached_has_bits = _impl_._has_bits_[0];
1132   if (cached_has_bits & 0x0000001fu) {
1133     // optional string rwbs = 4;
1134     if (cached_has_bits & 0x00000001u) {
1135       total_size += 1 +
1136         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
1137           this->_internal_rwbs());
1138     }
1139 
1140     // optional string comm = 5;
1141     if (cached_has_bits & 0x00000002u) {
1142       total_size += 1 +
1143         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
1144           this->_internal_comm());
1145     }
1146 
1147     // optional uint64 dev = 1;
1148     if (cached_has_bits & 0x00000004u) {
1149       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_dev());
1150     }
1151 
1152     // optional uint64 sector = 2;
1153     if (cached_has_bits & 0x00000008u) {
1154       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_sector());
1155     }
1156 
1157     // optional uint32 nr_sector = 3;
1158     if (cached_has_bits & 0x00000010u) {
1159       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_nr_sector());
1160     }
1161 
1162   }
1163   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1164     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1165   }
1166   int cached_size = ::_pbi::ToCachedSize(total_size);
1167   SetCachedSize(cached_size);
1168   return total_size;
1169 }
1170 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1171 void BlockBioBackmergeFtraceEvent::CheckTypeAndMergeFrom(
1172     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1173   MergeFrom(*::_pbi::DownCast<const BlockBioBackmergeFtraceEvent*>(
1174       &from));
1175 }
1176 
MergeFrom(const BlockBioBackmergeFtraceEvent & from)1177 void BlockBioBackmergeFtraceEvent::MergeFrom(const BlockBioBackmergeFtraceEvent& from) {
1178   BlockBioBackmergeFtraceEvent* const _this = this;
1179   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.BlockBioBackmergeFtraceEvent)
1180   GOOGLE_DCHECK_NE(&from, _this);
1181   ::uint32_t cached_has_bits = 0;
1182   (void) cached_has_bits;
1183 
1184   cached_has_bits = from._impl_._has_bits_[0];
1185   if (cached_has_bits & 0x0000001fu) {
1186     if (cached_has_bits & 0x00000001u) {
1187       _this->_internal_set_rwbs(from._internal_rwbs());
1188     }
1189     if (cached_has_bits & 0x00000002u) {
1190       _this->_internal_set_comm(from._internal_comm());
1191     }
1192     if (cached_has_bits & 0x00000004u) {
1193       _this->_impl_.dev_ = from._impl_.dev_;
1194     }
1195     if (cached_has_bits & 0x00000008u) {
1196       _this->_impl_.sector_ = from._impl_.sector_;
1197     }
1198     if (cached_has_bits & 0x00000010u) {
1199       _this->_impl_.nr_sector_ = from._impl_.nr_sector_;
1200     }
1201     _this->_impl_._has_bits_[0] |= cached_has_bits;
1202   }
1203   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1204 }
1205 
CopyFrom(const BlockBioBackmergeFtraceEvent & from)1206 void BlockBioBackmergeFtraceEvent::CopyFrom(const BlockBioBackmergeFtraceEvent& from) {
1207 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.BlockBioBackmergeFtraceEvent)
1208   if (&from == this) return;
1209   Clear();
1210   MergeFrom(from);
1211 }
1212 
IsInitialized() const1213 bool BlockBioBackmergeFtraceEvent::IsInitialized() const {
1214   return true;
1215 }
1216 
InternalSwap(BlockBioBackmergeFtraceEvent * other)1217 void BlockBioBackmergeFtraceEvent::InternalSwap(BlockBioBackmergeFtraceEvent* other) {
1218   using std::swap;
1219   auto* lhs_arena = GetArenaForAllocation();
1220   auto* rhs_arena = other->GetArenaForAllocation();
1221   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1222   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
1223   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1224       &_impl_.rwbs_, lhs_arena,
1225       &other->_impl_.rwbs_, rhs_arena
1226   );
1227   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1228       &_impl_.comm_, lhs_arena,
1229       &other->_impl_.comm_, rhs_arena
1230   );
1231   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
1232       PROTOBUF_FIELD_OFFSET(BlockBioBackmergeFtraceEvent, _impl_.nr_sector_)
1233       + sizeof(BlockBioBackmergeFtraceEvent::_impl_.nr_sector_)  // NOLINT
1234       - PROTOBUF_FIELD_OFFSET(BlockBioBackmergeFtraceEvent, _impl_.dev_)>(
1235           reinterpret_cast<char*>(&_impl_.dev_),
1236           reinterpret_cast<char*>(&other->_impl_.dev_));
1237 }
1238 
GetTypeName() const1239 std::string BlockBioBackmergeFtraceEvent::GetTypeName() const {
1240   return "perfetto.protos.BlockBioBackmergeFtraceEvent";
1241 }
1242 
1243 
1244 // ===================================================================
1245 
1246 class BlockBioBounceFtraceEvent::_Internal {
1247  public:
1248   using HasBits = decltype(std::declval<BlockBioBounceFtraceEvent>()._impl_._has_bits_);
set_has_dev(HasBits * has_bits)1249   static void set_has_dev(HasBits* has_bits) {
1250     (*has_bits)[0] |= 4u;
1251   }
set_has_sector(HasBits * has_bits)1252   static void set_has_sector(HasBits* has_bits) {
1253     (*has_bits)[0] |= 8u;
1254   }
set_has_nr_sector(HasBits * has_bits)1255   static void set_has_nr_sector(HasBits* has_bits) {
1256     (*has_bits)[0] |= 16u;
1257   }
set_has_rwbs(HasBits * has_bits)1258   static void set_has_rwbs(HasBits* has_bits) {
1259     (*has_bits)[0] |= 1u;
1260   }
set_has_comm(HasBits * has_bits)1261   static void set_has_comm(HasBits* has_bits) {
1262     (*has_bits)[0] |= 2u;
1263   }
1264 };
1265 
BlockBioBounceFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1266 BlockBioBounceFtraceEvent::BlockBioBounceFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1267                          bool is_message_owned)
1268   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1269   SharedCtor(arena, is_message_owned);
1270   // @@protoc_insertion_point(arena_constructor:perfetto.protos.BlockBioBounceFtraceEvent)
1271 }
BlockBioBounceFtraceEvent(const BlockBioBounceFtraceEvent & from)1272 BlockBioBounceFtraceEvent::BlockBioBounceFtraceEvent(const BlockBioBounceFtraceEvent& from)
1273   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1274   BlockBioBounceFtraceEvent* const _this = this; (void)_this;
1275   new (&_impl_) Impl_{
1276       decltype(_impl_._has_bits_){from._impl_._has_bits_}
1277     , /*decltype(_impl_._cached_size_)*/{}
1278     , decltype(_impl_.rwbs_){}
1279     , decltype(_impl_.comm_){}
1280     , decltype(_impl_.dev_){}
1281     , decltype(_impl_.sector_){}
1282     , decltype(_impl_.nr_sector_){}};
1283 
1284   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1285   _impl_.rwbs_.InitDefault();
1286   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1287     _impl_.rwbs_.Set("", GetArenaForAllocation());
1288   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1289   if (from._internal_has_rwbs()) {
1290     _this->_impl_.rwbs_.Set(from._internal_rwbs(),
1291       _this->GetArenaForAllocation());
1292   }
1293   _impl_.comm_.InitDefault();
1294   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1295     _impl_.comm_.Set("", GetArenaForAllocation());
1296   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1297   if (from._internal_has_comm()) {
1298     _this->_impl_.comm_.Set(from._internal_comm(),
1299       _this->GetArenaForAllocation());
1300   }
1301   ::memcpy(&_impl_.dev_, &from._impl_.dev_,
1302     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.nr_sector_) -
1303     reinterpret_cast<char*>(&_impl_.dev_)) + sizeof(_impl_.nr_sector_));
1304   // @@protoc_insertion_point(copy_constructor:perfetto.protos.BlockBioBounceFtraceEvent)
1305 }
1306 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1307 inline void BlockBioBounceFtraceEvent::SharedCtor(
1308     ::_pb::Arena* arena, bool is_message_owned) {
1309   (void)arena;
1310   (void)is_message_owned;
1311   new (&_impl_) Impl_{
1312       decltype(_impl_._has_bits_){}
1313     , /*decltype(_impl_._cached_size_)*/{}
1314     , decltype(_impl_.rwbs_){}
1315     , decltype(_impl_.comm_){}
1316     , decltype(_impl_.dev_){::uint64_t{0u}}
1317     , decltype(_impl_.sector_){::uint64_t{0u}}
1318     , decltype(_impl_.nr_sector_){0u}
1319   };
1320   _impl_.rwbs_.InitDefault();
1321   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1322     _impl_.rwbs_.Set("", GetArenaForAllocation());
1323   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1324   _impl_.comm_.InitDefault();
1325   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1326     _impl_.comm_.Set("", GetArenaForAllocation());
1327   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1328 }
1329 
~BlockBioBounceFtraceEvent()1330 BlockBioBounceFtraceEvent::~BlockBioBounceFtraceEvent() {
1331   // @@protoc_insertion_point(destructor:perfetto.protos.BlockBioBounceFtraceEvent)
1332   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1333   (void)arena;
1334     return;
1335   }
1336   SharedDtor();
1337 }
1338 
SharedDtor()1339 inline void BlockBioBounceFtraceEvent::SharedDtor() {
1340   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1341   _impl_.rwbs_.Destroy();
1342   _impl_.comm_.Destroy();
1343 }
1344 
SetCachedSize(int size) const1345 void BlockBioBounceFtraceEvent::SetCachedSize(int size) const {
1346   _impl_._cached_size_.Set(size);
1347 }
1348 
Clear()1349 void BlockBioBounceFtraceEvent::Clear() {
1350 // @@protoc_insertion_point(message_clear_start:perfetto.protos.BlockBioBounceFtraceEvent)
1351   ::uint32_t cached_has_bits = 0;
1352   // Prevent compiler warnings about cached_has_bits being unused
1353   (void) cached_has_bits;
1354 
1355   cached_has_bits = _impl_._has_bits_[0];
1356   if (cached_has_bits & 0x00000003u) {
1357     if (cached_has_bits & 0x00000001u) {
1358       _impl_.rwbs_.ClearNonDefaultToEmpty();
1359     }
1360     if (cached_has_bits & 0x00000002u) {
1361       _impl_.comm_.ClearNonDefaultToEmpty();
1362     }
1363   }
1364   if (cached_has_bits & 0x0000001cu) {
1365     ::memset(&_impl_.dev_, 0, static_cast<size_t>(
1366         reinterpret_cast<char*>(&_impl_.nr_sector_) -
1367         reinterpret_cast<char*>(&_impl_.dev_)) + sizeof(_impl_.nr_sector_));
1368   }
1369   _impl_._has_bits_.Clear();
1370   _internal_metadata_.Clear<std::string>();
1371 }
1372 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1373 const char* BlockBioBounceFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1374 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1375   _Internal::HasBits has_bits{};
1376   while (!ctx->Done(&ptr)) {
1377     ::uint32_t tag;
1378     ptr = ::_pbi::ReadTag(ptr, &tag);
1379     switch (tag >> 3) {
1380       // optional uint64 dev = 1;
1381       case 1:
1382         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
1383           _Internal::set_has_dev(&has_bits);
1384           _impl_.dev_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1385           CHK_(ptr);
1386         } else {
1387           goto handle_unusual;
1388         }
1389         continue;
1390       // optional uint64 sector = 2;
1391       case 2:
1392         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
1393           _Internal::set_has_sector(&has_bits);
1394           _impl_.sector_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1395           CHK_(ptr);
1396         } else {
1397           goto handle_unusual;
1398         }
1399         continue;
1400       // optional uint32 nr_sector = 3;
1401       case 3:
1402         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
1403           _Internal::set_has_nr_sector(&has_bits);
1404           _impl_.nr_sector_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1405           CHK_(ptr);
1406         } else {
1407           goto handle_unusual;
1408         }
1409         continue;
1410       // optional string rwbs = 4;
1411       case 4:
1412         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
1413           auto str = _internal_mutable_rwbs();
1414           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1415           CHK_(ptr);
1416         } else {
1417           goto handle_unusual;
1418         }
1419         continue;
1420       // optional string comm = 5;
1421       case 5:
1422         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 42)) {
1423           auto str = _internal_mutable_comm();
1424           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1425           CHK_(ptr);
1426         } else {
1427           goto handle_unusual;
1428         }
1429         continue;
1430       default:
1431         goto handle_unusual;
1432     }  // switch
1433   handle_unusual:
1434     if ((tag == 0) || ((tag & 7) == 4)) {
1435       CHK_(ptr);
1436       ctx->SetLastTag(tag);
1437       goto message_done;
1438     }
1439     ptr = UnknownFieldParse(
1440         tag,
1441         _internal_metadata_.mutable_unknown_fields<std::string>(),
1442         ptr, ctx);
1443     CHK_(ptr != nullptr);
1444   }  // while
1445 message_done:
1446   _impl_._has_bits_.Or(has_bits);
1447   return ptr;
1448 failure:
1449   ptr = nullptr;
1450   goto message_done;
1451 #undef CHK_
1452 }
1453 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1454 ::uint8_t* BlockBioBounceFtraceEvent::_InternalSerialize(
1455     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1456   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.BlockBioBounceFtraceEvent)
1457   ::uint32_t cached_has_bits = 0;
1458   (void) cached_has_bits;
1459 
1460   cached_has_bits = _impl_._has_bits_[0];
1461   // optional uint64 dev = 1;
1462   if (cached_has_bits & 0x00000004u) {
1463     target = stream->EnsureSpace(target);
1464     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_dev(), target);
1465   }
1466 
1467   // optional uint64 sector = 2;
1468   if (cached_has_bits & 0x00000008u) {
1469     target = stream->EnsureSpace(target);
1470     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(2, this->_internal_sector(), target);
1471   }
1472 
1473   // optional uint32 nr_sector = 3;
1474   if (cached_has_bits & 0x00000010u) {
1475     target = stream->EnsureSpace(target);
1476     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_nr_sector(), target);
1477   }
1478 
1479   // optional string rwbs = 4;
1480   if (cached_has_bits & 0x00000001u) {
1481     target = stream->WriteStringMaybeAliased(
1482         4, this->_internal_rwbs(), target);
1483   }
1484 
1485   // optional string comm = 5;
1486   if (cached_has_bits & 0x00000002u) {
1487     target = stream->WriteStringMaybeAliased(
1488         5, this->_internal_comm(), target);
1489   }
1490 
1491   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1492     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1493         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1494   }
1495   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.BlockBioBounceFtraceEvent)
1496   return target;
1497 }
1498 
ByteSizeLong() const1499 size_t BlockBioBounceFtraceEvent::ByteSizeLong() const {
1500 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.BlockBioBounceFtraceEvent)
1501   size_t total_size = 0;
1502 
1503   ::uint32_t cached_has_bits = 0;
1504   // Prevent compiler warnings about cached_has_bits being unused
1505   (void) cached_has_bits;
1506 
1507   cached_has_bits = _impl_._has_bits_[0];
1508   if (cached_has_bits & 0x0000001fu) {
1509     // optional string rwbs = 4;
1510     if (cached_has_bits & 0x00000001u) {
1511       total_size += 1 +
1512         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
1513           this->_internal_rwbs());
1514     }
1515 
1516     // optional string comm = 5;
1517     if (cached_has_bits & 0x00000002u) {
1518       total_size += 1 +
1519         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
1520           this->_internal_comm());
1521     }
1522 
1523     // optional uint64 dev = 1;
1524     if (cached_has_bits & 0x00000004u) {
1525       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_dev());
1526     }
1527 
1528     // optional uint64 sector = 2;
1529     if (cached_has_bits & 0x00000008u) {
1530       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_sector());
1531     }
1532 
1533     // optional uint32 nr_sector = 3;
1534     if (cached_has_bits & 0x00000010u) {
1535       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_nr_sector());
1536     }
1537 
1538   }
1539   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1540     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1541   }
1542   int cached_size = ::_pbi::ToCachedSize(total_size);
1543   SetCachedSize(cached_size);
1544   return total_size;
1545 }
1546 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1547 void BlockBioBounceFtraceEvent::CheckTypeAndMergeFrom(
1548     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1549   MergeFrom(*::_pbi::DownCast<const BlockBioBounceFtraceEvent*>(
1550       &from));
1551 }
1552 
MergeFrom(const BlockBioBounceFtraceEvent & from)1553 void BlockBioBounceFtraceEvent::MergeFrom(const BlockBioBounceFtraceEvent& from) {
1554   BlockBioBounceFtraceEvent* const _this = this;
1555   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.BlockBioBounceFtraceEvent)
1556   GOOGLE_DCHECK_NE(&from, _this);
1557   ::uint32_t cached_has_bits = 0;
1558   (void) cached_has_bits;
1559 
1560   cached_has_bits = from._impl_._has_bits_[0];
1561   if (cached_has_bits & 0x0000001fu) {
1562     if (cached_has_bits & 0x00000001u) {
1563       _this->_internal_set_rwbs(from._internal_rwbs());
1564     }
1565     if (cached_has_bits & 0x00000002u) {
1566       _this->_internal_set_comm(from._internal_comm());
1567     }
1568     if (cached_has_bits & 0x00000004u) {
1569       _this->_impl_.dev_ = from._impl_.dev_;
1570     }
1571     if (cached_has_bits & 0x00000008u) {
1572       _this->_impl_.sector_ = from._impl_.sector_;
1573     }
1574     if (cached_has_bits & 0x00000010u) {
1575       _this->_impl_.nr_sector_ = from._impl_.nr_sector_;
1576     }
1577     _this->_impl_._has_bits_[0] |= cached_has_bits;
1578   }
1579   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1580 }
1581 
CopyFrom(const BlockBioBounceFtraceEvent & from)1582 void BlockBioBounceFtraceEvent::CopyFrom(const BlockBioBounceFtraceEvent& from) {
1583 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.BlockBioBounceFtraceEvent)
1584   if (&from == this) return;
1585   Clear();
1586   MergeFrom(from);
1587 }
1588 
IsInitialized() const1589 bool BlockBioBounceFtraceEvent::IsInitialized() const {
1590   return true;
1591 }
1592 
InternalSwap(BlockBioBounceFtraceEvent * other)1593 void BlockBioBounceFtraceEvent::InternalSwap(BlockBioBounceFtraceEvent* other) {
1594   using std::swap;
1595   auto* lhs_arena = GetArenaForAllocation();
1596   auto* rhs_arena = other->GetArenaForAllocation();
1597   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1598   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
1599   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1600       &_impl_.rwbs_, lhs_arena,
1601       &other->_impl_.rwbs_, rhs_arena
1602   );
1603   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1604       &_impl_.comm_, lhs_arena,
1605       &other->_impl_.comm_, rhs_arena
1606   );
1607   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
1608       PROTOBUF_FIELD_OFFSET(BlockBioBounceFtraceEvent, _impl_.nr_sector_)
1609       + sizeof(BlockBioBounceFtraceEvent::_impl_.nr_sector_)  // NOLINT
1610       - PROTOBUF_FIELD_OFFSET(BlockBioBounceFtraceEvent, _impl_.dev_)>(
1611           reinterpret_cast<char*>(&_impl_.dev_),
1612           reinterpret_cast<char*>(&other->_impl_.dev_));
1613 }
1614 
GetTypeName() const1615 std::string BlockBioBounceFtraceEvent::GetTypeName() const {
1616   return "perfetto.protos.BlockBioBounceFtraceEvent";
1617 }
1618 
1619 
1620 // ===================================================================
1621 
1622 class BlockBioCompleteFtraceEvent::_Internal {
1623  public:
1624   using HasBits = decltype(std::declval<BlockBioCompleteFtraceEvent>()._impl_._has_bits_);
set_has_dev(HasBits * has_bits)1625   static void set_has_dev(HasBits* has_bits) {
1626     (*has_bits)[0] |= 2u;
1627   }
set_has_sector(HasBits * has_bits)1628   static void set_has_sector(HasBits* has_bits) {
1629     (*has_bits)[0] |= 4u;
1630   }
set_has_nr_sector(HasBits * has_bits)1631   static void set_has_nr_sector(HasBits* has_bits) {
1632     (*has_bits)[0] |= 8u;
1633   }
set_has_error(HasBits * has_bits)1634   static void set_has_error(HasBits* has_bits) {
1635     (*has_bits)[0] |= 16u;
1636   }
set_has_rwbs(HasBits * has_bits)1637   static void set_has_rwbs(HasBits* has_bits) {
1638     (*has_bits)[0] |= 1u;
1639   }
1640 };
1641 
BlockBioCompleteFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1642 BlockBioCompleteFtraceEvent::BlockBioCompleteFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1643                          bool is_message_owned)
1644   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1645   SharedCtor(arena, is_message_owned);
1646   // @@protoc_insertion_point(arena_constructor:perfetto.protos.BlockBioCompleteFtraceEvent)
1647 }
BlockBioCompleteFtraceEvent(const BlockBioCompleteFtraceEvent & from)1648 BlockBioCompleteFtraceEvent::BlockBioCompleteFtraceEvent(const BlockBioCompleteFtraceEvent& from)
1649   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1650   BlockBioCompleteFtraceEvent* const _this = this; (void)_this;
1651   new (&_impl_) Impl_{
1652       decltype(_impl_._has_bits_){from._impl_._has_bits_}
1653     , /*decltype(_impl_._cached_size_)*/{}
1654     , decltype(_impl_.rwbs_){}
1655     , decltype(_impl_.dev_){}
1656     , decltype(_impl_.sector_){}
1657     , decltype(_impl_.nr_sector_){}
1658     , decltype(_impl_.error_){}};
1659 
1660   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1661   _impl_.rwbs_.InitDefault();
1662   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1663     _impl_.rwbs_.Set("", GetArenaForAllocation());
1664   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1665   if (from._internal_has_rwbs()) {
1666     _this->_impl_.rwbs_.Set(from._internal_rwbs(),
1667       _this->GetArenaForAllocation());
1668   }
1669   ::memcpy(&_impl_.dev_, &from._impl_.dev_,
1670     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.error_) -
1671     reinterpret_cast<char*>(&_impl_.dev_)) + sizeof(_impl_.error_));
1672   // @@protoc_insertion_point(copy_constructor:perfetto.protos.BlockBioCompleteFtraceEvent)
1673 }
1674 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1675 inline void BlockBioCompleteFtraceEvent::SharedCtor(
1676     ::_pb::Arena* arena, bool is_message_owned) {
1677   (void)arena;
1678   (void)is_message_owned;
1679   new (&_impl_) Impl_{
1680       decltype(_impl_._has_bits_){}
1681     , /*decltype(_impl_._cached_size_)*/{}
1682     , decltype(_impl_.rwbs_){}
1683     , decltype(_impl_.dev_){::uint64_t{0u}}
1684     , decltype(_impl_.sector_){::uint64_t{0u}}
1685     , decltype(_impl_.nr_sector_){0u}
1686     , decltype(_impl_.error_){0}
1687   };
1688   _impl_.rwbs_.InitDefault();
1689   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1690     _impl_.rwbs_.Set("", GetArenaForAllocation());
1691   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1692 }
1693 
~BlockBioCompleteFtraceEvent()1694 BlockBioCompleteFtraceEvent::~BlockBioCompleteFtraceEvent() {
1695   // @@protoc_insertion_point(destructor:perfetto.protos.BlockBioCompleteFtraceEvent)
1696   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1697   (void)arena;
1698     return;
1699   }
1700   SharedDtor();
1701 }
1702 
SharedDtor()1703 inline void BlockBioCompleteFtraceEvent::SharedDtor() {
1704   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1705   _impl_.rwbs_.Destroy();
1706 }
1707 
SetCachedSize(int size) const1708 void BlockBioCompleteFtraceEvent::SetCachedSize(int size) const {
1709   _impl_._cached_size_.Set(size);
1710 }
1711 
Clear()1712 void BlockBioCompleteFtraceEvent::Clear() {
1713 // @@protoc_insertion_point(message_clear_start:perfetto.protos.BlockBioCompleteFtraceEvent)
1714   ::uint32_t cached_has_bits = 0;
1715   // Prevent compiler warnings about cached_has_bits being unused
1716   (void) cached_has_bits;
1717 
1718   cached_has_bits = _impl_._has_bits_[0];
1719   if (cached_has_bits & 0x00000001u) {
1720     _impl_.rwbs_.ClearNonDefaultToEmpty();
1721   }
1722   if (cached_has_bits & 0x0000001eu) {
1723     ::memset(&_impl_.dev_, 0, static_cast<size_t>(
1724         reinterpret_cast<char*>(&_impl_.error_) -
1725         reinterpret_cast<char*>(&_impl_.dev_)) + sizeof(_impl_.error_));
1726   }
1727   _impl_._has_bits_.Clear();
1728   _internal_metadata_.Clear<std::string>();
1729 }
1730 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1731 const char* BlockBioCompleteFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1732 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1733   _Internal::HasBits has_bits{};
1734   while (!ctx->Done(&ptr)) {
1735     ::uint32_t tag;
1736     ptr = ::_pbi::ReadTag(ptr, &tag);
1737     switch (tag >> 3) {
1738       // optional uint64 dev = 1;
1739       case 1:
1740         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
1741           _Internal::set_has_dev(&has_bits);
1742           _impl_.dev_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1743           CHK_(ptr);
1744         } else {
1745           goto handle_unusual;
1746         }
1747         continue;
1748       // optional uint64 sector = 2;
1749       case 2:
1750         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
1751           _Internal::set_has_sector(&has_bits);
1752           _impl_.sector_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1753           CHK_(ptr);
1754         } else {
1755           goto handle_unusual;
1756         }
1757         continue;
1758       // optional uint32 nr_sector = 3;
1759       case 3:
1760         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
1761           _Internal::set_has_nr_sector(&has_bits);
1762           _impl_.nr_sector_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1763           CHK_(ptr);
1764         } else {
1765           goto handle_unusual;
1766         }
1767         continue;
1768       // optional int32 error = 4;
1769       case 4:
1770         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
1771           _Internal::set_has_error(&has_bits);
1772           _impl_.error_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1773           CHK_(ptr);
1774         } else {
1775           goto handle_unusual;
1776         }
1777         continue;
1778       // optional string rwbs = 5;
1779       case 5:
1780         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 42)) {
1781           auto str = _internal_mutable_rwbs();
1782           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1783           CHK_(ptr);
1784         } else {
1785           goto handle_unusual;
1786         }
1787         continue;
1788       default:
1789         goto handle_unusual;
1790     }  // switch
1791   handle_unusual:
1792     if ((tag == 0) || ((tag & 7) == 4)) {
1793       CHK_(ptr);
1794       ctx->SetLastTag(tag);
1795       goto message_done;
1796     }
1797     ptr = UnknownFieldParse(
1798         tag,
1799         _internal_metadata_.mutable_unknown_fields<std::string>(),
1800         ptr, ctx);
1801     CHK_(ptr != nullptr);
1802   }  // while
1803 message_done:
1804   _impl_._has_bits_.Or(has_bits);
1805   return ptr;
1806 failure:
1807   ptr = nullptr;
1808   goto message_done;
1809 #undef CHK_
1810 }
1811 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1812 ::uint8_t* BlockBioCompleteFtraceEvent::_InternalSerialize(
1813     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1814   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.BlockBioCompleteFtraceEvent)
1815   ::uint32_t cached_has_bits = 0;
1816   (void) cached_has_bits;
1817 
1818   cached_has_bits = _impl_._has_bits_[0];
1819   // optional uint64 dev = 1;
1820   if (cached_has_bits & 0x00000002u) {
1821     target = stream->EnsureSpace(target);
1822     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_dev(), target);
1823   }
1824 
1825   // optional uint64 sector = 2;
1826   if (cached_has_bits & 0x00000004u) {
1827     target = stream->EnsureSpace(target);
1828     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(2, this->_internal_sector(), target);
1829   }
1830 
1831   // optional uint32 nr_sector = 3;
1832   if (cached_has_bits & 0x00000008u) {
1833     target = stream->EnsureSpace(target);
1834     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_nr_sector(), target);
1835   }
1836 
1837   // optional int32 error = 4;
1838   if (cached_has_bits & 0x00000010u) {
1839     target = stream->EnsureSpace(target);
1840     target = ::_pbi::WireFormatLite::WriteInt32ToArray(4, this->_internal_error(), target);
1841   }
1842 
1843   // optional string rwbs = 5;
1844   if (cached_has_bits & 0x00000001u) {
1845     target = stream->WriteStringMaybeAliased(
1846         5, this->_internal_rwbs(), target);
1847   }
1848 
1849   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1850     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1851         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1852   }
1853   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.BlockBioCompleteFtraceEvent)
1854   return target;
1855 }
1856 
ByteSizeLong() const1857 size_t BlockBioCompleteFtraceEvent::ByteSizeLong() const {
1858 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.BlockBioCompleteFtraceEvent)
1859   size_t total_size = 0;
1860 
1861   ::uint32_t cached_has_bits = 0;
1862   // Prevent compiler warnings about cached_has_bits being unused
1863   (void) cached_has_bits;
1864 
1865   cached_has_bits = _impl_._has_bits_[0];
1866   if (cached_has_bits & 0x0000001fu) {
1867     // optional string rwbs = 5;
1868     if (cached_has_bits & 0x00000001u) {
1869       total_size += 1 +
1870         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
1871           this->_internal_rwbs());
1872     }
1873 
1874     // optional uint64 dev = 1;
1875     if (cached_has_bits & 0x00000002u) {
1876       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_dev());
1877     }
1878 
1879     // optional uint64 sector = 2;
1880     if (cached_has_bits & 0x00000004u) {
1881       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_sector());
1882     }
1883 
1884     // optional uint32 nr_sector = 3;
1885     if (cached_has_bits & 0x00000008u) {
1886       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_nr_sector());
1887     }
1888 
1889     // optional int32 error = 4;
1890     if (cached_has_bits & 0x00000010u) {
1891       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_error());
1892     }
1893 
1894   }
1895   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1896     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1897   }
1898   int cached_size = ::_pbi::ToCachedSize(total_size);
1899   SetCachedSize(cached_size);
1900   return total_size;
1901 }
1902 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1903 void BlockBioCompleteFtraceEvent::CheckTypeAndMergeFrom(
1904     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1905   MergeFrom(*::_pbi::DownCast<const BlockBioCompleteFtraceEvent*>(
1906       &from));
1907 }
1908 
MergeFrom(const BlockBioCompleteFtraceEvent & from)1909 void BlockBioCompleteFtraceEvent::MergeFrom(const BlockBioCompleteFtraceEvent& from) {
1910   BlockBioCompleteFtraceEvent* const _this = this;
1911   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.BlockBioCompleteFtraceEvent)
1912   GOOGLE_DCHECK_NE(&from, _this);
1913   ::uint32_t cached_has_bits = 0;
1914   (void) cached_has_bits;
1915 
1916   cached_has_bits = from._impl_._has_bits_[0];
1917   if (cached_has_bits & 0x0000001fu) {
1918     if (cached_has_bits & 0x00000001u) {
1919       _this->_internal_set_rwbs(from._internal_rwbs());
1920     }
1921     if (cached_has_bits & 0x00000002u) {
1922       _this->_impl_.dev_ = from._impl_.dev_;
1923     }
1924     if (cached_has_bits & 0x00000004u) {
1925       _this->_impl_.sector_ = from._impl_.sector_;
1926     }
1927     if (cached_has_bits & 0x00000008u) {
1928       _this->_impl_.nr_sector_ = from._impl_.nr_sector_;
1929     }
1930     if (cached_has_bits & 0x00000010u) {
1931       _this->_impl_.error_ = from._impl_.error_;
1932     }
1933     _this->_impl_._has_bits_[0] |= cached_has_bits;
1934   }
1935   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1936 }
1937 
CopyFrom(const BlockBioCompleteFtraceEvent & from)1938 void BlockBioCompleteFtraceEvent::CopyFrom(const BlockBioCompleteFtraceEvent& from) {
1939 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.BlockBioCompleteFtraceEvent)
1940   if (&from == this) return;
1941   Clear();
1942   MergeFrom(from);
1943 }
1944 
IsInitialized() const1945 bool BlockBioCompleteFtraceEvent::IsInitialized() const {
1946   return true;
1947 }
1948 
InternalSwap(BlockBioCompleteFtraceEvent * other)1949 void BlockBioCompleteFtraceEvent::InternalSwap(BlockBioCompleteFtraceEvent* other) {
1950   using std::swap;
1951   auto* lhs_arena = GetArenaForAllocation();
1952   auto* rhs_arena = other->GetArenaForAllocation();
1953   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1954   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
1955   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1956       &_impl_.rwbs_, lhs_arena,
1957       &other->_impl_.rwbs_, rhs_arena
1958   );
1959   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
1960       PROTOBUF_FIELD_OFFSET(BlockBioCompleteFtraceEvent, _impl_.error_)
1961       + sizeof(BlockBioCompleteFtraceEvent::_impl_.error_)  // NOLINT
1962       - PROTOBUF_FIELD_OFFSET(BlockBioCompleteFtraceEvent, _impl_.dev_)>(
1963           reinterpret_cast<char*>(&_impl_.dev_),
1964           reinterpret_cast<char*>(&other->_impl_.dev_));
1965 }
1966 
GetTypeName() const1967 std::string BlockBioCompleteFtraceEvent::GetTypeName() const {
1968   return "perfetto.protos.BlockBioCompleteFtraceEvent";
1969 }
1970 
1971 
1972 // ===================================================================
1973 
1974 class BlockBioFrontmergeFtraceEvent::_Internal {
1975  public:
1976   using HasBits = decltype(std::declval<BlockBioFrontmergeFtraceEvent>()._impl_._has_bits_);
set_has_dev(HasBits * has_bits)1977   static void set_has_dev(HasBits* has_bits) {
1978     (*has_bits)[0] |= 4u;
1979   }
set_has_sector(HasBits * has_bits)1980   static void set_has_sector(HasBits* has_bits) {
1981     (*has_bits)[0] |= 8u;
1982   }
set_has_nr_sector(HasBits * has_bits)1983   static void set_has_nr_sector(HasBits* has_bits) {
1984     (*has_bits)[0] |= 16u;
1985   }
set_has_rwbs(HasBits * has_bits)1986   static void set_has_rwbs(HasBits* has_bits) {
1987     (*has_bits)[0] |= 1u;
1988   }
set_has_comm(HasBits * has_bits)1989   static void set_has_comm(HasBits* has_bits) {
1990     (*has_bits)[0] |= 2u;
1991   }
1992 };
1993 
BlockBioFrontmergeFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1994 BlockBioFrontmergeFtraceEvent::BlockBioFrontmergeFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1995                          bool is_message_owned)
1996   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1997   SharedCtor(arena, is_message_owned);
1998   // @@protoc_insertion_point(arena_constructor:perfetto.protos.BlockBioFrontmergeFtraceEvent)
1999 }
BlockBioFrontmergeFtraceEvent(const BlockBioFrontmergeFtraceEvent & from)2000 BlockBioFrontmergeFtraceEvent::BlockBioFrontmergeFtraceEvent(const BlockBioFrontmergeFtraceEvent& from)
2001   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
2002   BlockBioFrontmergeFtraceEvent* const _this = this; (void)_this;
2003   new (&_impl_) Impl_{
2004       decltype(_impl_._has_bits_){from._impl_._has_bits_}
2005     , /*decltype(_impl_._cached_size_)*/{}
2006     , decltype(_impl_.rwbs_){}
2007     , decltype(_impl_.comm_){}
2008     , decltype(_impl_.dev_){}
2009     , decltype(_impl_.sector_){}
2010     , decltype(_impl_.nr_sector_){}};
2011 
2012   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2013   _impl_.rwbs_.InitDefault();
2014   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2015     _impl_.rwbs_.Set("", GetArenaForAllocation());
2016   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2017   if (from._internal_has_rwbs()) {
2018     _this->_impl_.rwbs_.Set(from._internal_rwbs(),
2019       _this->GetArenaForAllocation());
2020   }
2021   _impl_.comm_.InitDefault();
2022   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2023     _impl_.comm_.Set("", GetArenaForAllocation());
2024   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2025   if (from._internal_has_comm()) {
2026     _this->_impl_.comm_.Set(from._internal_comm(),
2027       _this->GetArenaForAllocation());
2028   }
2029   ::memcpy(&_impl_.dev_, &from._impl_.dev_,
2030     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.nr_sector_) -
2031     reinterpret_cast<char*>(&_impl_.dev_)) + sizeof(_impl_.nr_sector_));
2032   // @@protoc_insertion_point(copy_constructor:perfetto.protos.BlockBioFrontmergeFtraceEvent)
2033 }
2034 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)2035 inline void BlockBioFrontmergeFtraceEvent::SharedCtor(
2036     ::_pb::Arena* arena, bool is_message_owned) {
2037   (void)arena;
2038   (void)is_message_owned;
2039   new (&_impl_) Impl_{
2040       decltype(_impl_._has_bits_){}
2041     , /*decltype(_impl_._cached_size_)*/{}
2042     , decltype(_impl_.rwbs_){}
2043     , decltype(_impl_.comm_){}
2044     , decltype(_impl_.dev_){::uint64_t{0u}}
2045     , decltype(_impl_.sector_){::uint64_t{0u}}
2046     , decltype(_impl_.nr_sector_){0u}
2047   };
2048   _impl_.rwbs_.InitDefault();
2049   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2050     _impl_.rwbs_.Set("", GetArenaForAllocation());
2051   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2052   _impl_.comm_.InitDefault();
2053   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2054     _impl_.comm_.Set("", GetArenaForAllocation());
2055   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2056 }
2057 
~BlockBioFrontmergeFtraceEvent()2058 BlockBioFrontmergeFtraceEvent::~BlockBioFrontmergeFtraceEvent() {
2059   // @@protoc_insertion_point(destructor:perfetto.protos.BlockBioFrontmergeFtraceEvent)
2060   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
2061   (void)arena;
2062     return;
2063   }
2064   SharedDtor();
2065 }
2066 
SharedDtor()2067 inline void BlockBioFrontmergeFtraceEvent::SharedDtor() {
2068   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
2069   _impl_.rwbs_.Destroy();
2070   _impl_.comm_.Destroy();
2071 }
2072 
SetCachedSize(int size) const2073 void BlockBioFrontmergeFtraceEvent::SetCachedSize(int size) const {
2074   _impl_._cached_size_.Set(size);
2075 }
2076 
Clear()2077 void BlockBioFrontmergeFtraceEvent::Clear() {
2078 // @@protoc_insertion_point(message_clear_start:perfetto.protos.BlockBioFrontmergeFtraceEvent)
2079   ::uint32_t cached_has_bits = 0;
2080   // Prevent compiler warnings about cached_has_bits being unused
2081   (void) cached_has_bits;
2082 
2083   cached_has_bits = _impl_._has_bits_[0];
2084   if (cached_has_bits & 0x00000003u) {
2085     if (cached_has_bits & 0x00000001u) {
2086       _impl_.rwbs_.ClearNonDefaultToEmpty();
2087     }
2088     if (cached_has_bits & 0x00000002u) {
2089       _impl_.comm_.ClearNonDefaultToEmpty();
2090     }
2091   }
2092   if (cached_has_bits & 0x0000001cu) {
2093     ::memset(&_impl_.dev_, 0, static_cast<size_t>(
2094         reinterpret_cast<char*>(&_impl_.nr_sector_) -
2095         reinterpret_cast<char*>(&_impl_.dev_)) + sizeof(_impl_.nr_sector_));
2096   }
2097   _impl_._has_bits_.Clear();
2098   _internal_metadata_.Clear<std::string>();
2099 }
2100 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)2101 const char* BlockBioFrontmergeFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
2102 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
2103   _Internal::HasBits has_bits{};
2104   while (!ctx->Done(&ptr)) {
2105     ::uint32_t tag;
2106     ptr = ::_pbi::ReadTag(ptr, &tag);
2107     switch (tag >> 3) {
2108       // optional uint64 dev = 1;
2109       case 1:
2110         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
2111           _Internal::set_has_dev(&has_bits);
2112           _impl_.dev_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
2113           CHK_(ptr);
2114         } else {
2115           goto handle_unusual;
2116         }
2117         continue;
2118       // optional uint64 sector = 2;
2119       case 2:
2120         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
2121           _Internal::set_has_sector(&has_bits);
2122           _impl_.sector_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
2123           CHK_(ptr);
2124         } else {
2125           goto handle_unusual;
2126         }
2127         continue;
2128       // optional uint32 nr_sector = 3;
2129       case 3:
2130         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
2131           _Internal::set_has_nr_sector(&has_bits);
2132           _impl_.nr_sector_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
2133           CHK_(ptr);
2134         } else {
2135           goto handle_unusual;
2136         }
2137         continue;
2138       // optional string rwbs = 4;
2139       case 4:
2140         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
2141           auto str = _internal_mutable_rwbs();
2142           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
2143           CHK_(ptr);
2144         } else {
2145           goto handle_unusual;
2146         }
2147         continue;
2148       // optional string comm = 5;
2149       case 5:
2150         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 42)) {
2151           auto str = _internal_mutable_comm();
2152           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
2153           CHK_(ptr);
2154         } else {
2155           goto handle_unusual;
2156         }
2157         continue;
2158       default:
2159         goto handle_unusual;
2160     }  // switch
2161   handle_unusual:
2162     if ((tag == 0) || ((tag & 7) == 4)) {
2163       CHK_(ptr);
2164       ctx->SetLastTag(tag);
2165       goto message_done;
2166     }
2167     ptr = UnknownFieldParse(
2168         tag,
2169         _internal_metadata_.mutable_unknown_fields<std::string>(),
2170         ptr, ctx);
2171     CHK_(ptr != nullptr);
2172   }  // while
2173 message_done:
2174   _impl_._has_bits_.Or(has_bits);
2175   return ptr;
2176 failure:
2177   ptr = nullptr;
2178   goto message_done;
2179 #undef CHK_
2180 }
2181 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const2182 ::uint8_t* BlockBioFrontmergeFtraceEvent::_InternalSerialize(
2183     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
2184   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.BlockBioFrontmergeFtraceEvent)
2185   ::uint32_t cached_has_bits = 0;
2186   (void) cached_has_bits;
2187 
2188   cached_has_bits = _impl_._has_bits_[0];
2189   // optional uint64 dev = 1;
2190   if (cached_has_bits & 0x00000004u) {
2191     target = stream->EnsureSpace(target);
2192     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_dev(), target);
2193   }
2194 
2195   // optional uint64 sector = 2;
2196   if (cached_has_bits & 0x00000008u) {
2197     target = stream->EnsureSpace(target);
2198     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(2, this->_internal_sector(), target);
2199   }
2200 
2201   // optional uint32 nr_sector = 3;
2202   if (cached_has_bits & 0x00000010u) {
2203     target = stream->EnsureSpace(target);
2204     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_nr_sector(), target);
2205   }
2206 
2207   // optional string rwbs = 4;
2208   if (cached_has_bits & 0x00000001u) {
2209     target = stream->WriteStringMaybeAliased(
2210         4, this->_internal_rwbs(), target);
2211   }
2212 
2213   // optional string comm = 5;
2214   if (cached_has_bits & 0x00000002u) {
2215     target = stream->WriteStringMaybeAliased(
2216         5, this->_internal_comm(), target);
2217   }
2218 
2219   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2220     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
2221         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
2222   }
2223   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.BlockBioFrontmergeFtraceEvent)
2224   return target;
2225 }
2226 
ByteSizeLong() const2227 size_t BlockBioFrontmergeFtraceEvent::ByteSizeLong() const {
2228 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.BlockBioFrontmergeFtraceEvent)
2229   size_t total_size = 0;
2230 
2231   ::uint32_t cached_has_bits = 0;
2232   // Prevent compiler warnings about cached_has_bits being unused
2233   (void) cached_has_bits;
2234 
2235   cached_has_bits = _impl_._has_bits_[0];
2236   if (cached_has_bits & 0x0000001fu) {
2237     // optional string rwbs = 4;
2238     if (cached_has_bits & 0x00000001u) {
2239       total_size += 1 +
2240         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
2241           this->_internal_rwbs());
2242     }
2243 
2244     // optional string comm = 5;
2245     if (cached_has_bits & 0x00000002u) {
2246       total_size += 1 +
2247         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
2248           this->_internal_comm());
2249     }
2250 
2251     // optional uint64 dev = 1;
2252     if (cached_has_bits & 0x00000004u) {
2253       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_dev());
2254     }
2255 
2256     // optional uint64 sector = 2;
2257     if (cached_has_bits & 0x00000008u) {
2258       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_sector());
2259     }
2260 
2261     // optional uint32 nr_sector = 3;
2262     if (cached_has_bits & 0x00000010u) {
2263       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_nr_sector());
2264     }
2265 
2266   }
2267   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2268     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
2269   }
2270   int cached_size = ::_pbi::ToCachedSize(total_size);
2271   SetCachedSize(cached_size);
2272   return total_size;
2273 }
2274 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)2275 void BlockBioFrontmergeFtraceEvent::CheckTypeAndMergeFrom(
2276     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
2277   MergeFrom(*::_pbi::DownCast<const BlockBioFrontmergeFtraceEvent*>(
2278       &from));
2279 }
2280 
MergeFrom(const BlockBioFrontmergeFtraceEvent & from)2281 void BlockBioFrontmergeFtraceEvent::MergeFrom(const BlockBioFrontmergeFtraceEvent& from) {
2282   BlockBioFrontmergeFtraceEvent* const _this = this;
2283   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.BlockBioFrontmergeFtraceEvent)
2284   GOOGLE_DCHECK_NE(&from, _this);
2285   ::uint32_t cached_has_bits = 0;
2286   (void) cached_has_bits;
2287 
2288   cached_has_bits = from._impl_._has_bits_[0];
2289   if (cached_has_bits & 0x0000001fu) {
2290     if (cached_has_bits & 0x00000001u) {
2291       _this->_internal_set_rwbs(from._internal_rwbs());
2292     }
2293     if (cached_has_bits & 0x00000002u) {
2294       _this->_internal_set_comm(from._internal_comm());
2295     }
2296     if (cached_has_bits & 0x00000004u) {
2297       _this->_impl_.dev_ = from._impl_.dev_;
2298     }
2299     if (cached_has_bits & 0x00000008u) {
2300       _this->_impl_.sector_ = from._impl_.sector_;
2301     }
2302     if (cached_has_bits & 0x00000010u) {
2303       _this->_impl_.nr_sector_ = from._impl_.nr_sector_;
2304     }
2305     _this->_impl_._has_bits_[0] |= cached_has_bits;
2306   }
2307   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2308 }
2309 
CopyFrom(const BlockBioFrontmergeFtraceEvent & from)2310 void BlockBioFrontmergeFtraceEvent::CopyFrom(const BlockBioFrontmergeFtraceEvent& from) {
2311 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.BlockBioFrontmergeFtraceEvent)
2312   if (&from == this) return;
2313   Clear();
2314   MergeFrom(from);
2315 }
2316 
IsInitialized() const2317 bool BlockBioFrontmergeFtraceEvent::IsInitialized() const {
2318   return true;
2319 }
2320 
InternalSwap(BlockBioFrontmergeFtraceEvent * other)2321 void BlockBioFrontmergeFtraceEvent::InternalSwap(BlockBioFrontmergeFtraceEvent* other) {
2322   using std::swap;
2323   auto* lhs_arena = GetArenaForAllocation();
2324   auto* rhs_arena = other->GetArenaForAllocation();
2325   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2326   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
2327   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
2328       &_impl_.rwbs_, lhs_arena,
2329       &other->_impl_.rwbs_, rhs_arena
2330   );
2331   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
2332       &_impl_.comm_, lhs_arena,
2333       &other->_impl_.comm_, rhs_arena
2334   );
2335   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
2336       PROTOBUF_FIELD_OFFSET(BlockBioFrontmergeFtraceEvent, _impl_.nr_sector_)
2337       + sizeof(BlockBioFrontmergeFtraceEvent::_impl_.nr_sector_)  // NOLINT
2338       - PROTOBUF_FIELD_OFFSET(BlockBioFrontmergeFtraceEvent, _impl_.dev_)>(
2339           reinterpret_cast<char*>(&_impl_.dev_),
2340           reinterpret_cast<char*>(&other->_impl_.dev_));
2341 }
2342 
GetTypeName() const2343 std::string BlockBioFrontmergeFtraceEvent::GetTypeName() const {
2344   return "perfetto.protos.BlockBioFrontmergeFtraceEvent";
2345 }
2346 
2347 
2348 // ===================================================================
2349 
2350 class BlockBioQueueFtraceEvent::_Internal {
2351  public:
2352   using HasBits = decltype(std::declval<BlockBioQueueFtraceEvent>()._impl_._has_bits_);
set_has_dev(HasBits * has_bits)2353   static void set_has_dev(HasBits* has_bits) {
2354     (*has_bits)[0] |= 4u;
2355   }
set_has_sector(HasBits * has_bits)2356   static void set_has_sector(HasBits* has_bits) {
2357     (*has_bits)[0] |= 8u;
2358   }
set_has_nr_sector(HasBits * has_bits)2359   static void set_has_nr_sector(HasBits* has_bits) {
2360     (*has_bits)[0] |= 16u;
2361   }
set_has_rwbs(HasBits * has_bits)2362   static void set_has_rwbs(HasBits* has_bits) {
2363     (*has_bits)[0] |= 1u;
2364   }
set_has_comm(HasBits * has_bits)2365   static void set_has_comm(HasBits* has_bits) {
2366     (*has_bits)[0] |= 2u;
2367   }
2368 };
2369 
BlockBioQueueFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)2370 BlockBioQueueFtraceEvent::BlockBioQueueFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2371                          bool is_message_owned)
2372   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
2373   SharedCtor(arena, is_message_owned);
2374   // @@protoc_insertion_point(arena_constructor:perfetto.protos.BlockBioQueueFtraceEvent)
2375 }
BlockBioQueueFtraceEvent(const BlockBioQueueFtraceEvent & from)2376 BlockBioQueueFtraceEvent::BlockBioQueueFtraceEvent(const BlockBioQueueFtraceEvent& from)
2377   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
2378   BlockBioQueueFtraceEvent* const _this = this; (void)_this;
2379   new (&_impl_) Impl_{
2380       decltype(_impl_._has_bits_){from._impl_._has_bits_}
2381     , /*decltype(_impl_._cached_size_)*/{}
2382     , decltype(_impl_.rwbs_){}
2383     , decltype(_impl_.comm_){}
2384     , decltype(_impl_.dev_){}
2385     , decltype(_impl_.sector_){}
2386     , decltype(_impl_.nr_sector_){}};
2387 
2388   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2389   _impl_.rwbs_.InitDefault();
2390   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2391     _impl_.rwbs_.Set("", GetArenaForAllocation());
2392   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2393   if (from._internal_has_rwbs()) {
2394     _this->_impl_.rwbs_.Set(from._internal_rwbs(),
2395       _this->GetArenaForAllocation());
2396   }
2397   _impl_.comm_.InitDefault();
2398   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2399     _impl_.comm_.Set("", GetArenaForAllocation());
2400   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2401   if (from._internal_has_comm()) {
2402     _this->_impl_.comm_.Set(from._internal_comm(),
2403       _this->GetArenaForAllocation());
2404   }
2405   ::memcpy(&_impl_.dev_, &from._impl_.dev_,
2406     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.nr_sector_) -
2407     reinterpret_cast<char*>(&_impl_.dev_)) + sizeof(_impl_.nr_sector_));
2408   // @@protoc_insertion_point(copy_constructor:perfetto.protos.BlockBioQueueFtraceEvent)
2409 }
2410 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)2411 inline void BlockBioQueueFtraceEvent::SharedCtor(
2412     ::_pb::Arena* arena, bool is_message_owned) {
2413   (void)arena;
2414   (void)is_message_owned;
2415   new (&_impl_) Impl_{
2416       decltype(_impl_._has_bits_){}
2417     , /*decltype(_impl_._cached_size_)*/{}
2418     , decltype(_impl_.rwbs_){}
2419     , decltype(_impl_.comm_){}
2420     , decltype(_impl_.dev_){::uint64_t{0u}}
2421     , decltype(_impl_.sector_){::uint64_t{0u}}
2422     , decltype(_impl_.nr_sector_){0u}
2423   };
2424   _impl_.rwbs_.InitDefault();
2425   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2426     _impl_.rwbs_.Set("", GetArenaForAllocation());
2427   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2428   _impl_.comm_.InitDefault();
2429   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2430     _impl_.comm_.Set("", GetArenaForAllocation());
2431   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2432 }
2433 
~BlockBioQueueFtraceEvent()2434 BlockBioQueueFtraceEvent::~BlockBioQueueFtraceEvent() {
2435   // @@protoc_insertion_point(destructor:perfetto.protos.BlockBioQueueFtraceEvent)
2436   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
2437   (void)arena;
2438     return;
2439   }
2440   SharedDtor();
2441 }
2442 
SharedDtor()2443 inline void BlockBioQueueFtraceEvent::SharedDtor() {
2444   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
2445   _impl_.rwbs_.Destroy();
2446   _impl_.comm_.Destroy();
2447 }
2448 
SetCachedSize(int size) const2449 void BlockBioQueueFtraceEvent::SetCachedSize(int size) const {
2450   _impl_._cached_size_.Set(size);
2451 }
2452 
Clear()2453 void BlockBioQueueFtraceEvent::Clear() {
2454 // @@protoc_insertion_point(message_clear_start:perfetto.protos.BlockBioQueueFtraceEvent)
2455   ::uint32_t cached_has_bits = 0;
2456   // Prevent compiler warnings about cached_has_bits being unused
2457   (void) cached_has_bits;
2458 
2459   cached_has_bits = _impl_._has_bits_[0];
2460   if (cached_has_bits & 0x00000003u) {
2461     if (cached_has_bits & 0x00000001u) {
2462       _impl_.rwbs_.ClearNonDefaultToEmpty();
2463     }
2464     if (cached_has_bits & 0x00000002u) {
2465       _impl_.comm_.ClearNonDefaultToEmpty();
2466     }
2467   }
2468   if (cached_has_bits & 0x0000001cu) {
2469     ::memset(&_impl_.dev_, 0, static_cast<size_t>(
2470         reinterpret_cast<char*>(&_impl_.nr_sector_) -
2471         reinterpret_cast<char*>(&_impl_.dev_)) + sizeof(_impl_.nr_sector_));
2472   }
2473   _impl_._has_bits_.Clear();
2474   _internal_metadata_.Clear<std::string>();
2475 }
2476 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)2477 const char* BlockBioQueueFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
2478 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
2479   _Internal::HasBits has_bits{};
2480   while (!ctx->Done(&ptr)) {
2481     ::uint32_t tag;
2482     ptr = ::_pbi::ReadTag(ptr, &tag);
2483     switch (tag >> 3) {
2484       // optional uint64 dev = 1;
2485       case 1:
2486         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
2487           _Internal::set_has_dev(&has_bits);
2488           _impl_.dev_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
2489           CHK_(ptr);
2490         } else {
2491           goto handle_unusual;
2492         }
2493         continue;
2494       // optional uint64 sector = 2;
2495       case 2:
2496         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
2497           _Internal::set_has_sector(&has_bits);
2498           _impl_.sector_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
2499           CHK_(ptr);
2500         } else {
2501           goto handle_unusual;
2502         }
2503         continue;
2504       // optional uint32 nr_sector = 3;
2505       case 3:
2506         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
2507           _Internal::set_has_nr_sector(&has_bits);
2508           _impl_.nr_sector_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
2509           CHK_(ptr);
2510         } else {
2511           goto handle_unusual;
2512         }
2513         continue;
2514       // optional string rwbs = 4;
2515       case 4:
2516         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
2517           auto str = _internal_mutable_rwbs();
2518           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
2519           CHK_(ptr);
2520         } else {
2521           goto handle_unusual;
2522         }
2523         continue;
2524       // optional string comm = 5;
2525       case 5:
2526         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 42)) {
2527           auto str = _internal_mutable_comm();
2528           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
2529           CHK_(ptr);
2530         } else {
2531           goto handle_unusual;
2532         }
2533         continue;
2534       default:
2535         goto handle_unusual;
2536     }  // switch
2537   handle_unusual:
2538     if ((tag == 0) || ((tag & 7) == 4)) {
2539       CHK_(ptr);
2540       ctx->SetLastTag(tag);
2541       goto message_done;
2542     }
2543     ptr = UnknownFieldParse(
2544         tag,
2545         _internal_metadata_.mutable_unknown_fields<std::string>(),
2546         ptr, ctx);
2547     CHK_(ptr != nullptr);
2548   }  // while
2549 message_done:
2550   _impl_._has_bits_.Or(has_bits);
2551   return ptr;
2552 failure:
2553   ptr = nullptr;
2554   goto message_done;
2555 #undef CHK_
2556 }
2557 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const2558 ::uint8_t* BlockBioQueueFtraceEvent::_InternalSerialize(
2559     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
2560   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.BlockBioQueueFtraceEvent)
2561   ::uint32_t cached_has_bits = 0;
2562   (void) cached_has_bits;
2563 
2564   cached_has_bits = _impl_._has_bits_[0];
2565   // optional uint64 dev = 1;
2566   if (cached_has_bits & 0x00000004u) {
2567     target = stream->EnsureSpace(target);
2568     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_dev(), target);
2569   }
2570 
2571   // optional uint64 sector = 2;
2572   if (cached_has_bits & 0x00000008u) {
2573     target = stream->EnsureSpace(target);
2574     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(2, this->_internal_sector(), target);
2575   }
2576 
2577   // optional uint32 nr_sector = 3;
2578   if (cached_has_bits & 0x00000010u) {
2579     target = stream->EnsureSpace(target);
2580     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_nr_sector(), target);
2581   }
2582 
2583   // optional string rwbs = 4;
2584   if (cached_has_bits & 0x00000001u) {
2585     target = stream->WriteStringMaybeAliased(
2586         4, this->_internal_rwbs(), target);
2587   }
2588 
2589   // optional string comm = 5;
2590   if (cached_has_bits & 0x00000002u) {
2591     target = stream->WriteStringMaybeAliased(
2592         5, this->_internal_comm(), target);
2593   }
2594 
2595   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2596     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
2597         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
2598   }
2599   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.BlockBioQueueFtraceEvent)
2600   return target;
2601 }
2602 
ByteSizeLong() const2603 size_t BlockBioQueueFtraceEvent::ByteSizeLong() const {
2604 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.BlockBioQueueFtraceEvent)
2605   size_t total_size = 0;
2606 
2607   ::uint32_t cached_has_bits = 0;
2608   // Prevent compiler warnings about cached_has_bits being unused
2609   (void) cached_has_bits;
2610 
2611   cached_has_bits = _impl_._has_bits_[0];
2612   if (cached_has_bits & 0x0000001fu) {
2613     // optional string rwbs = 4;
2614     if (cached_has_bits & 0x00000001u) {
2615       total_size += 1 +
2616         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
2617           this->_internal_rwbs());
2618     }
2619 
2620     // optional string comm = 5;
2621     if (cached_has_bits & 0x00000002u) {
2622       total_size += 1 +
2623         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
2624           this->_internal_comm());
2625     }
2626 
2627     // optional uint64 dev = 1;
2628     if (cached_has_bits & 0x00000004u) {
2629       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_dev());
2630     }
2631 
2632     // optional uint64 sector = 2;
2633     if (cached_has_bits & 0x00000008u) {
2634       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_sector());
2635     }
2636 
2637     // optional uint32 nr_sector = 3;
2638     if (cached_has_bits & 0x00000010u) {
2639       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_nr_sector());
2640     }
2641 
2642   }
2643   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2644     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
2645   }
2646   int cached_size = ::_pbi::ToCachedSize(total_size);
2647   SetCachedSize(cached_size);
2648   return total_size;
2649 }
2650 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)2651 void BlockBioQueueFtraceEvent::CheckTypeAndMergeFrom(
2652     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
2653   MergeFrom(*::_pbi::DownCast<const BlockBioQueueFtraceEvent*>(
2654       &from));
2655 }
2656 
MergeFrom(const BlockBioQueueFtraceEvent & from)2657 void BlockBioQueueFtraceEvent::MergeFrom(const BlockBioQueueFtraceEvent& from) {
2658   BlockBioQueueFtraceEvent* const _this = this;
2659   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.BlockBioQueueFtraceEvent)
2660   GOOGLE_DCHECK_NE(&from, _this);
2661   ::uint32_t cached_has_bits = 0;
2662   (void) cached_has_bits;
2663 
2664   cached_has_bits = from._impl_._has_bits_[0];
2665   if (cached_has_bits & 0x0000001fu) {
2666     if (cached_has_bits & 0x00000001u) {
2667       _this->_internal_set_rwbs(from._internal_rwbs());
2668     }
2669     if (cached_has_bits & 0x00000002u) {
2670       _this->_internal_set_comm(from._internal_comm());
2671     }
2672     if (cached_has_bits & 0x00000004u) {
2673       _this->_impl_.dev_ = from._impl_.dev_;
2674     }
2675     if (cached_has_bits & 0x00000008u) {
2676       _this->_impl_.sector_ = from._impl_.sector_;
2677     }
2678     if (cached_has_bits & 0x00000010u) {
2679       _this->_impl_.nr_sector_ = from._impl_.nr_sector_;
2680     }
2681     _this->_impl_._has_bits_[0] |= cached_has_bits;
2682   }
2683   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2684 }
2685 
CopyFrom(const BlockBioQueueFtraceEvent & from)2686 void BlockBioQueueFtraceEvent::CopyFrom(const BlockBioQueueFtraceEvent& from) {
2687 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.BlockBioQueueFtraceEvent)
2688   if (&from == this) return;
2689   Clear();
2690   MergeFrom(from);
2691 }
2692 
IsInitialized() const2693 bool BlockBioQueueFtraceEvent::IsInitialized() const {
2694   return true;
2695 }
2696 
InternalSwap(BlockBioQueueFtraceEvent * other)2697 void BlockBioQueueFtraceEvent::InternalSwap(BlockBioQueueFtraceEvent* other) {
2698   using std::swap;
2699   auto* lhs_arena = GetArenaForAllocation();
2700   auto* rhs_arena = other->GetArenaForAllocation();
2701   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2702   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
2703   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
2704       &_impl_.rwbs_, lhs_arena,
2705       &other->_impl_.rwbs_, rhs_arena
2706   );
2707   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
2708       &_impl_.comm_, lhs_arena,
2709       &other->_impl_.comm_, rhs_arena
2710   );
2711   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
2712       PROTOBUF_FIELD_OFFSET(BlockBioQueueFtraceEvent, _impl_.nr_sector_)
2713       + sizeof(BlockBioQueueFtraceEvent::_impl_.nr_sector_)  // NOLINT
2714       - PROTOBUF_FIELD_OFFSET(BlockBioQueueFtraceEvent, _impl_.dev_)>(
2715           reinterpret_cast<char*>(&_impl_.dev_),
2716           reinterpret_cast<char*>(&other->_impl_.dev_));
2717 }
2718 
GetTypeName() const2719 std::string BlockBioQueueFtraceEvent::GetTypeName() const {
2720   return "perfetto.protos.BlockBioQueueFtraceEvent";
2721 }
2722 
2723 
2724 // ===================================================================
2725 
2726 class BlockBioRemapFtraceEvent::_Internal {
2727  public:
2728   using HasBits = decltype(std::declval<BlockBioRemapFtraceEvent>()._impl_._has_bits_);
set_has_dev(HasBits * has_bits)2729   static void set_has_dev(HasBits* has_bits) {
2730     (*has_bits)[0] |= 2u;
2731   }
set_has_sector(HasBits * has_bits)2732   static void set_has_sector(HasBits* has_bits) {
2733     (*has_bits)[0] |= 4u;
2734   }
set_has_nr_sector(HasBits * has_bits)2735   static void set_has_nr_sector(HasBits* has_bits) {
2736     (*has_bits)[0] |= 32u;
2737   }
set_has_old_dev(HasBits * has_bits)2738   static void set_has_old_dev(HasBits* has_bits) {
2739     (*has_bits)[0] |= 8u;
2740   }
set_has_old_sector(HasBits * has_bits)2741   static void set_has_old_sector(HasBits* has_bits) {
2742     (*has_bits)[0] |= 16u;
2743   }
set_has_rwbs(HasBits * has_bits)2744   static void set_has_rwbs(HasBits* has_bits) {
2745     (*has_bits)[0] |= 1u;
2746   }
2747 };
2748 
BlockBioRemapFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)2749 BlockBioRemapFtraceEvent::BlockBioRemapFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2750                          bool is_message_owned)
2751   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
2752   SharedCtor(arena, is_message_owned);
2753   // @@protoc_insertion_point(arena_constructor:perfetto.protos.BlockBioRemapFtraceEvent)
2754 }
BlockBioRemapFtraceEvent(const BlockBioRemapFtraceEvent & from)2755 BlockBioRemapFtraceEvent::BlockBioRemapFtraceEvent(const BlockBioRemapFtraceEvent& from)
2756   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
2757   BlockBioRemapFtraceEvent* const _this = this; (void)_this;
2758   new (&_impl_) Impl_{
2759       decltype(_impl_._has_bits_){from._impl_._has_bits_}
2760     , /*decltype(_impl_._cached_size_)*/{}
2761     , decltype(_impl_.rwbs_){}
2762     , decltype(_impl_.dev_){}
2763     , decltype(_impl_.sector_){}
2764     , decltype(_impl_.old_dev_){}
2765     , decltype(_impl_.old_sector_){}
2766     , decltype(_impl_.nr_sector_){}};
2767 
2768   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2769   _impl_.rwbs_.InitDefault();
2770   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2771     _impl_.rwbs_.Set("", GetArenaForAllocation());
2772   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2773   if (from._internal_has_rwbs()) {
2774     _this->_impl_.rwbs_.Set(from._internal_rwbs(),
2775       _this->GetArenaForAllocation());
2776   }
2777   ::memcpy(&_impl_.dev_, &from._impl_.dev_,
2778     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.nr_sector_) -
2779     reinterpret_cast<char*>(&_impl_.dev_)) + sizeof(_impl_.nr_sector_));
2780   // @@protoc_insertion_point(copy_constructor:perfetto.protos.BlockBioRemapFtraceEvent)
2781 }
2782 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)2783 inline void BlockBioRemapFtraceEvent::SharedCtor(
2784     ::_pb::Arena* arena, bool is_message_owned) {
2785   (void)arena;
2786   (void)is_message_owned;
2787   new (&_impl_) Impl_{
2788       decltype(_impl_._has_bits_){}
2789     , /*decltype(_impl_._cached_size_)*/{}
2790     , decltype(_impl_.rwbs_){}
2791     , decltype(_impl_.dev_){::uint64_t{0u}}
2792     , decltype(_impl_.sector_){::uint64_t{0u}}
2793     , decltype(_impl_.old_dev_){::uint64_t{0u}}
2794     , decltype(_impl_.old_sector_){::uint64_t{0u}}
2795     , decltype(_impl_.nr_sector_){0u}
2796   };
2797   _impl_.rwbs_.InitDefault();
2798   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2799     _impl_.rwbs_.Set("", GetArenaForAllocation());
2800   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2801 }
2802 
~BlockBioRemapFtraceEvent()2803 BlockBioRemapFtraceEvent::~BlockBioRemapFtraceEvent() {
2804   // @@protoc_insertion_point(destructor:perfetto.protos.BlockBioRemapFtraceEvent)
2805   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
2806   (void)arena;
2807     return;
2808   }
2809   SharedDtor();
2810 }
2811 
SharedDtor()2812 inline void BlockBioRemapFtraceEvent::SharedDtor() {
2813   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
2814   _impl_.rwbs_.Destroy();
2815 }
2816 
SetCachedSize(int size) const2817 void BlockBioRemapFtraceEvent::SetCachedSize(int size) const {
2818   _impl_._cached_size_.Set(size);
2819 }
2820 
Clear()2821 void BlockBioRemapFtraceEvent::Clear() {
2822 // @@protoc_insertion_point(message_clear_start:perfetto.protos.BlockBioRemapFtraceEvent)
2823   ::uint32_t cached_has_bits = 0;
2824   // Prevent compiler warnings about cached_has_bits being unused
2825   (void) cached_has_bits;
2826 
2827   cached_has_bits = _impl_._has_bits_[0];
2828   if (cached_has_bits & 0x00000001u) {
2829     _impl_.rwbs_.ClearNonDefaultToEmpty();
2830   }
2831   if (cached_has_bits & 0x0000003eu) {
2832     ::memset(&_impl_.dev_, 0, static_cast<size_t>(
2833         reinterpret_cast<char*>(&_impl_.nr_sector_) -
2834         reinterpret_cast<char*>(&_impl_.dev_)) + sizeof(_impl_.nr_sector_));
2835   }
2836   _impl_._has_bits_.Clear();
2837   _internal_metadata_.Clear<std::string>();
2838 }
2839 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)2840 const char* BlockBioRemapFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
2841 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
2842   _Internal::HasBits has_bits{};
2843   while (!ctx->Done(&ptr)) {
2844     ::uint32_t tag;
2845     ptr = ::_pbi::ReadTag(ptr, &tag);
2846     switch (tag >> 3) {
2847       // optional uint64 dev = 1;
2848       case 1:
2849         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
2850           _Internal::set_has_dev(&has_bits);
2851           _impl_.dev_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
2852           CHK_(ptr);
2853         } else {
2854           goto handle_unusual;
2855         }
2856         continue;
2857       // optional uint64 sector = 2;
2858       case 2:
2859         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
2860           _Internal::set_has_sector(&has_bits);
2861           _impl_.sector_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
2862           CHK_(ptr);
2863         } else {
2864           goto handle_unusual;
2865         }
2866         continue;
2867       // optional uint32 nr_sector = 3;
2868       case 3:
2869         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
2870           _Internal::set_has_nr_sector(&has_bits);
2871           _impl_.nr_sector_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
2872           CHK_(ptr);
2873         } else {
2874           goto handle_unusual;
2875         }
2876         continue;
2877       // optional uint64 old_dev = 4;
2878       case 4:
2879         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
2880           _Internal::set_has_old_dev(&has_bits);
2881           _impl_.old_dev_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
2882           CHK_(ptr);
2883         } else {
2884           goto handle_unusual;
2885         }
2886         continue;
2887       // optional uint64 old_sector = 5;
2888       case 5:
2889         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
2890           _Internal::set_has_old_sector(&has_bits);
2891           _impl_.old_sector_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
2892           CHK_(ptr);
2893         } else {
2894           goto handle_unusual;
2895         }
2896         continue;
2897       // optional string rwbs = 6;
2898       case 6:
2899         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 50)) {
2900           auto str = _internal_mutable_rwbs();
2901           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
2902           CHK_(ptr);
2903         } else {
2904           goto handle_unusual;
2905         }
2906         continue;
2907       default:
2908         goto handle_unusual;
2909     }  // switch
2910   handle_unusual:
2911     if ((tag == 0) || ((tag & 7) == 4)) {
2912       CHK_(ptr);
2913       ctx->SetLastTag(tag);
2914       goto message_done;
2915     }
2916     ptr = UnknownFieldParse(
2917         tag,
2918         _internal_metadata_.mutable_unknown_fields<std::string>(),
2919         ptr, ctx);
2920     CHK_(ptr != nullptr);
2921   }  // while
2922 message_done:
2923   _impl_._has_bits_.Or(has_bits);
2924   return ptr;
2925 failure:
2926   ptr = nullptr;
2927   goto message_done;
2928 #undef CHK_
2929 }
2930 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const2931 ::uint8_t* BlockBioRemapFtraceEvent::_InternalSerialize(
2932     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
2933   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.BlockBioRemapFtraceEvent)
2934   ::uint32_t cached_has_bits = 0;
2935   (void) cached_has_bits;
2936 
2937   cached_has_bits = _impl_._has_bits_[0];
2938   // optional uint64 dev = 1;
2939   if (cached_has_bits & 0x00000002u) {
2940     target = stream->EnsureSpace(target);
2941     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_dev(), target);
2942   }
2943 
2944   // optional uint64 sector = 2;
2945   if (cached_has_bits & 0x00000004u) {
2946     target = stream->EnsureSpace(target);
2947     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(2, this->_internal_sector(), target);
2948   }
2949 
2950   // optional uint32 nr_sector = 3;
2951   if (cached_has_bits & 0x00000020u) {
2952     target = stream->EnsureSpace(target);
2953     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_nr_sector(), target);
2954   }
2955 
2956   // optional uint64 old_dev = 4;
2957   if (cached_has_bits & 0x00000008u) {
2958     target = stream->EnsureSpace(target);
2959     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(4, this->_internal_old_dev(), target);
2960   }
2961 
2962   // optional uint64 old_sector = 5;
2963   if (cached_has_bits & 0x00000010u) {
2964     target = stream->EnsureSpace(target);
2965     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(5, this->_internal_old_sector(), target);
2966   }
2967 
2968   // optional string rwbs = 6;
2969   if (cached_has_bits & 0x00000001u) {
2970     target = stream->WriteStringMaybeAliased(
2971         6, this->_internal_rwbs(), target);
2972   }
2973 
2974   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2975     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
2976         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
2977   }
2978   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.BlockBioRemapFtraceEvent)
2979   return target;
2980 }
2981 
ByteSizeLong() const2982 size_t BlockBioRemapFtraceEvent::ByteSizeLong() const {
2983 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.BlockBioRemapFtraceEvent)
2984   size_t total_size = 0;
2985 
2986   ::uint32_t cached_has_bits = 0;
2987   // Prevent compiler warnings about cached_has_bits being unused
2988   (void) cached_has_bits;
2989 
2990   cached_has_bits = _impl_._has_bits_[0];
2991   if (cached_has_bits & 0x0000003fu) {
2992     // optional string rwbs = 6;
2993     if (cached_has_bits & 0x00000001u) {
2994       total_size += 1 +
2995         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
2996           this->_internal_rwbs());
2997     }
2998 
2999     // optional uint64 dev = 1;
3000     if (cached_has_bits & 0x00000002u) {
3001       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_dev());
3002     }
3003 
3004     // optional uint64 sector = 2;
3005     if (cached_has_bits & 0x00000004u) {
3006       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_sector());
3007     }
3008 
3009     // optional uint64 old_dev = 4;
3010     if (cached_has_bits & 0x00000008u) {
3011       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_old_dev());
3012     }
3013 
3014     // optional uint64 old_sector = 5;
3015     if (cached_has_bits & 0x00000010u) {
3016       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_old_sector());
3017     }
3018 
3019     // optional uint32 nr_sector = 3;
3020     if (cached_has_bits & 0x00000020u) {
3021       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_nr_sector());
3022     }
3023 
3024   }
3025   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
3026     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
3027   }
3028   int cached_size = ::_pbi::ToCachedSize(total_size);
3029   SetCachedSize(cached_size);
3030   return total_size;
3031 }
3032 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)3033 void BlockBioRemapFtraceEvent::CheckTypeAndMergeFrom(
3034     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
3035   MergeFrom(*::_pbi::DownCast<const BlockBioRemapFtraceEvent*>(
3036       &from));
3037 }
3038 
MergeFrom(const BlockBioRemapFtraceEvent & from)3039 void BlockBioRemapFtraceEvent::MergeFrom(const BlockBioRemapFtraceEvent& from) {
3040   BlockBioRemapFtraceEvent* const _this = this;
3041   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.BlockBioRemapFtraceEvent)
3042   GOOGLE_DCHECK_NE(&from, _this);
3043   ::uint32_t cached_has_bits = 0;
3044   (void) cached_has_bits;
3045 
3046   cached_has_bits = from._impl_._has_bits_[0];
3047   if (cached_has_bits & 0x0000003fu) {
3048     if (cached_has_bits & 0x00000001u) {
3049       _this->_internal_set_rwbs(from._internal_rwbs());
3050     }
3051     if (cached_has_bits & 0x00000002u) {
3052       _this->_impl_.dev_ = from._impl_.dev_;
3053     }
3054     if (cached_has_bits & 0x00000004u) {
3055       _this->_impl_.sector_ = from._impl_.sector_;
3056     }
3057     if (cached_has_bits & 0x00000008u) {
3058       _this->_impl_.old_dev_ = from._impl_.old_dev_;
3059     }
3060     if (cached_has_bits & 0x00000010u) {
3061       _this->_impl_.old_sector_ = from._impl_.old_sector_;
3062     }
3063     if (cached_has_bits & 0x00000020u) {
3064       _this->_impl_.nr_sector_ = from._impl_.nr_sector_;
3065     }
3066     _this->_impl_._has_bits_[0] |= cached_has_bits;
3067   }
3068   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
3069 }
3070 
CopyFrom(const BlockBioRemapFtraceEvent & from)3071 void BlockBioRemapFtraceEvent::CopyFrom(const BlockBioRemapFtraceEvent& from) {
3072 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.BlockBioRemapFtraceEvent)
3073   if (&from == this) return;
3074   Clear();
3075   MergeFrom(from);
3076 }
3077 
IsInitialized() const3078 bool BlockBioRemapFtraceEvent::IsInitialized() const {
3079   return true;
3080 }
3081 
InternalSwap(BlockBioRemapFtraceEvent * other)3082 void BlockBioRemapFtraceEvent::InternalSwap(BlockBioRemapFtraceEvent* other) {
3083   using std::swap;
3084   auto* lhs_arena = GetArenaForAllocation();
3085   auto* rhs_arena = other->GetArenaForAllocation();
3086   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
3087   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
3088   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
3089       &_impl_.rwbs_, lhs_arena,
3090       &other->_impl_.rwbs_, rhs_arena
3091   );
3092   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
3093       PROTOBUF_FIELD_OFFSET(BlockBioRemapFtraceEvent, _impl_.nr_sector_)
3094       + sizeof(BlockBioRemapFtraceEvent::_impl_.nr_sector_)  // NOLINT
3095       - PROTOBUF_FIELD_OFFSET(BlockBioRemapFtraceEvent, _impl_.dev_)>(
3096           reinterpret_cast<char*>(&_impl_.dev_),
3097           reinterpret_cast<char*>(&other->_impl_.dev_));
3098 }
3099 
GetTypeName() const3100 std::string BlockBioRemapFtraceEvent::GetTypeName() const {
3101   return "perfetto.protos.BlockBioRemapFtraceEvent";
3102 }
3103 
3104 
3105 // ===================================================================
3106 
3107 class BlockDirtyBufferFtraceEvent::_Internal {
3108  public:
3109   using HasBits = decltype(std::declval<BlockDirtyBufferFtraceEvent>()._impl_._has_bits_);
set_has_dev(HasBits * has_bits)3110   static void set_has_dev(HasBits* has_bits) {
3111     (*has_bits)[0] |= 1u;
3112   }
set_has_sector(HasBits * has_bits)3113   static void set_has_sector(HasBits* has_bits) {
3114     (*has_bits)[0] |= 2u;
3115   }
set_has_size(HasBits * has_bits)3116   static void set_has_size(HasBits* has_bits) {
3117     (*has_bits)[0] |= 4u;
3118   }
3119 };
3120 
BlockDirtyBufferFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)3121 BlockDirtyBufferFtraceEvent::BlockDirtyBufferFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
3122                          bool is_message_owned)
3123   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
3124   SharedCtor(arena, is_message_owned);
3125   // @@protoc_insertion_point(arena_constructor:perfetto.protos.BlockDirtyBufferFtraceEvent)
3126 }
BlockDirtyBufferFtraceEvent(const BlockDirtyBufferFtraceEvent & from)3127 BlockDirtyBufferFtraceEvent::BlockDirtyBufferFtraceEvent(const BlockDirtyBufferFtraceEvent& from)
3128   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
3129   BlockDirtyBufferFtraceEvent* const _this = this; (void)_this;
3130   new (&_impl_) Impl_{
3131       decltype(_impl_._has_bits_){from._impl_._has_bits_}
3132     , /*decltype(_impl_._cached_size_)*/{}
3133     , decltype(_impl_.dev_){}
3134     , decltype(_impl_.sector_){}
3135     , decltype(_impl_.size_){}};
3136 
3137   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
3138   ::memcpy(&_impl_.dev_, &from._impl_.dev_,
3139     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.size_) -
3140     reinterpret_cast<char*>(&_impl_.dev_)) + sizeof(_impl_.size_));
3141   // @@protoc_insertion_point(copy_constructor:perfetto.protos.BlockDirtyBufferFtraceEvent)
3142 }
3143 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)3144 inline void BlockDirtyBufferFtraceEvent::SharedCtor(
3145     ::_pb::Arena* arena, bool is_message_owned) {
3146   (void)arena;
3147   (void)is_message_owned;
3148   new (&_impl_) Impl_{
3149       decltype(_impl_._has_bits_){}
3150     , /*decltype(_impl_._cached_size_)*/{}
3151     , decltype(_impl_.dev_){::uint64_t{0u}}
3152     , decltype(_impl_.sector_){::uint64_t{0u}}
3153     , decltype(_impl_.size_){::uint64_t{0u}}
3154   };
3155 }
3156 
~BlockDirtyBufferFtraceEvent()3157 BlockDirtyBufferFtraceEvent::~BlockDirtyBufferFtraceEvent() {
3158   // @@protoc_insertion_point(destructor:perfetto.protos.BlockDirtyBufferFtraceEvent)
3159   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
3160   (void)arena;
3161     return;
3162   }
3163   SharedDtor();
3164 }
3165 
SharedDtor()3166 inline void BlockDirtyBufferFtraceEvent::SharedDtor() {
3167   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
3168 }
3169 
SetCachedSize(int size) const3170 void BlockDirtyBufferFtraceEvent::SetCachedSize(int size) const {
3171   _impl_._cached_size_.Set(size);
3172 }
3173 
Clear()3174 void BlockDirtyBufferFtraceEvent::Clear() {
3175 // @@protoc_insertion_point(message_clear_start:perfetto.protos.BlockDirtyBufferFtraceEvent)
3176   ::uint32_t cached_has_bits = 0;
3177   // Prevent compiler warnings about cached_has_bits being unused
3178   (void) cached_has_bits;
3179 
3180   cached_has_bits = _impl_._has_bits_[0];
3181   if (cached_has_bits & 0x00000007u) {
3182     ::memset(&_impl_.dev_, 0, static_cast<size_t>(
3183         reinterpret_cast<char*>(&_impl_.size_) -
3184         reinterpret_cast<char*>(&_impl_.dev_)) + sizeof(_impl_.size_));
3185   }
3186   _impl_._has_bits_.Clear();
3187   _internal_metadata_.Clear<std::string>();
3188 }
3189 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)3190 const char* BlockDirtyBufferFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
3191 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
3192   _Internal::HasBits has_bits{};
3193   while (!ctx->Done(&ptr)) {
3194     ::uint32_t tag;
3195     ptr = ::_pbi::ReadTag(ptr, &tag);
3196     switch (tag >> 3) {
3197       // optional uint64 dev = 1;
3198       case 1:
3199         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
3200           _Internal::set_has_dev(&has_bits);
3201           _impl_.dev_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
3202           CHK_(ptr);
3203         } else {
3204           goto handle_unusual;
3205         }
3206         continue;
3207       // optional uint64 sector = 2;
3208       case 2:
3209         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
3210           _Internal::set_has_sector(&has_bits);
3211           _impl_.sector_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
3212           CHK_(ptr);
3213         } else {
3214           goto handle_unusual;
3215         }
3216         continue;
3217       // optional uint64 size = 3;
3218       case 3:
3219         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
3220           _Internal::set_has_size(&has_bits);
3221           _impl_.size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
3222           CHK_(ptr);
3223         } else {
3224           goto handle_unusual;
3225         }
3226         continue;
3227       default:
3228         goto handle_unusual;
3229     }  // switch
3230   handle_unusual:
3231     if ((tag == 0) || ((tag & 7) == 4)) {
3232       CHK_(ptr);
3233       ctx->SetLastTag(tag);
3234       goto message_done;
3235     }
3236     ptr = UnknownFieldParse(
3237         tag,
3238         _internal_metadata_.mutable_unknown_fields<std::string>(),
3239         ptr, ctx);
3240     CHK_(ptr != nullptr);
3241   }  // while
3242 message_done:
3243   _impl_._has_bits_.Or(has_bits);
3244   return ptr;
3245 failure:
3246   ptr = nullptr;
3247   goto message_done;
3248 #undef CHK_
3249 }
3250 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const3251 ::uint8_t* BlockDirtyBufferFtraceEvent::_InternalSerialize(
3252     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
3253   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.BlockDirtyBufferFtraceEvent)
3254   ::uint32_t cached_has_bits = 0;
3255   (void) cached_has_bits;
3256 
3257   cached_has_bits = _impl_._has_bits_[0];
3258   // optional uint64 dev = 1;
3259   if (cached_has_bits & 0x00000001u) {
3260     target = stream->EnsureSpace(target);
3261     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_dev(), target);
3262   }
3263 
3264   // optional uint64 sector = 2;
3265   if (cached_has_bits & 0x00000002u) {
3266     target = stream->EnsureSpace(target);
3267     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(2, this->_internal_sector(), target);
3268   }
3269 
3270   // optional uint64 size = 3;
3271   if (cached_has_bits & 0x00000004u) {
3272     target = stream->EnsureSpace(target);
3273     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(3, this->_internal_size(), target);
3274   }
3275 
3276   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
3277     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
3278         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
3279   }
3280   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.BlockDirtyBufferFtraceEvent)
3281   return target;
3282 }
3283 
ByteSizeLong() const3284 size_t BlockDirtyBufferFtraceEvent::ByteSizeLong() const {
3285 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.BlockDirtyBufferFtraceEvent)
3286   size_t total_size = 0;
3287 
3288   ::uint32_t cached_has_bits = 0;
3289   // Prevent compiler warnings about cached_has_bits being unused
3290   (void) cached_has_bits;
3291 
3292   cached_has_bits = _impl_._has_bits_[0];
3293   if (cached_has_bits & 0x00000007u) {
3294     // optional uint64 dev = 1;
3295     if (cached_has_bits & 0x00000001u) {
3296       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_dev());
3297     }
3298 
3299     // optional uint64 sector = 2;
3300     if (cached_has_bits & 0x00000002u) {
3301       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_sector());
3302     }
3303 
3304     // optional uint64 size = 3;
3305     if (cached_has_bits & 0x00000004u) {
3306       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_size());
3307     }
3308 
3309   }
3310   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
3311     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
3312   }
3313   int cached_size = ::_pbi::ToCachedSize(total_size);
3314   SetCachedSize(cached_size);
3315   return total_size;
3316 }
3317 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)3318 void BlockDirtyBufferFtraceEvent::CheckTypeAndMergeFrom(
3319     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
3320   MergeFrom(*::_pbi::DownCast<const BlockDirtyBufferFtraceEvent*>(
3321       &from));
3322 }
3323 
MergeFrom(const BlockDirtyBufferFtraceEvent & from)3324 void BlockDirtyBufferFtraceEvent::MergeFrom(const BlockDirtyBufferFtraceEvent& from) {
3325   BlockDirtyBufferFtraceEvent* const _this = this;
3326   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.BlockDirtyBufferFtraceEvent)
3327   GOOGLE_DCHECK_NE(&from, _this);
3328   ::uint32_t cached_has_bits = 0;
3329   (void) cached_has_bits;
3330 
3331   cached_has_bits = from._impl_._has_bits_[0];
3332   if (cached_has_bits & 0x00000007u) {
3333     if (cached_has_bits & 0x00000001u) {
3334       _this->_impl_.dev_ = from._impl_.dev_;
3335     }
3336     if (cached_has_bits & 0x00000002u) {
3337       _this->_impl_.sector_ = from._impl_.sector_;
3338     }
3339     if (cached_has_bits & 0x00000004u) {
3340       _this->_impl_.size_ = from._impl_.size_;
3341     }
3342     _this->_impl_._has_bits_[0] |= cached_has_bits;
3343   }
3344   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
3345 }
3346 
CopyFrom(const BlockDirtyBufferFtraceEvent & from)3347 void BlockDirtyBufferFtraceEvent::CopyFrom(const BlockDirtyBufferFtraceEvent& from) {
3348 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.BlockDirtyBufferFtraceEvent)
3349   if (&from == this) return;
3350   Clear();
3351   MergeFrom(from);
3352 }
3353 
IsInitialized() const3354 bool BlockDirtyBufferFtraceEvent::IsInitialized() const {
3355   return true;
3356 }
3357 
InternalSwap(BlockDirtyBufferFtraceEvent * other)3358 void BlockDirtyBufferFtraceEvent::InternalSwap(BlockDirtyBufferFtraceEvent* other) {
3359   using std::swap;
3360   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
3361   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
3362   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
3363       PROTOBUF_FIELD_OFFSET(BlockDirtyBufferFtraceEvent, _impl_.size_)
3364       + sizeof(BlockDirtyBufferFtraceEvent::_impl_.size_)  // NOLINT
3365       - PROTOBUF_FIELD_OFFSET(BlockDirtyBufferFtraceEvent, _impl_.dev_)>(
3366           reinterpret_cast<char*>(&_impl_.dev_),
3367           reinterpret_cast<char*>(&other->_impl_.dev_));
3368 }
3369 
GetTypeName() const3370 std::string BlockDirtyBufferFtraceEvent::GetTypeName() const {
3371   return "perfetto.protos.BlockDirtyBufferFtraceEvent";
3372 }
3373 
3374 
3375 // ===================================================================
3376 
3377 class BlockGetrqFtraceEvent::_Internal {
3378  public:
3379   using HasBits = decltype(std::declval<BlockGetrqFtraceEvent>()._impl_._has_bits_);
set_has_dev(HasBits * has_bits)3380   static void set_has_dev(HasBits* has_bits) {
3381     (*has_bits)[0] |= 4u;
3382   }
set_has_sector(HasBits * has_bits)3383   static void set_has_sector(HasBits* has_bits) {
3384     (*has_bits)[0] |= 8u;
3385   }
set_has_nr_sector(HasBits * has_bits)3386   static void set_has_nr_sector(HasBits* has_bits) {
3387     (*has_bits)[0] |= 16u;
3388   }
set_has_rwbs(HasBits * has_bits)3389   static void set_has_rwbs(HasBits* has_bits) {
3390     (*has_bits)[0] |= 1u;
3391   }
set_has_comm(HasBits * has_bits)3392   static void set_has_comm(HasBits* has_bits) {
3393     (*has_bits)[0] |= 2u;
3394   }
3395 };
3396 
BlockGetrqFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)3397 BlockGetrqFtraceEvent::BlockGetrqFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
3398                          bool is_message_owned)
3399   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
3400   SharedCtor(arena, is_message_owned);
3401   // @@protoc_insertion_point(arena_constructor:perfetto.protos.BlockGetrqFtraceEvent)
3402 }
BlockGetrqFtraceEvent(const BlockGetrqFtraceEvent & from)3403 BlockGetrqFtraceEvent::BlockGetrqFtraceEvent(const BlockGetrqFtraceEvent& from)
3404   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
3405   BlockGetrqFtraceEvent* const _this = this; (void)_this;
3406   new (&_impl_) Impl_{
3407       decltype(_impl_._has_bits_){from._impl_._has_bits_}
3408     , /*decltype(_impl_._cached_size_)*/{}
3409     , decltype(_impl_.rwbs_){}
3410     , decltype(_impl_.comm_){}
3411     , decltype(_impl_.dev_){}
3412     , decltype(_impl_.sector_){}
3413     , decltype(_impl_.nr_sector_){}};
3414 
3415   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
3416   _impl_.rwbs_.InitDefault();
3417   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3418     _impl_.rwbs_.Set("", GetArenaForAllocation());
3419   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3420   if (from._internal_has_rwbs()) {
3421     _this->_impl_.rwbs_.Set(from._internal_rwbs(),
3422       _this->GetArenaForAllocation());
3423   }
3424   _impl_.comm_.InitDefault();
3425   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3426     _impl_.comm_.Set("", GetArenaForAllocation());
3427   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3428   if (from._internal_has_comm()) {
3429     _this->_impl_.comm_.Set(from._internal_comm(),
3430       _this->GetArenaForAllocation());
3431   }
3432   ::memcpy(&_impl_.dev_, &from._impl_.dev_,
3433     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.nr_sector_) -
3434     reinterpret_cast<char*>(&_impl_.dev_)) + sizeof(_impl_.nr_sector_));
3435   // @@protoc_insertion_point(copy_constructor:perfetto.protos.BlockGetrqFtraceEvent)
3436 }
3437 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)3438 inline void BlockGetrqFtraceEvent::SharedCtor(
3439     ::_pb::Arena* arena, bool is_message_owned) {
3440   (void)arena;
3441   (void)is_message_owned;
3442   new (&_impl_) Impl_{
3443       decltype(_impl_._has_bits_){}
3444     , /*decltype(_impl_._cached_size_)*/{}
3445     , decltype(_impl_.rwbs_){}
3446     , decltype(_impl_.comm_){}
3447     , decltype(_impl_.dev_){::uint64_t{0u}}
3448     , decltype(_impl_.sector_){::uint64_t{0u}}
3449     , decltype(_impl_.nr_sector_){0u}
3450   };
3451   _impl_.rwbs_.InitDefault();
3452   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3453     _impl_.rwbs_.Set("", GetArenaForAllocation());
3454   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3455   _impl_.comm_.InitDefault();
3456   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3457     _impl_.comm_.Set("", GetArenaForAllocation());
3458   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3459 }
3460 
~BlockGetrqFtraceEvent()3461 BlockGetrqFtraceEvent::~BlockGetrqFtraceEvent() {
3462   // @@protoc_insertion_point(destructor:perfetto.protos.BlockGetrqFtraceEvent)
3463   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
3464   (void)arena;
3465     return;
3466   }
3467   SharedDtor();
3468 }
3469 
SharedDtor()3470 inline void BlockGetrqFtraceEvent::SharedDtor() {
3471   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
3472   _impl_.rwbs_.Destroy();
3473   _impl_.comm_.Destroy();
3474 }
3475 
SetCachedSize(int size) const3476 void BlockGetrqFtraceEvent::SetCachedSize(int size) const {
3477   _impl_._cached_size_.Set(size);
3478 }
3479 
Clear()3480 void BlockGetrqFtraceEvent::Clear() {
3481 // @@protoc_insertion_point(message_clear_start:perfetto.protos.BlockGetrqFtraceEvent)
3482   ::uint32_t cached_has_bits = 0;
3483   // Prevent compiler warnings about cached_has_bits being unused
3484   (void) cached_has_bits;
3485 
3486   cached_has_bits = _impl_._has_bits_[0];
3487   if (cached_has_bits & 0x00000003u) {
3488     if (cached_has_bits & 0x00000001u) {
3489       _impl_.rwbs_.ClearNonDefaultToEmpty();
3490     }
3491     if (cached_has_bits & 0x00000002u) {
3492       _impl_.comm_.ClearNonDefaultToEmpty();
3493     }
3494   }
3495   if (cached_has_bits & 0x0000001cu) {
3496     ::memset(&_impl_.dev_, 0, static_cast<size_t>(
3497         reinterpret_cast<char*>(&_impl_.nr_sector_) -
3498         reinterpret_cast<char*>(&_impl_.dev_)) + sizeof(_impl_.nr_sector_));
3499   }
3500   _impl_._has_bits_.Clear();
3501   _internal_metadata_.Clear<std::string>();
3502 }
3503 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)3504 const char* BlockGetrqFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
3505 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
3506   _Internal::HasBits has_bits{};
3507   while (!ctx->Done(&ptr)) {
3508     ::uint32_t tag;
3509     ptr = ::_pbi::ReadTag(ptr, &tag);
3510     switch (tag >> 3) {
3511       // optional uint64 dev = 1;
3512       case 1:
3513         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
3514           _Internal::set_has_dev(&has_bits);
3515           _impl_.dev_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
3516           CHK_(ptr);
3517         } else {
3518           goto handle_unusual;
3519         }
3520         continue;
3521       // optional uint64 sector = 2;
3522       case 2:
3523         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
3524           _Internal::set_has_sector(&has_bits);
3525           _impl_.sector_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
3526           CHK_(ptr);
3527         } else {
3528           goto handle_unusual;
3529         }
3530         continue;
3531       // optional uint32 nr_sector = 3;
3532       case 3:
3533         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
3534           _Internal::set_has_nr_sector(&has_bits);
3535           _impl_.nr_sector_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
3536           CHK_(ptr);
3537         } else {
3538           goto handle_unusual;
3539         }
3540         continue;
3541       // optional string rwbs = 4;
3542       case 4:
3543         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
3544           auto str = _internal_mutable_rwbs();
3545           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
3546           CHK_(ptr);
3547         } else {
3548           goto handle_unusual;
3549         }
3550         continue;
3551       // optional string comm = 5;
3552       case 5:
3553         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 42)) {
3554           auto str = _internal_mutable_comm();
3555           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
3556           CHK_(ptr);
3557         } else {
3558           goto handle_unusual;
3559         }
3560         continue;
3561       default:
3562         goto handle_unusual;
3563     }  // switch
3564   handle_unusual:
3565     if ((tag == 0) || ((tag & 7) == 4)) {
3566       CHK_(ptr);
3567       ctx->SetLastTag(tag);
3568       goto message_done;
3569     }
3570     ptr = UnknownFieldParse(
3571         tag,
3572         _internal_metadata_.mutable_unknown_fields<std::string>(),
3573         ptr, ctx);
3574     CHK_(ptr != nullptr);
3575   }  // while
3576 message_done:
3577   _impl_._has_bits_.Or(has_bits);
3578   return ptr;
3579 failure:
3580   ptr = nullptr;
3581   goto message_done;
3582 #undef CHK_
3583 }
3584 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const3585 ::uint8_t* BlockGetrqFtraceEvent::_InternalSerialize(
3586     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
3587   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.BlockGetrqFtraceEvent)
3588   ::uint32_t cached_has_bits = 0;
3589   (void) cached_has_bits;
3590 
3591   cached_has_bits = _impl_._has_bits_[0];
3592   // optional uint64 dev = 1;
3593   if (cached_has_bits & 0x00000004u) {
3594     target = stream->EnsureSpace(target);
3595     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_dev(), target);
3596   }
3597 
3598   // optional uint64 sector = 2;
3599   if (cached_has_bits & 0x00000008u) {
3600     target = stream->EnsureSpace(target);
3601     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(2, this->_internal_sector(), target);
3602   }
3603 
3604   // optional uint32 nr_sector = 3;
3605   if (cached_has_bits & 0x00000010u) {
3606     target = stream->EnsureSpace(target);
3607     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_nr_sector(), target);
3608   }
3609 
3610   // optional string rwbs = 4;
3611   if (cached_has_bits & 0x00000001u) {
3612     target = stream->WriteStringMaybeAliased(
3613         4, this->_internal_rwbs(), target);
3614   }
3615 
3616   // optional string comm = 5;
3617   if (cached_has_bits & 0x00000002u) {
3618     target = stream->WriteStringMaybeAliased(
3619         5, this->_internal_comm(), target);
3620   }
3621 
3622   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
3623     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
3624         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
3625   }
3626   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.BlockGetrqFtraceEvent)
3627   return target;
3628 }
3629 
ByteSizeLong() const3630 size_t BlockGetrqFtraceEvent::ByteSizeLong() const {
3631 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.BlockGetrqFtraceEvent)
3632   size_t total_size = 0;
3633 
3634   ::uint32_t cached_has_bits = 0;
3635   // Prevent compiler warnings about cached_has_bits being unused
3636   (void) cached_has_bits;
3637 
3638   cached_has_bits = _impl_._has_bits_[0];
3639   if (cached_has_bits & 0x0000001fu) {
3640     // optional string rwbs = 4;
3641     if (cached_has_bits & 0x00000001u) {
3642       total_size += 1 +
3643         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
3644           this->_internal_rwbs());
3645     }
3646 
3647     // optional string comm = 5;
3648     if (cached_has_bits & 0x00000002u) {
3649       total_size += 1 +
3650         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
3651           this->_internal_comm());
3652     }
3653 
3654     // optional uint64 dev = 1;
3655     if (cached_has_bits & 0x00000004u) {
3656       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_dev());
3657     }
3658 
3659     // optional uint64 sector = 2;
3660     if (cached_has_bits & 0x00000008u) {
3661       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_sector());
3662     }
3663 
3664     // optional uint32 nr_sector = 3;
3665     if (cached_has_bits & 0x00000010u) {
3666       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_nr_sector());
3667     }
3668 
3669   }
3670   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
3671     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
3672   }
3673   int cached_size = ::_pbi::ToCachedSize(total_size);
3674   SetCachedSize(cached_size);
3675   return total_size;
3676 }
3677 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)3678 void BlockGetrqFtraceEvent::CheckTypeAndMergeFrom(
3679     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
3680   MergeFrom(*::_pbi::DownCast<const BlockGetrqFtraceEvent*>(
3681       &from));
3682 }
3683 
MergeFrom(const BlockGetrqFtraceEvent & from)3684 void BlockGetrqFtraceEvent::MergeFrom(const BlockGetrqFtraceEvent& from) {
3685   BlockGetrqFtraceEvent* const _this = this;
3686   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.BlockGetrqFtraceEvent)
3687   GOOGLE_DCHECK_NE(&from, _this);
3688   ::uint32_t cached_has_bits = 0;
3689   (void) cached_has_bits;
3690 
3691   cached_has_bits = from._impl_._has_bits_[0];
3692   if (cached_has_bits & 0x0000001fu) {
3693     if (cached_has_bits & 0x00000001u) {
3694       _this->_internal_set_rwbs(from._internal_rwbs());
3695     }
3696     if (cached_has_bits & 0x00000002u) {
3697       _this->_internal_set_comm(from._internal_comm());
3698     }
3699     if (cached_has_bits & 0x00000004u) {
3700       _this->_impl_.dev_ = from._impl_.dev_;
3701     }
3702     if (cached_has_bits & 0x00000008u) {
3703       _this->_impl_.sector_ = from._impl_.sector_;
3704     }
3705     if (cached_has_bits & 0x00000010u) {
3706       _this->_impl_.nr_sector_ = from._impl_.nr_sector_;
3707     }
3708     _this->_impl_._has_bits_[0] |= cached_has_bits;
3709   }
3710   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
3711 }
3712 
CopyFrom(const BlockGetrqFtraceEvent & from)3713 void BlockGetrqFtraceEvent::CopyFrom(const BlockGetrqFtraceEvent& from) {
3714 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.BlockGetrqFtraceEvent)
3715   if (&from == this) return;
3716   Clear();
3717   MergeFrom(from);
3718 }
3719 
IsInitialized() const3720 bool BlockGetrqFtraceEvent::IsInitialized() const {
3721   return true;
3722 }
3723 
InternalSwap(BlockGetrqFtraceEvent * other)3724 void BlockGetrqFtraceEvent::InternalSwap(BlockGetrqFtraceEvent* other) {
3725   using std::swap;
3726   auto* lhs_arena = GetArenaForAllocation();
3727   auto* rhs_arena = other->GetArenaForAllocation();
3728   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
3729   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
3730   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
3731       &_impl_.rwbs_, lhs_arena,
3732       &other->_impl_.rwbs_, rhs_arena
3733   );
3734   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
3735       &_impl_.comm_, lhs_arena,
3736       &other->_impl_.comm_, rhs_arena
3737   );
3738   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
3739       PROTOBUF_FIELD_OFFSET(BlockGetrqFtraceEvent, _impl_.nr_sector_)
3740       + sizeof(BlockGetrqFtraceEvent::_impl_.nr_sector_)  // NOLINT
3741       - PROTOBUF_FIELD_OFFSET(BlockGetrqFtraceEvent, _impl_.dev_)>(
3742           reinterpret_cast<char*>(&_impl_.dev_),
3743           reinterpret_cast<char*>(&other->_impl_.dev_));
3744 }
3745 
GetTypeName() const3746 std::string BlockGetrqFtraceEvent::GetTypeName() const {
3747   return "perfetto.protos.BlockGetrqFtraceEvent";
3748 }
3749 
3750 
3751 // ===================================================================
3752 
3753 class BlockPlugFtraceEvent::_Internal {
3754  public:
3755   using HasBits = decltype(std::declval<BlockPlugFtraceEvent>()._impl_._has_bits_);
set_has_comm(HasBits * has_bits)3756   static void set_has_comm(HasBits* has_bits) {
3757     (*has_bits)[0] |= 1u;
3758   }
3759 };
3760 
BlockPlugFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)3761 BlockPlugFtraceEvent::BlockPlugFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
3762                          bool is_message_owned)
3763   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
3764   SharedCtor(arena, is_message_owned);
3765   // @@protoc_insertion_point(arena_constructor:perfetto.protos.BlockPlugFtraceEvent)
3766 }
BlockPlugFtraceEvent(const BlockPlugFtraceEvent & from)3767 BlockPlugFtraceEvent::BlockPlugFtraceEvent(const BlockPlugFtraceEvent& from)
3768   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
3769   BlockPlugFtraceEvent* const _this = this; (void)_this;
3770   new (&_impl_) Impl_{
3771       decltype(_impl_._has_bits_){from._impl_._has_bits_}
3772     , /*decltype(_impl_._cached_size_)*/{}
3773     , decltype(_impl_.comm_){}};
3774 
3775   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
3776   _impl_.comm_.InitDefault();
3777   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3778     _impl_.comm_.Set("", GetArenaForAllocation());
3779   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3780   if (from._internal_has_comm()) {
3781     _this->_impl_.comm_.Set(from._internal_comm(),
3782       _this->GetArenaForAllocation());
3783   }
3784   // @@protoc_insertion_point(copy_constructor:perfetto.protos.BlockPlugFtraceEvent)
3785 }
3786 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)3787 inline void BlockPlugFtraceEvent::SharedCtor(
3788     ::_pb::Arena* arena, bool is_message_owned) {
3789   (void)arena;
3790   (void)is_message_owned;
3791   new (&_impl_) Impl_{
3792       decltype(_impl_._has_bits_){}
3793     , /*decltype(_impl_._cached_size_)*/{}
3794     , decltype(_impl_.comm_){}
3795   };
3796   _impl_.comm_.InitDefault();
3797   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3798     _impl_.comm_.Set("", GetArenaForAllocation());
3799   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3800 }
3801 
~BlockPlugFtraceEvent()3802 BlockPlugFtraceEvent::~BlockPlugFtraceEvent() {
3803   // @@protoc_insertion_point(destructor:perfetto.protos.BlockPlugFtraceEvent)
3804   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
3805   (void)arena;
3806     return;
3807   }
3808   SharedDtor();
3809 }
3810 
SharedDtor()3811 inline void BlockPlugFtraceEvent::SharedDtor() {
3812   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
3813   _impl_.comm_.Destroy();
3814 }
3815 
SetCachedSize(int size) const3816 void BlockPlugFtraceEvent::SetCachedSize(int size) const {
3817   _impl_._cached_size_.Set(size);
3818 }
3819 
Clear()3820 void BlockPlugFtraceEvent::Clear() {
3821 // @@protoc_insertion_point(message_clear_start:perfetto.protos.BlockPlugFtraceEvent)
3822   ::uint32_t cached_has_bits = 0;
3823   // Prevent compiler warnings about cached_has_bits being unused
3824   (void) cached_has_bits;
3825 
3826   cached_has_bits = _impl_._has_bits_[0];
3827   if (cached_has_bits & 0x00000001u) {
3828     _impl_.comm_.ClearNonDefaultToEmpty();
3829   }
3830   _impl_._has_bits_.Clear();
3831   _internal_metadata_.Clear<std::string>();
3832 }
3833 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)3834 const char* BlockPlugFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
3835 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
3836   _Internal::HasBits has_bits{};
3837   while (!ctx->Done(&ptr)) {
3838     ::uint32_t tag;
3839     ptr = ::_pbi::ReadTag(ptr, &tag);
3840     switch (tag >> 3) {
3841       // optional string comm = 1;
3842       case 1:
3843         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
3844           auto str = _internal_mutable_comm();
3845           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
3846           CHK_(ptr);
3847         } else {
3848           goto handle_unusual;
3849         }
3850         continue;
3851       default:
3852         goto handle_unusual;
3853     }  // switch
3854   handle_unusual:
3855     if ((tag == 0) || ((tag & 7) == 4)) {
3856       CHK_(ptr);
3857       ctx->SetLastTag(tag);
3858       goto message_done;
3859     }
3860     ptr = UnknownFieldParse(
3861         tag,
3862         _internal_metadata_.mutable_unknown_fields<std::string>(),
3863         ptr, ctx);
3864     CHK_(ptr != nullptr);
3865   }  // while
3866 message_done:
3867   _impl_._has_bits_.Or(has_bits);
3868   return ptr;
3869 failure:
3870   ptr = nullptr;
3871   goto message_done;
3872 #undef CHK_
3873 }
3874 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const3875 ::uint8_t* BlockPlugFtraceEvent::_InternalSerialize(
3876     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
3877   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.BlockPlugFtraceEvent)
3878   ::uint32_t cached_has_bits = 0;
3879   (void) cached_has_bits;
3880 
3881   cached_has_bits = _impl_._has_bits_[0];
3882   // optional string comm = 1;
3883   if (cached_has_bits & 0x00000001u) {
3884     target = stream->WriteStringMaybeAliased(
3885         1, this->_internal_comm(), target);
3886   }
3887 
3888   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
3889     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
3890         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
3891   }
3892   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.BlockPlugFtraceEvent)
3893   return target;
3894 }
3895 
ByteSizeLong() const3896 size_t BlockPlugFtraceEvent::ByteSizeLong() const {
3897 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.BlockPlugFtraceEvent)
3898   size_t total_size = 0;
3899 
3900   ::uint32_t cached_has_bits = 0;
3901   // Prevent compiler warnings about cached_has_bits being unused
3902   (void) cached_has_bits;
3903 
3904   // optional string comm = 1;
3905   cached_has_bits = _impl_._has_bits_[0];
3906   if (cached_has_bits & 0x00000001u) {
3907     total_size += 1 +
3908       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
3909         this->_internal_comm());
3910   }
3911 
3912   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
3913     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
3914   }
3915   int cached_size = ::_pbi::ToCachedSize(total_size);
3916   SetCachedSize(cached_size);
3917   return total_size;
3918 }
3919 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)3920 void BlockPlugFtraceEvent::CheckTypeAndMergeFrom(
3921     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
3922   MergeFrom(*::_pbi::DownCast<const BlockPlugFtraceEvent*>(
3923       &from));
3924 }
3925 
MergeFrom(const BlockPlugFtraceEvent & from)3926 void BlockPlugFtraceEvent::MergeFrom(const BlockPlugFtraceEvent& from) {
3927   BlockPlugFtraceEvent* const _this = this;
3928   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.BlockPlugFtraceEvent)
3929   GOOGLE_DCHECK_NE(&from, _this);
3930   ::uint32_t cached_has_bits = 0;
3931   (void) cached_has_bits;
3932 
3933   if (from._internal_has_comm()) {
3934     _this->_internal_set_comm(from._internal_comm());
3935   }
3936   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
3937 }
3938 
CopyFrom(const BlockPlugFtraceEvent & from)3939 void BlockPlugFtraceEvent::CopyFrom(const BlockPlugFtraceEvent& from) {
3940 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.BlockPlugFtraceEvent)
3941   if (&from == this) return;
3942   Clear();
3943   MergeFrom(from);
3944 }
3945 
IsInitialized() const3946 bool BlockPlugFtraceEvent::IsInitialized() const {
3947   return true;
3948 }
3949 
InternalSwap(BlockPlugFtraceEvent * other)3950 void BlockPlugFtraceEvent::InternalSwap(BlockPlugFtraceEvent* other) {
3951   using std::swap;
3952   auto* lhs_arena = GetArenaForAllocation();
3953   auto* rhs_arena = other->GetArenaForAllocation();
3954   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
3955   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
3956   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
3957       &_impl_.comm_, lhs_arena,
3958       &other->_impl_.comm_, rhs_arena
3959   );
3960 }
3961 
GetTypeName() const3962 std::string BlockPlugFtraceEvent::GetTypeName() const {
3963   return "perfetto.protos.BlockPlugFtraceEvent";
3964 }
3965 
3966 
3967 // ===================================================================
3968 
3969 class BlockRqAbortFtraceEvent::_Internal {
3970  public:
3971   using HasBits = decltype(std::declval<BlockRqAbortFtraceEvent>()._impl_._has_bits_);
set_has_dev(HasBits * has_bits)3972   static void set_has_dev(HasBits* has_bits) {
3973     (*has_bits)[0] |= 4u;
3974   }
set_has_sector(HasBits * has_bits)3975   static void set_has_sector(HasBits* has_bits) {
3976     (*has_bits)[0] |= 8u;
3977   }
set_has_nr_sector(HasBits * has_bits)3978   static void set_has_nr_sector(HasBits* has_bits) {
3979     (*has_bits)[0] |= 16u;
3980   }
set_has_errors(HasBits * has_bits)3981   static void set_has_errors(HasBits* has_bits) {
3982     (*has_bits)[0] |= 32u;
3983   }
set_has_rwbs(HasBits * has_bits)3984   static void set_has_rwbs(HasBits* has_bits) {
3985     (*has_bits)[0] |= 1u;
3986   }
set_has_cmd(HasBits * has_bits)3987   static void set_has_cmd(HasBits* has_bits) {
3988     (*has_bits)[0] |= 2u;
3989   }
3990 };
3991 
BlockRqAbortFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)3992 BlockRqAbortFtraceEvent::BlockRqAbortFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
3993                          bool is_message_owned)
3994   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
3995   SharedCtor(arena, is_message_owned);
3996   // @@protoc_insertion_point(arena_constructor:perfetto.protos.BlockRqAbortFtraceEvent)
3997 }
BlockRqAbortFtraceEvent(const BlockRqAbortFtraceEvent & from)3998 BlockRqAbortFtraceEvent::BlockRqAbortFtraceEvent(const BlockRqAbortFtraceEvent& from)
3999   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
4000   BlockRqAbortFtraceEvent* const _this = this; (void)_this;
4001   new (&_impl_) Impl_{
4002       decltype(_impl_._has_bits_){from._impl_._has_bits_}
4003     , /*decltype(_impl_._cached_size_)*/{}
4004     , decltype(_impl_.rwbs_){}
4005     , decltype(_impl_.cmd_){}
4006     , decltype(_impl_.dev_){}
4007     , decltype(_impl_.sector_){}
4008     , decltype(_impl_.nr_sector_){}
4009     , decltype(_impl_.errors_){}};
4010 
4011   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
4012   _impl_.rwbs_.InitDefault();
4013   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4014     _impl_.rwbs_.Set("", GetArenaForAllocation());
4015   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4016   if (from._internal_has_rwbs()) {
4017     _this->_impl_.rwbs_.Set(from._internal_rwbs(),
4018       _this->GetArenaForAllocation());
4019   }
4020   _impl_.cmd_.InitDefault();
4021   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4022     _impl_.cmd_.Set("", GetArenaForAllocation());
4023   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4024   if (from._internal_has_cmd()) {
4025     _this->_impl_.cmd_.Set(from._internal_cmd(),
4026       _this->GetArenaForAllocation());
4027   }
4028   ::memcpy(&_impl_.dev_, &from._impl_.dev_,
4029     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.errors_) -
4030     reinterpret_cast<char*>(&_impl_.dev_)) + sizeof(_impl_.errors_));
4031   // @@protoc_insertion_point(copy_constructor:perfetto.protos.BlockRqAbortFtraceEvent)
4032 }
4033 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)4034 inline void BlockRqAbortFtraceEvent::SharedCtor(
4035     ::_pb::Arena* arena, bool is_message_owned) {
4036   (void)arena;
4037   (void)is_message_owned;
4038   new (&_impl_) Impl_{
4039       decltype(_impl_._has_bits_){}
4040     , /*decltype(_impl_._cached_size_)*/{}
4041     , decltype(_impl_.rwbs_){}
4042     , decltype(_impl_.cmd_){}
4043     , decltype(_impl_.dev_){::uint64_t{0u}}
4044     , decltype(_impl_.sector_){::uint64_t{0u}}
4045     , decltype(_impl_.nr_sector_){0u}
4046     , decltype(_impl_.errors_){0}
4047   };
4048   _impl_.rwbs_.InitDefault();
4049   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4050     _impl_.rwbs_.Set("", GetArenaForAllocation());
4051   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4052   _impl_.cmd_.InitDefault();
4053   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4054     _impl_.cmd_.Set("", GetArenaForAllocation());
4055   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4056 }
4057 
~BlockRqAbortFtraceEvent()4058 BlockRqAbortFtraceEvent::~BlockRqAbortFtraceEvent() {
4059   // @@protoc_insertion_point(destructor:perfetto.protos.BlockRqAbortFtraceEvent)
4060   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
4061   (void)arena;
4062     return;
4063   }
4064   SharedDtor();
4065 }
4066 
SharedDtor()4067 inline void BlockRqAbortFtraceEvent::SharedDtor() {
4068   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
4069   _impl_.rwbs_.Destroy();
4070   _impl_.cmd_.Destroy();
4071 }
4072 
SetCachedSize(int size) const4073 void BlockRqAbortFtraceEvent::SetCachedSize(int size) const {
4074   _impl_._cached_size_.Set(size);
4075 }
4076 
Clear()4077 void BlockRqAbortFtraceEvent::Clear() {
4078 // @@protoc_insertion_point(message_clear_start:perfetto.protos.BlockRqAbortFtraceEvent)
4079   ::uint32_t cached_has_bits = 0;
4080   // Prevent compiler warnings about cached_has_bits being unused
4081   (void) cached_has_bits;
4082 
4083   cached_has_bits = _impl_._has_bits_[0];
4084   if (cached_has_bits & 0x00000003u) {
4085     if (cached_has_bits & 0x00000001u) {
4086       _impl_.rwbs_.ClearNonDefaultToEmpty();
4087     }
4088     if (cached_has_bits & 0x00000002u) {
4089       _impl_.cmd_.ClearNonDefaultToEmpty();
4090     }
4091   }
4092   if (cached_has_bits & 0x0000003cu) {
4093     ::memset(&_impl_.dev_, 0, static_cast<size_t>(
4094         reinterpret_cast<char*>(&_impl_.errors_) -
4095         reinterpret_cast<char*>(&_impl_.dev_)) + sizeof(_impl_.errors_));
4096   }
4097   _impl_._has_bits_.Clear();
4098   _internal_metadata_.Clear<std::string>();
4099 }
4100 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)4101 const char* BlockRqAbortFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
4102 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
4103   _Internal::HasBits has_bits{};
4104   while (!ctx->Done(&ptr)) {
4105     ::uint32_t tag;
4106     ptr = ::_pbi::ReadTag(ptr, &tag);
4107     switch (tag >> 3) {
4108       // optional uint64 dev = 1;
4109       case 1:
4110         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
4111           _Internal::set_has_dev(&has_bits);
4112           _impl_.dev_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
4113           CHK_(ptr);
4114         } else {
4115           goto handle_unusual;
4116         }
4117         continue;
4118       // optional uint64 sector = 2;
4119       case 2:
4120         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
4121           _Internal::set_has_sector(&has_bits);
4122           _impl_.sector_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
4123           CHK_(ptr);
4124         } else {
4125           goto handle_unusual;
4126         }
4127         continue;
4128       // optional uint32 nr_sector = 3;
4129       case 3:
4130         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
4131           _Internal::set_has_nr_sector(&has_bits);
4132           _impl_.nr_sector_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
4133           CHK_(ptr);
4134         } else {
4135           goto handle_unusual;
4136         }
4137         continue;
4138       // optional int32 errors = 4;
4139       case 4:
4140         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
4141           _Internal::set_has_errors(&has_bits);
4142           _impl_.errors_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
4143           CHK_(ptr);
4144         } else {
4145           goto handle_unusual;
4146         }
4147         continue;
4148       // optional string rwbs = 5;
4149       case 5:
4150         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 42)) {
4151           auto str = _internal_mutable_rwbs();
4152           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
4153           CHK_(ptr);
4154         } else {
4155           goto handle_unusual;
4156         }
4157         continue;
4158       // optional string cmd = 6;
4159       case 6:
4160         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 50)) {
4161           auto str = _internal_mutable_cmd();
4162           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
4163           CHK_(ptr);
4164         } else {
4165           goto handle_unusual;
4166         }
4167         continue;
4168       default:
4169         goto handle_unusual;
4170     }  // switch
4171   handle_unusual:
4172     if ((tag == 0) || ((tag & 7) == 4)) {
4173       CHK_(ptr);
4174       ctx->SetLastTag(tag);
4175       goto message_done;
4176     }
4177     ptr = UnknownFieldParse(
4178         tag,
4179         _internal_metadata_.mutable_unknown_fields<std::string>(),
4180         ptr, ctx);
4181     CHK_(ptr != nullptr);
4182   }  // while
4183 message_done:
4184   _impl_._has_bits_.Or(has_bits);
4185   return ptr;
4186 failure:
4187   ptr = nullptr;
4188   goto message_done;
4189 #undef CHK_
4190 }
4191 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const4192 ::uint8_t* BlockRqAbortFtraceEvent::_InternalSerialize(
4193     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
4194   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.BlockRqAbortFtraceEvent)
4195   ::uint32_t cached_has_bits = 0;
4196   (void) cached_has_bits;
4197 
4198   cached_has_bits = _impl_._has_bits_[0];
4199   // optional uint64 dev = 1;
4200   if (cached_has_bits & 0x00000004u) {
4201     target = stream->EnsureSpace(target);
4202     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_dev(), target);
4203   }
4204 
4205   // optional uint64 sector = 2;
4206   if (cached_has_bits & 0x00000008u) {
4207     target = stream->EnsureSpace(target);
4208     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(2, this->_internal_sector(), target);
4209   }
4210 
4211   // optional uint32 nr_sector = 3;
4212   if (cached_has_bits & 0x00000010u) {
4213     target = stream->EnsureSpace(target);
4214     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_nr_sector(), target);
4215   }
4216 
4217   // optional int32 errors = 4;
4218   if (cached_has_bits & 0x00000020u) {
4219     target = stream->EnsureSpace(target);
4220     target = ::_pbi::WireFormatLite::WriteInt32ToArray(4, this->_internal_errors(), target);
4221   }
4222 
4223   // optional string rwbs = 5;
4224   if (cached_has_bits & 0x00000001u) {
4225     target = stream->WriteStringMaybeAliased(
4226         5, this->_internal_rwbs(), target);
4227   }
4228 
4229   // optional string cmd = 6;
4230   if (cached_has_bits & 0x00000002u) {
4231     target = stream->WriteStringMaybeAliased(
4232         6, this->_internal_cmd(), target);
4233   }
4234 
4235   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
4236     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
4237         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
4238   }
4239   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.BlockRqAbortFtraceEvent)
4240   return target;
4241 }
4242 
ByteSizeLong() const4243 size_t BlockRqAbortFtraceEvent::ByteSizeLong() const {
4244 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.BlockRqAbortFtraceEvent)
4245   size_t total_size = 0;
4246 
4247   ::uint32_t cached_has_bits = 0;
4248   // Prevent compiler warnings about cached_has_bits being unused
4249   (void) cached_has_bits;
4250 
4251   cached_has_bits = _impl_._has_bits_[0];
4252   if (cached_has_bits & 0x0000003fu) {
4253     // optional string rwbs = 5;
4254     if (cached_has_bits & 0x00000001u) {
4255       total_size += 1 +
4256         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
4257           this->_internal_rwbs());
4258     }
4259 
4260     // optional string cmd = 6;
4261     if (cached_has_bits & 0x00000002u) {
4262       total_size += 1 +
4263         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
4264           this->_internal_cmd());
4265     }
4266 
4267     // optional uint64 dev = 1;
4268     if (cached_has_bits & 0x00000004u) {
4269       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_dev());
4270     }
4271 
4272     // optional uint64 sector = 2;
4273     if (cached_has_bits & 0x00000008u) {
4274       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_sector());
4275     }
4276 
4277     // optional uint32 nr_sector = 3;
4278     if (cached_has_bits & 0x00000010u) {
4279       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_nr_sector());
4280     }
4281 
4282     // optional int32 errors = 4;
4283     if (cached_has_bits & 0x00000020u) {
4284       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_errors());
4285     }
4286 
4287   }
4288   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
4289     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
4290   }
4291   int cached_size = ::_pbi::ToCachedSize(total_size);
4292   SetCachedSize(cached_size);
4293   return total_size;
4294 }
4295 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)4296 void BlockRqAbortFtraceEvent::CheckTypeAndMergeFrom(
4297     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
4298   MergeFrom(*::_pbi::DownCast<const BlockRqAbortFtraceEvent*>(
4299       &from));
4300 }
4301 
MergeFrom(const BlockRqAbortFtraceEvent & from)4302 void BlockRqAbortFtraceEvent::MergeFrom(const BlockRqAbortFtraceEvent& from) {
4303   BlockRqAbortFtraceEvent* const _this = this;
4304   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.BlockRqAbortFtraceEvent)
4305   GOOGLE_DCHECK_NE(&from, _this);
4306   ::uint32_t cached_has_bits = 0;
4307   (void) cached_has_bits;
4308 
4309   cached_has_bits = from._impl_._has_bits_[0];
4310   if (cached_has_bits & 0x0000003fu) {
4311     if (cached_has_bits & 0x00000001u) {
4312       _this->_internal_set_rwbs(from._internal_rwbs());
4313     }
4314     if (cached_has_bits & 0x00000002u) {
4315       _this->_internal_set_cmd(from._internal_cmd());
4316     }
4317     if (cached_has_bits & 0x00000004u) {
4318       _this->_impl_.dev_ = from._impl_.dev_;
4319     }
4320     if (cached_has_bits & 0x00000008u) {
4321       _this->_impl_.sector_ = from._impl_.sector_;
4322     }
4323     if (cached_has_bits & 0x00000010u) {
4324       _this->_impl_.nr_sector_ = from._impl_.nr_sector_;
4325     }
4326     if (cached_has_bits & 0x00000020u) {
4327       _this->_impl_.errors_ = from._impl_.errors_;
4328     }
4329     _this->_impl_._has_bits_[0] |= cached_has_bits;
4330   }
4331   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
4332 }
4333 
CopyFrom(const BlockRqAbortFtraceEvent & from)4334 void BlockRqAbortFtraceEvent::CopyFrom(const BlockRqAbortFtraceEvent& from) {
4335 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.BlockRqAbortFtraceEvent)
4336   if (&from == this) return;
4337   Clear();
4338   MergeFrom(from);
4339 }
4340 
IsInitialized() const4341 bool BlockRqAbortFtraceEvent::IsInitialized() const {
4342   return true;
4343 }
4344 
InternalSwap(BlockRqAbortFtraceEvent * other)4345 void BlockRqAbortFtraceEvent::InternalSwap(BlockRqAbortFtraceEvent* other) {
4346   using std::swap;
4347   auto* lhs_arena = GetArenaForAllocation();
4348   auto* rhs_arena = other->GetArenaForAllocation();
4349   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
4350   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
4351   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
4352       &_impl_.rwbs_, lhs_arena,
4353       &other->_impl_.rwbs_, rhs_arena
4354   );
4355   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
4356       &_impl_.cmd_, lhs_arena,
4357       &other->_impl_.cmd_, rhs_arena
4358   );
4359   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
4360       PROTOBUF_FIELD_OFFSET(BlockRqAbortFtraceEvent, _impl_.errors_)
4361       + sizeof(BlockRqAbortFtraceEvent::_impl_.errors_)  // NOLINT
4362       - PROTOBUF_FIELD_OFFSET(BlockRqAbortFtraceEvent, _impl_.dev_)>(
4363           reinterpret_cast<char*>(&_impl_.dev_),
4364           reinterpret_cast<char*>(&other->_impl_.dev_));
4365 }
4366 
GetTypeName() const4367 std::string BlockRqAbortFtraceEvent::GetTypeName() const {
4368   return "perfetto.protos.BlockRqAbortFtraceEvent";
4369 }
4370 
4371 
4372 // ===================================================================
4373 
4374 class BlockRqCompleteFtraceEvent::_Internal {
4375  public:
4376   using HasBits = decltype(std::declval<BlockRqCompleteFtraceEvent>()._impl_._has_bits_);
set_has_dev(HasBits * has_bits)4377   static void set_has_dev(HasBits* has_bits) {
4378     (*has_bits)[0] |= 4u;
4379   }
set_has_sector(HasBits * has_bits)4380   static void set_has_sector(HasBits* has_bits) {
4381     (*has_bits)[0] |= 8u;
4382   }
set_has_nr_sector(HasBits * has_bits)4383   static void set_has_nr_sector(HasBits* has_bits) {
4384     (*has_bits)[0] |= 16u;
4385   }
set_has_errors(HasBits * has_bits)4386   static void set_has_errors(HasBits* has_bits) {
4387     (*has_bits)[0] |= 32u;
4388   }
set_has_rwbs(HasBits * has_bits)4389   static void set_has_rwbs(HasBits* has_bits) {
4390     (*has_bits)[0] |= 1u;
4391   }
set_has_cmd(HasBits * has_bits)4392   static void set_has_cmd(HasBits* has_bits) {
4393     (*has_bits)[0] |= 2u;
4394   }
set_has_error(HasBits * has_bits)4395   static void set_has_error(HasBits* has_bits) {
4396     (*has_bits)[0] |= 64u;
4397   }
4398 };
4399 
BlockRqCompleteFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)4400 BlockRqCompleteFtraceEvent::BlockRqCompleteFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
4401                          bool is_message_owned)
4402   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
4403   SharedCtor(arena, is_message_owned);
4404   // @@protoc_insertion_point(arena_constructor:perfetto.protos.BlockRqCompleteFtraceEvent)
4405 }
BlockRqCompleteFtraceEvent(const BlockRqCompleteFtraceEvent & from)4406 BlockRqCompleteFtraceEvent::BlockRqCompleteFtraceEvent(const BlockRqCompleteFtraceEvent& from)
4407   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
4408   BlockRqCompleteFtraceEvent* const _this = this; (void)_this;
4409   new (&_impl_) Impl_{
4410       decltype(_impl_._has_bits_){from._impl_._has_bits_}
4411     , /*decltype(_impl_._cached_size_)*/{}
4412     , decltype(_impl_.rwbs_){}
4413     , decltype(_impl_.cmd_){}
4414     , decltype(_impl_.dev_){}
4415     , decltype(_impl_.sector_){}
4416     , decltype(_impl_.nr_sector_){}
4417     , decltype(_impl_.errors_){}
4418     , decltype(_impl_.error_){}};
4419 
4420   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
4421   _impl_.rwbs_.InitDefault();
4422   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4423     _impl_.rwbs_.Set("", GetArenaForAllocation());
4424   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4425   if (from._internal_has_rwbs()) {
4426     _this->_impl_.rwbs_.Set(from._internal_rwbs(),
4427       _this->GetArenaForAllocation());
4428   }
4429   _impl_.cmd_.InitDefault();
4430   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4431     _impl_.cmd_.Set("", GetArenaForAllocation());
4432   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4433   if (from._internal_has_cmd()) {
4434     _this->_impl_.cmd_.Set(from._internal_cmd(),
4435       _this->GetArenaForAllocation());
4436   }
4437   ::memcpy(&_impl_.dev_, &from._impl_.dev_,
4438     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.error_) -
4439     reinterpret_cast<char*>(&_impl_.dev_)) + sizeof(_impl_.error_));
4440   // @@protoc_insertion_point(copy_constructor:perfetto.protos.BlockRqCompleteFtraceEvent)
4441 }
4442 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)4443 inline void BlockRqCompleteFtraceEvent::SharedCtor(
4444     ::_pb::Arena* arena, bool is_message_owned) {
4445   (void)arena;
4446   (void)is_message_owned;
4447   new (&_impl_) Impl_{
4448       decltype(_impl_._has_bits_){}
4449     , /*decltype(_impl_._cached_size_)*/{}
4450     , decltype(_impl_.rwbs_){}
4451     , decltype(_impl_.cmd_){}
4452     , decltype(_impl_.dev_){::uint64_t{0u}}
4453     , decltype(_impl_.sector_){::uint64_t{0u}}
4454     , decltype(_impl_.nr_sector_){0u}
4455     , decltype(_impl_.errors_){0}
4456     , decltype(_impl_.error_){0}
4457   };
4458   _impl_.rwbs_.InitDefault();
4459   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4460     _impl_.rwbs_.Set("", GetArenaForAllocation());
4461   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4462   _impl_.cmd_.InitDefault();
4463   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4464     _impl_.cmd_.Set("", GetArenaForAllocation());
4465   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4466 }
4467 
~BlockRqCompleteFtraceEvent()4468 BlockRqCompleteFtraceEvent::~BlockRqCompleteFtraceEvent() {
4469   // @@protoc_insertion_point(destructor:perfetto.protos.BlockRqCompleteFtraceEvent)
4470   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
4471   (void)arena;
4472     return;
4473   }
4474   SharedDtor();
4475 }
4476 
SharedDtor()4477 inline void BlockRqCompleteFtraceEvent::SharedDtor() {
4478   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
4479   _impl_.rwbs_.Destroy();
4480   _impl_.cmd_.Destroy();
4481 }
4482 
SetCachedSize(int size) const4483 void BlockRqCompleteFtraceEvent::SetCachedSize(int size) const {
4484   _impl_._cached_size_.Set(size);
4485 }
4486 
Clear()4487 void BlockRqCompleteFtraceEvent::Clear() {
4488 // @@protoc_insertion_point(message_clear_start:perfetto.protos.BlockRqCompleteFtraceEvent)
4489   ::uint32_t cached_has_bits = 0;
4490   // Prevent compiler warnings about cached_has_bits being unused
4491   (void) cached_has_bits;
4492 
4493   cached_has_bits = _impl_._has_bits_[0];
4494   if (cached_has_bits & 0x00000003u) {
4495     if (cached_has_bits & 0x00000001u) {
4496       _impl_.rwbs_.ClearNonDefaultToEmpty();
4497     }
4498     if (cached_has_bits & 0x00000002u) {
4499       _impl_.cmd_.ClearNonDefaultToEmpty();
4500     }
4501   }
4502   if (cached_has_bits & 0x0000007cu) {
4503     ::memset(&_impl_.dev_, 0, static_cast<size_t>(
4504         reinterpret_cast<char*>(&_impl_.error_) -
4505         reinterpret_cast<char*>(&_impl_.dev_)) + sizeof(_impl_.error_));
4506   }
4507   _impl_._has_bits_.Clear();
4508   _internal_metadata_.Clear<std::string>();
4509 }
4510 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)4511 const char* BlockRqCompleteFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
4512 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
4513   _Internal::HasBits has_bits{};
4514   while (!ctx->Done(&ptr)) {
4515     ::uint32_t tag;
4516     ptr = ::_pbi::ReadTag(ptr, &tag);
4517     switch (tag >> 3) {
4518       // optional uint64 dev = 1;
4519       case 1:
4520         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
4521           _Internal::set_has_dev(&has_bits);
4522           _impl_.dev_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
4523           CHK_(ptr);
4524         } else {
4525           goto handle_unusual;
4526         }
4527         continue;
4528       // optional uint64 sector = 2;
4529       case 2:
4530         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
4531           _Internal::set_has_sector(&has_bits);
4532           _impl_.sector_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
4533           CHK_(ptr);
4534         } else {
4535           goto handle_unusual;
4536         }
4537         continue;
4538       // optional uint32 nr_sector = 3;
4539       case 3:
4540         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
4541           _Internal::set_has_nr_sector(&has_bits);
4542           _impl_.nr_sector_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
4543           CHK_(ptr);
4544         } else {
4545           goto handle_unusual;
4546         }
4547         continue;
4548       // optional int32 errors = 4;
4549       case 4:
4550         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
4551           _Internal::set_has_errors(&has_bits);
4552           _impl_.errors_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
4553           CHK_(ptr);
4554         } else {
4555           goto handle_unusual;
4556         }
4557         continue;
4558       // optional string rwbs = 5;
4559       case 5:
4560         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 42)) {
4561           auto str = _internal_mutable_rwbs();
4562           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
4563           CHK_(ptr);
4564         } else {
4565           goto handle_unusual;
4566         }
4567         continue;
4568       // optional string cmd = 6;
4569       case 6:
4570         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 50)) {
4571           auto str = _internal_mutable_cmd();
4572           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
4573           CHK_(ptr);
4574         } else {
4575           goto handle_unusual;
4576         }
4577         continue;
4578       // optional int32 error = 7;
4579       case 7:
4580         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 56)) {
4581           _Internal::set_has_error(&has_bits);
4582           _impl_.error_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
4583           CHK_(ptr);
4584         } else {
4585           goto handle_unusual;
4586         }
4587         continue;
4588       default:
4589         goto handle_unusual;
4590     }  // switch
4591   handle_unusual:
4592     if ((tag == 0) || ((tag & 7) == 4)) {
4593       CHK_(ptr);
4594       ctx->SetLastTag(tag);
4595       goto message_done;
4596     }
4597     ptr = UnknownFieldParse(
4598         tag,
4599         _internal_metadata_.mutable_unknown_fields<std::string>(),
4600         ptr, ctx);
4601     CHK_(ptr != nullptr);
4602   }  // while
4603 message_done:
4604   _impl_._has_bits_.Or(has_bits);
4605   return ptr;
4606 failure:
4607   ptr = nullptr;
4608   goto message_done;
4609 #undef CHK_
4610 }
4611 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const4612 ::uint8_t* BlockRqCompleteFtraceEvent::_InternalSerialize(
4613     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
4614   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.BlockRqCompleteFtraceEvent)
4615   ::uint32_t cached_has_bits = 0;
4616   (void) cached_has_bits;
4617 
4618   cached_has_bits = _impl_._has_bits_[0];
4619   // optional uint64 dev = 1;
4620   if (cached_has_bits & 0x00000004u) {
4621     target = stream->EnsureSpace(target);
4622     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_dev(), target);
4623   }
4624 
4625   // optional uint64 sector = 2;
4626   if (cached_has_bits & 0x00000008u) {
4627     target = stream->EnsureSpace(target);
4628     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(2, this->_internal_sector(), target);
4629   }
4630 
4631   // optional uint32 nr_sector = 3;
4632   if (cached_has_bits & 0x00000010u) {
4633     target = stream->EnsureSpace(target);
4634     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_nr_sector(), target);
4635   }
4636 
4637   // optional int32 errors = 4;
4638   if (cached_has_bits & 0x00000020u) {
4639     target = stream->EnsureSpace(target);
4640     target = ::_pbi::WireFormatLite::WriteInt32ToArray(4, this->_internal_errors(), target);
4641   }
4642 
4643   // optional string rwbs = 5;
4644   if (cached_has_bits & 0x00000001u) {
4645     target = stream->WriteStringMaybeAliased(
4646         5, this->_internal_rwbs(), target);
4647   }
4648 
4649   // optional string cmd = 6;
4650   if (cached_has_bits & 0x00000002u) {
4651     target = stream->WriteStringMaybeAliased(
4652         6, this->_internal_cmd(), target);
4653   }
4654 
4655   // optional int32 error = 7;
4656   if (cached_has_bits & 0x00000040u) {
4657     target = stream->EnsureSpace(target);
4658     target = ::_pbi::WireFormatLite::WriteInt32ToArray(7, this->_internal_error(), target);
4659   }
4660 
4661   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
4662     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
4663         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
4664   }
4665   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.BlockRqCompleteFtraceEvent)
4666   return target;
4667 }
4668 
ByteSizeLong() const4669 size_t BlockRqCompleteFtraceEvent::ByteSizeLong() const {
4670 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.BlockRqCompleteFtraceEvent)
4671   size_t total_size = 0;
4672 
4673   ::uint32_t cached_has_bits = 0;
4674   // Prevent compiler warnings about cached_has_bits being unused
4675   (void) cached_has_bits;
4676 
4677   cached_has_bits = _impl_._has_bits_[0];
4678   if (cached_has_bits & 0x0000007fu) {
4679     // optional string rwbs = 5;
4680     if (cached_has_bits & 0x00000001u) {
4681       total_size += 1 +
4682         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
4683           this->_internal_rwbs());
4684     }
4685 
4686     // optional string cmd = 6;
4687     if (cached_has_bits & 0x00000002u) {
4688       total_size += 1 +
4689         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
4690           this->_internal_cmd());
4691     }
4692 
4693     // optional uint64 dev = 1;
4694     if (cached_has_bits & 0x00000004u) {
4695       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_dev());
4696     }
4697 
4698     // optional uint64 sector = 2;
4699     if (cached_has_bits & 0x00000008u) {
4700       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_sector());
4701     }
4702 
4703     // optional uint32 nr_sector = 3;
4704     if (cached_has_bits & 0x00000010u) {
4705       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_nr_sector());
4706     }
4707 
4708     // optional int32 errors = 4;
4709     if (cached_has_bits & 0x00000020u) {
4710       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_errors());
4711     }
4712 
4713     // optional int32 error = 7;
4714     if (cached_has_bits & 0x00000040u) {
4715       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_error());
4716     }
4717 
4718   }
4719   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
4720     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
4721   }
4722   int cached_size = ::_pbi::ToCachedSize(total_size);
4723   SetCachedSize(cached_size);
4724   return total_size;
4725 }
4726 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)4727 void BlockRqCompleteFtraceEvent::CheckTypeAndMergeFrom(
4728     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
4729   MergeFrom(*::_pbi::DownCast<const BlockRqCompleteFtraceEvent*>(
4730       &from));
4731 }
4732 
MergeFrom(const BlockRqCompleteFtraceEvent & from)4733 void BlockRqCompleteFtraceEvent::MergeFrom(const BlockRqCompleteFtraceEvent& from) {
4734   BlockRqCompleteFtraceEvent* const _this = this;
4735   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.BlockRqCompleteFtraceEvent)
4736   GOOGLE_DCHECK_NE(&from, _this);
4737   ::uint32_t cached_has_bits = 0;
4738   (void) cached_has_bits;
4739 
4740   cached_has_bits = from._impl_._has_bits_[0];
4741   if (cached_has_bits & 0x0000007fu) {
4742     if (cached_has_bits & 0x00000001u) {
4743       _this->_internal_set_rwbs(from._internal_rwbs());
4744     }
4745     if (cached_has_bits & 0x00000002u) {
4746       _this->_internal_set_cmd(from._internal_cmd());
4747     }
4748     if (cached_has_bits & 0x00000004u) {
4749       _this->_impl_.dev_ = from._impl_.dev_;
4750     }
4751     if (cached_has_bits & 0x00000008u) {
4752       _this->_impl_.sector_ = from._impl_.sector_;
4753     }
4754     if (cached_has_bits & 0x00000010u) {
4755       _this->_impl_.nr_sector_ = from._impl_.nr_sector_;
4756     }
4757     if (cached_has_bits & 0x00000020u) {
4758       _this->_impl_.errors_ = from._impl_.errors_;
4759     }
4760     if (cached_has_bits & 0x00000040u) {
4761       _this->_impl_.error_ = from._impl_.error_;
4762     }
4763     _this->_impl_._has_bits_[0] |= cached_has_bits;
4764   }
4765   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
4766 }
4767 
CopyFrom(const BlockRqCompleteFtraceEvent & from)4768 void BlockRqCompleteFtraceEvent::CopyFrom(const BlockRqCompleteFtraceEvent& from) {
4769 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.BlockRqCompleteFtraceEvent)
4770   if (&from == this) return;
4771   Clear();
4772   MergeFrom(from);
4773 }
4774 
IsInitialized() const4775 bool BlockRqCompleteFtraceEvent::IsInitialized() const {
4776   return true;
4777 }
4778 
InternalSwap(BlockRqCompleteFtraceEvent * other)4779 void BlockRqCompleteFtraceEvent::InternalSwap(BlockRqCompleteFtraceEvent* other) {
4780   using std::swap;
4781   auto* lhs_arena = GetArenaForAllocation();
4782   auto* rhs_arena = other->GetArenaForAllocation();
4783   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
4784   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
4785   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
4786       &_impl_.rwbs_, lhs_arena,
4787       &other->_impl_.rwbs_, rhs_arena
4788   );
4789   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
4790       &_impl_.cmd_, lhs_arena,
4791       &other->_impl_.cmd_, rhs_arena
4792   );
4793   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
4794       PROTOBUF_FIELD_OFFSET(BlockRqCompleteFtraceEvent, _impl_.error_)
4795       + sizeof(BlockRqCompleteFtraceEvent::_impl_.error_)  // NOLINT
4796       - PROTOBUF_FIELD_OFFSET(BlockRqCompleteFtraceEvent, _impl_.dev_)>(
4797           reinterpret_cast<char*>(&_impl_.dev_),
4798           reinterpret_cast<char*>(&other->_impl_.dev_));
4799 }
4800 
GetTypeName() const4801 std::string BlockRqCompleteFtraceEvent::GetTypeName() const {
4802   return "perfetto.protos.BlockRqCompleteFtraceEvent";
4803 }
4804 
4805 
4806 // ===================================================================
4807 
4808 class BlockRqInsertFtraceEvent::_Internal {
4809  public:
4810   using HasBits = decltype(std::declval<BlockRqInsertFtraceEvent>()._impl_._has_bits_);
set_has_dev(HasBits * has_bits)4811   static void set_has_dev(HasBits* has_bits) {
4812     (*has_bits)[0] |= 8u;
4813   }
set_has_sector(HasBits * has_bits)4814   static void set_has_sector(HasBits* has_bits) {
4815     (*has_bits)[0] |= 16u;
4816   }
set_has_nr_sector(HasBits * has_bits)4817   static void set_has_nr_sector(HasBits* has_bits) {
4818     (*has_bits)[0] |= 32u;
4819   }
set_has_bytes(HasBits * has_bits)4820   static void set_has_bytes(HasBits* has_bits) {
4821     (*has_bits)[0] |= 64u;
4822   }
set_has_rwbs(HasBits * has_bits)4823   static void set_has_rwbs(HasBits* has_bits) {
4824     (*has_bits)[0] |= 1u;
4825   }
set_has_comm(HasBits * has_bits)4826   static void set_has_comm(HasBits* has_bits) {
4827     (*has_bits)[0] |= 2u;
4828   }
set_has_cmd(HasBits * has_bits)4829   static void set_has_cmd(HasBits* has_bits) {
4830     (*has_bits)[0] |= 4u;
4831   }
4832 };
4833 
BlockRqInsertFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)4834 BlockRqInsertFtraceEvent::BlockRqInsertFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
4835                          bool is_message_owned)
4836   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
4837   SharedCtor(arena, is_message_owned);
4838   // @@protoc_insertion_point(arena_constructor:perfetto.protos.BlockRqInsertFtraceEvent)
4839 }
BlockRqInsertFtraceEvent(const BlockRqInsertFtraceEvent & from)4840 BlockRqInsertFtraceEvent::BlockRqInsertFtraceEvent(const BlockRqInsertFtraceEvent& from)
4841   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
4842   BlockRqInsertFtraceEvent* const _this = this; (void)_this;
4843   new (&_impl_) Impl_{
4844       decltype(_impl_._has_bits_){from._impl_._has_bits_}
4845     , /*decltype(_impl_._cached_size_)*/{}
4846     , decltype(_impl_.rwbs_){}
4847     , decltype(_impl_.comm_){}
4848     , decltype(_impl_.cmd_){}
4849     , decltype(_impl_.dev_){}
4850     , decltype(_impl_.sector_){}
4851     , decltype(_impl_.nr_sector_){}
4852     , decltype(_impl_.bytes_){}};
4853 
4854   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
4855   _impl_.rwbs_.InitDefault();
4856   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4857     _impl_.rwbs_.Set("", GetArenaForAllocation());
4858   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4859   if (from._internal_has_rwbs()) {
4860     _this->_impl_.rwbs_.Set(from._internal_rwbs(),
4861       _this->GetArenaForAllocation());
4862   }
4863   _impl_.comm_.InitDefault();
4864   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4865     _impl_.comm_.Set("", GetArenaForAllocation());
4866   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4867   if (from._internal_has_comm()) {
4868     _this->_impl_.comm_.Set(from._internal_comm(),
4869       _this->GetArenaForAllocation());
4870   }
4871   _impl_.cmd_.InitDefault();
4872   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4873     _impl_.cmd_.Set("", GetArenaForAllocation());
4874   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4875   if (from._internal_has_cmd()) {
4876     _this->_impl_.cmd_.Set(from._internal_cmd(),
4877       _this->GetArenaForAllocation());
4878   }
4879   ::memcpy(&_impl_.dev_, &from._impl_.dev_,
4880     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.bytes_) -
4881     reinterpret_cast<char*>(&_impl_.dev_)) + sizeof(_impl_.bytes_));
4882   // @@protoc_insertion_point(copy_constructor:perfetto.protos.BlockRqInsertFtraceEvent)
4883 }
4884 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)4885 inline void BlockRqInsertFtraceEvent::SharedCtor(
4886     ::_pb::Arena* arena, bool is_message_owned) {
4887   (void)arena;
4888   (void)is_message_owned;
4889   new (&_impl_) Impl_{
4890       decltype(_impl_._has_bits_){}
4891     , /*decltype(_impl_._cached_size_)*/{}
4892     , decltype(_impl_.rwbs_){}
4893     , decltype(_impl_.comm_){}
4894     , decltype(_impl_.cmd_){}
4895     , decltype(_impl_.dev_){::uint64_t{0u}}
4896     , decltype(_impl_.sector_){::uint64_t{0u}}
4897     , decltype(_impl_.nr_sector_){0u}
4898     , decltype(_impl_.bytes_){0u}
4899   };
4900   _impl_.rwbs_.InitDefault();
4901   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4902     _impl_.rwbs_.Set("", GetArenaForAllocation());
4903   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4904   _impl_.comm_.InitDefault();
4905   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4906     _impl_.comm_.Set("", GetArenaForAllocation());
4907   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4908   _impl_.cmd_.InitDefault();
4909   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4910     _impl_.cmd_.Set("", GetArenaForAllocation());
4911   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4912 }
4913 
~BlockRqInsertFtraceEvent()4914 BlockRqInsertFtraceEvent::~BlockRqInsertFtraceEvent() {
4915   // @@protoc_insertion_point(destructor:perfetto.protos.BlockRqInsertFtraceEvent)
4916   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
4917   (void)arena;
4918     return;
4919   }
4920   SharedDtor();
4921 }
4922 
SharedDtor()4923 inline void BlockRqInsertFtraceEvent::SharedDtor() {
4924   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
4925   _impl_.rwbs_.Destroy();
4926   _impl_.comm_.Destroy();
4927   _impl_.cmd_.Destroy();
4928 }
4929 
SetCachedSize(int size) const4930 void BlockRqInsertFtraceEvent::SetCachedSize(int size) const {
4931   _impl_._cached_size_.Set(size);
4932 }
4933 
Clear()4934 void BlockRqInsertFtraceEvent::Clear() {
4935 // @@protoc_insertion_point(message_clear_start:perfetto.protos.BlockRqInsertFtraceEvent)
4936   ::uint32_t cached_has_bits = 0;
4937   // Prevent compiler warnings about cached_has_bits being unused
4938   (void) cached_has_bits;
4939 
4940   cached_has_bits = _impl_._has_bits_[0];
4941   if (cached_has_bits & 0x00000007u) {
4942     if (cached_has_bits & 0x00000001u) {
4943       _impl_.rwbs_.ClearNonDefaultToEmpty();
4944     }
4945     if (cached_has_bits & 0x00000002u) {
4946       _impl_.comm_.ClearNonDefaultToEmpty();
4947     }
4948     if (cached_has_bits & 0x00000004u) {
4949       _impl_.cmd_.ClearNonDefaultToEmpty();
4950     }
4951   }
4952   if (cached_has_bits & 0x00000078u) {
4953     ::memset(&_impl_.dev_, 0, static_cast<size_t>(
4954         reinterpret_cast<char*>(&_impl_.bytes_) -
4955         reinterpret_cast<char*>(&_impl_.dev_)) + sizeof(_impl_.bytes_));
4956   }
4957   _impl_._has_bits_.Clear();
4958   _internal_metadata_.Clear<std::string>();
4959 }
4960 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)4961 const char* BlockRqInsertFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
4962 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
4963   _Internal::HasBits has_bits{};
4964   while (!ctx->Done(&ptr)) {
4965     ::uint32_t tag;
4966     ptr = ::_pbi::ReadTag(ptr, &tag);
4967     switch (tag >> 3) {
4968       // optional uint64 dev = 1;
4969       case 1:
4970         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
4971           _Internal::set_has_dev(&has_bits);
4972           _impl_.dev_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
4973           CHK_(ptr);
4974         } else {
4975           goto handle_unusual;
4976         }
4977         continue;
4978       // optional uint64 sector = 2;
4979       case 2:
4980         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
4981           _Internal::set_has_sector(&has_bits);
4982           _impl_.sector_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
4983           CHK_(ptr);
4984         } else {
4985           goto handle_unusual;
4986         }
4987         continue;
4988       // optional uint32 nr_sector = 3;
4989       case 3:
4990         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
4991           _Internal::set_has_nr_sector(&has_bits);
4992           _impl_.nr_sector_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
4993           CHK_(ptr);
4994         } else {
4995           goto handle_unusual;
4996         }
4997         continue;
4998       // optional uint32 bytes = 4;
4999       case 4:
5000         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
5001           _Internal::set_has_bytes(&has_bits);
5002           _impl_.bytes_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
5003           CHK_(ptr);
5004         } else {
5005           goto handle_unusual;
5006         }
5007         continue;
5008       // optional string rwbs = 5;
5009       case 5:
5010         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 42)) {
5011           auto str = _internal_mutable_rwbs();
5012           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
5013           CHK_(ptr);
5014         } else {
5015           goto handle_unusual;
5016         }
5017         continue;
5018       // optional string comm = 6;
5019       case 6:
5020         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 50)) {
5021           auto str = _internal_mutable_comm();
5022           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
5023           CHK_(ptr);
5024         } else {
5025           goto handle_unusual;
5026         }
5027         continue;
5028       // optional string cmd = 7;
5029       case 7:
5030         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 58)) {
5031           auto str = _internal_mutable_cmd();
5032           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
5033           CHK_(ptr);
5034         } else {
5035           goto handle_unusual;
5036         }
5037         continue;
5038       default:
5039         goto handle_unusual;
5040     }  // switch
5041   handle_unusual:
5042     if ((tag == 0) || ((tag & 7) == 4)) {
5043       CHK_(ptr);
5044       ctx->SetLastTag(tag);
5045       goto message_done;
5046     }
5047     ptr = UnknownFieldParse(
5048         tag,
5049         _internal_metadata_.mutable_unknown_fields<std::string>(),
5050         ptr, ctx);
5051     CHK_(ptr != nullptr);
5052   }  // while
5053 message_done:
5054   _impl_._has_bits_.Or(has_bits);
5055   return ptr;
5056 failure:
5057   ptr = nullptr;
5058   goto message_done;
5059 #undef CHK_
5060 }
5061 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const5062 ::uint8_t* BlockRqInsertFtraceEvent::_InternalSerialize(
5063     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
5064   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.BlockRqInsertFtraceEvent)
5065   ::uint32_t cached_has_bits = 0;
5066   (void) cached_has_bits;
5067 
5068   cached_has_bits = _impl_._has_bits_[0];
5069   // optional uint64 dev = 1;
5070   if (cached_has_bits & 0x00000008u) {
5071     target = stream->EnsureSpace(target);
5072     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_dev(), target);
5073   }
5074 
5075   // optional uint64 sector = 2;
5076   if (cached_has_bits & 0x00000010u) {
5077     target = stream->EnsureSpace(target);
5078     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(2, this->_internal_sector(), target);
5079   }
5080 
5081   // optional uint32 nr_sector = 3;
5082   if (cached_has_bits & 0x00000020u) {
5083     target = stream->EnsureSpace(target);
5084     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_nr_sector(), target);
5085   }
5086 
5087   // optional uint32 bytes = 4;
5088   if (cached_has_bits & 0x00000040u) {
5089     target = stream->EnsureSpace(target);
5090     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(4, this->_internal_bytes(), target);
5091   }
5092 
5093   // optional string rwbs = 5;
5094   if (cached_has_bits & 0x00000001u) {
5095     target = stream->WriteStringMaybeAliased(
5096         5, this->_internal_rwbs(), target);
5097   }
5098 
5099   // optional string comm = 6;
5100   if (cached_has_bits & 0x00000002u) {
5101     target = stream->WriteStringMaybeAliased(
5102         6, this->_internal_comm(), target);
5103   }
5104 
5105   // optional string cmd = 7;
5106   if (cached_has_bits & 0x00000004u) {
5107     target = stream->WriteStringMaybeAliased(
5108         7, this->_internal_cmd(), target);
5109   }
5110 
5111   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
5112     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
5113         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
5114   }
5115   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.BlockRqInsertFtraceEvent)
5116   return target;
5117 }
5118 
ByteSizeLong() const5119 size_t BlockRqInsertFtraceEvent::ByteSizeLong() const {
5120 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.BlockRqInsertFtraceEvent)
5121   size_t total_size = 0;
5122 
5123   ::uint32_t cached_has_bits = 0;
5124   // Prevent compiler warnings about cached_has_bits being unused
5125   (void) cached_has_bits;
5126 
5127   cached_has_bits = _impl_._has_bits_[0];
5128   if (cached_has_bits & 0x0000007fu) {
5129     // optional string rwbs = 5;
5130     if (cached_has_bits & 0x00000001u) {
5131       total_size += 1 +
5132         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
5133           this->_internal_rwbs());
5134     }
5135 
5136     // optional string comm = 6;
5137     if (cached_has_bits & 0x00000002u) {
5138       total_size += 1 +
5139         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
5140           this->_internal_comm());
5141     }
5142 
5143     // optional string cmd = 7;
5144     if (cached_has_bits & 0x00000004u) {
5145       total_size += 1 +
5146         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
5147           this->_internal_cmd());
5148     }
5149 
5150     // optional uint64 dev = 1;
5151     if (cached_has_bits & 0x00000008u) {
5152       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_dev());
5153     }
5154 
5155     // optional uint64 sector = 2;
5156     if (cached_has_bits & 0x00000010u) {
5157       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_sector());
5158     }
5159 
5160     // optional uint32 nr_sector = 3;
5161     if (cached_has_bits & 0x00000020u) {
5162       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_nr_sector());
5163     }
5164 
5165     // optional uint32 bytes = 4;
5166     if (cached_has_bits & 0x00000040u) {
5167       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_bytes());
5168     }
5169 
5170   }
5171   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
5172     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
5173   }
5174   int cached_size = ::_pbi::ToCachedSize(total_size);
5175   SetCachedSize(cached_size);
5176   return total_size;
5177 }
5178 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)5179 void BlockRqInsertFtraceEvent::CheckTypeAndMergeFrom(
5180     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
5181   MergeFrom(*::_pbi::DownCast<const BlockRqInsertFtraceEvent*>(
5182       &from));
5183 }
5184 
MergeFrom(const BlockRqInsertFtraceEvent & from)5185 void BlockRqInsertFtraceEvent::MergeFrom(const BlockRqInsertFtraceEvent& from) {
5186   BlockRqInsertFtraceEvent* const _this = this;
5187   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.BlockRqInsertFtraceEvent)
5188   GOOGLE_DCHECK_NE(&from, _this);
5189   ::uint32_t cached_has_bits = 0;
5190   (void) cached_has_bits;
5191 
5192   cached_has_bits = from._impl_._has_bits_[0];
5193   if (cached_has_bits & 0x0000007fu) {
5194     if (cached_has_bits & 0x00000001u) {
5195       _this->_internal_set_rwbs(from._internal_rwbs());
5196     }
5197     if (cached_has_bits & 0x00000002u) {
5198       _this->_internal_set_comm(from._internal_comm());
5199     }
5200     if (cached_has_bits & 0x00000004u) {
5201       _this->_internal_set_cmd(from._internal_cmd());
5202     }
5203     if (cached_has_bits & 0x00000008u) {
5204       _this->_impl_.dev_ = from._impl_.dev_;
5205     }
5206     if (cached_has_bits & 0x00000010u) {
5207       _this->_impl_.sector_ = from._impl_.sector_;
5208     }
5209     if (cached_has_bits & 0x00000020u) {
5210       _this->_impl_.nr_sector_ = from._impl_.nr_sector_;
5211     }
5212     if (cached_has_bits & 0x00000040u) {
5213       _this->_impl_.bytes_ = from._impl_.bytes_;
5214     }
5215     _this->_impl_._has_bits_[0] |= cached_has_bits;
5216   }
5217   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
5218 }
5219 
CopyFrom(const BlockRqInsertFtraceEvent & from)5220 void BlockRqInsertFtraceEvent::CopyFrom(const BlockRqInsertFtraceEvent& from) {
5221 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.BlockRqInsertFtraceEvent)
5222   if (&from == this) return;
5223   Clear();
5224   MergeFrom(from);
5225 }
5226 
IsInitialized() const5227 bool BlockRqInsertFtraceEvent::IsInitialized() const {
5228   return true;
5229 }
5230 
InternalSwap(BlockRqInsertFtraceEvent * other)5231 void BlockRqInsertFtraceEvent::InternalSwap(BlockRqInsertFtraceEvent* other) {
5232   using std::swap;
5233   auto* lhs_arena = GetArenaForAllocation();
5234   auto* rhs_arena = other->GetArenaForAllocation();
5235   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
5236   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
5237   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
5238       &_impl_.rwbs_, lhs_arena,
5239       &other->_impl_.rwbs_, rhs_arena
5240   );
5241   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
5242       &_impl_.comm_, lhs_arena,
5243       &other->_impl_.comm_, rhs_arena
5244   );
5245   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
5246       &_impl_.cmd_, lhs_arena,
5247       &other->_impl_.cmd_, rhs_arena
5248   );
5249   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
5250       PROTOBUF_FIELD_OFFSET(BlockRqInsertFtraceEvent, _impl_.bytes_)
5251       + sizeof(BlockRqInsertFtraceEvent::_impl_.bytes_)  // NOLINT
5252       - PROTOBUF_FIELD_OFFSET(BlockRqInsertFtraceEvent, _impl_.dev_)>(
5253           reinterpret_cast<char*>(&_impl_.dev_),
5254           reinterpret_cast<char*>(&other->_impl_.dev_));
5255 }
5256 
GetTypeName() const5257 std::string BlockRqInsertFtraceEvent::GetTypeName() const {
5258   return "perfetto.protos.BlockRqInsertFtraceEvent";
5259 }
5260 
5261 
5262 // ===================================================================
5263 
5264 class BlockRqRemapFtraceEvent::_Internal {
5265  public:
5266   using HasBits = decltype(std::declval<BlockRqRemapFtraceEvent>()._impl_._has_bits_);
set_has_dev(HasBits * has_bits)5267   static void set_has_dev(HasBits* has_bits) {
5268     (*has_bits)[0] |= 2u;
5269   }
set_has_sector(HasBits * has_bits)5270   static void set_has_sector(HasBits* has_bits) {
5271     (*has_bits)[0] |= 4u;
5272   }
set_has_nr_sector(HasBits * has_bits)5273   static void set_has_nr_sector(HasBits* has_bits) {
5274     (*has_bits)[0] |= 16u;
5275   }
set_has_old_dev(HasBits * has_bits)5276   static void set_has_old_dev(HasBits* has_bits) {
5277     (*has_bits)[0] |= 8u;
5278   }
set_has_old_sector(HasBits * has_bits)5279   static void set_has_old_sector(HasBits* has_bits) {
5280     (*has_bits)[0] |= 64u;
5281   }
set_has_nr_bios(HasBits * has_bits)5282   static void set_has_nr_bios(HasBits* has_bits) {
5283     (*has_bits)[0] |= 32u;
5284   }
set_has_rwbs(HasBits * has_bits)5285   static void set_has_rwbs(HasBits* has_bits) {
5286     (*has_bits)[0] |= 1u;
5287   }
5288 };
5289 
BlockRqRemapFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)5290 BlockRqRemapFtraceEvent::BlockRqRemapFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
5291                          bool is_message_owned)
5292   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
5293   SharedCtor(arena, is_message_owned);
5294   // @@protoc_insertion_point(arena_constructor:perfetto.protos.BlockRqRemapFtraceEvent)
5295 }
BlockRqRemapFtraceEvent(const BlockRqRemapFtraceEvent & from)5296 BlockRqRemapFtraceEvent::BlockRqRemapFtraceEvent(const BlockRqRemapFtraceEvent& from)
5297   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
5298   BlockRqRemapFtraceEvent* const _this = this; (void)_this;
5299   new (&_impl_) Impl_{
5300       decltype(_impl_._has_bits_){from._impl_._has_bits_}
5301     , /*decltype(_impl_._cached_size_)*/{}
5302     , decltype(_impl_.rwbs_){}
5303     , decltype(_impl_.dev_){}
5304     , decltype(_impl_.sector_){}
5305     , decltype(_impl_.old_dev_){}
5306     , decltype(_impl_.nr_sector_){}
5307     , decltype(_impl_.nr_bios_){}
5308     , decltype(_impl_.old_sector_){}};
5309 
5310   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
5311   _impl_.rwbs_.InitDefault();
5312   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
5313     _impl_.rwbs_.Set("", GetArenaForAllocation());
5314   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
5315   if (from._internal_has_rwbs()) {
5316     _this->_impl_.rwbs_.Set(from._internal_rwbs(),
5317       _this->GetArenaForAllocation());
5318   }
5319   ::memcpy(&_impl_.dev_, &from._impl_.dev_,
5320     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.old_sector_) -
5321     reinterpret_cast<char*>(&_impl_.dev_)) + sizeof(_impl_.old_sector_));
5322   // @@protoc_insertion_point(copy_constructor:perfetto.protos.BlockRqRemapFtraceEvent)
5323 }
5324 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)5325 inline void BlockRqRemapFtraceEvent::SharedCtor(
5326     ::_pb::Arena* arena, bool is_message_owned) {
5327   (void)arena;
5328   (void)is_message_owned;
5329   new (&_impl_) Impl_{
5330       decltype(_impl_._has_bits_){}
5331     , /*decltype(_impl_._cached_size_)*/{}
5332     , decltype(_impl_.rwbs_){}
5333     , decltype(_impl_.dev_){::uint64_t{0u}}
5334     , decltype(_impl_.sector_){::uint64_t{0u}}
5335     , decltype(_impl_.old_dev_){::uint64_t{0u}}
5336     , decltype(_impl_.nr_sector_){0u}
5337     , decltype(_impl_.nr_bios_){0u}
5338     , decltype(_impl_.old_sector_){::uint64_t{0u}}
5339   };
5340   _impl_.rwbs_.InitDefault();
5341   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
5342     _impl_.rwbs_.Set("", GetArenaForAllocation());
5343   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
5344 }
5345 
~BlockRqRemapFtraceEvent()5346 BlockRqRemapFtraceEvent::~BlockRqRemapFtraceEvent() {
5347   // @@protoc_insertion_point(destructor:perfetto.protos.BlockRqRemapFtraceEvent)
5348   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
5349   (void)arena;
5350     return;
5351   }
5352   SharedDtor();
5353 }
5354 
SharedDtor()5355 inline void BlockRqRemapFtraceEvent::SharedDtor() {
5356   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
5357   _impl_.rwbs_.Destroy();
5358 }
5359 
SetCachedSize(int size) const5360 void BlockRqRemapFtraceEvent::SetCachedSize(int size) const {
5361   _impl_._cached_size_.Set(size);
5362 }
5363 
Clear()5364 void BlockRqRemapFtraceEvent::Clear() {
5365 // @@protoc_insertion_point(message_clear_start:perfetto.protos.BlockRqRemapFtraceEvent)
5366   ::uint32_t cached_has_bits = 0;
5367   // Prevent compiler warnings about cached_has_bits being unused
5368   (void) cached_has_bits;
5369 
5370   cached_has_bits = _impl_._has_bits_[0];
5371   if (cached_has_bits & 0x00000001u) {
5372     _impl_.rwbs_.ClearNonDefaultToEmpty();
5373   }
5374   if (cached_has_bits & 0x0000007eu) {
5375     ::memset(&_impl_.dev_, 0, static_cast<size_t>(
5376         reinterpret_cast<char*>(&_impl_.old_sector_) -
5377         reinterpret_cast<char*>(&_impl_.dev_)) + sizeof(_impl_.old_sector_));
5378   }
5379   _impl_._has_bits_.Clear();
5380   _internal_metadata_.Clear<std::string>();
5381 }
5382 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)5383 const char* BlockRqRemapFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
5384 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
5385   _Internal::HasBits has_bits{};
5386   while (!ctx->Done(&ptr)) {
5387     ::uint32_t tag;
5388     ptr = ::_pbi::ReadTag(ptr, &tag);
5389     switch (tag >> 3) {
5390       // optional uint64 dev = 1;
5391       case 1:
5392         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
5393           _Internal::set_has_dev(&has_bits);
5394           _impl_.dev_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
5395           CHK_(ptr);
5396         } else {
5397           goto handle_unusual;
5398         }
5399         continue;
5400       // optional uint64 sector = 2;
5401       case 2:
5402         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
5403           _Internal::set_has_sector(&has_bits);
5404           _impl_.sector_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
5405           CHK_(ptr);
5406         } else {
5407           goto handle_unusual;
5408         }
5409         continue;
5410       // optional uint32 nr_sector = 3;
5411       case 3:
5412         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
5413           _Internal::set_has_nr_sector(&has_bits);
5414           _impl_.nr_sector_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
5415           CHK_(ptr);
5416         } else {
5417           goto handle_unusual;
5418         }
5419         continue;
5420       // optional uint64 old_dev = 4;
5421       case 4:
5422         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
5423           _Internal::set_has_old_dev(&has_bits);
5424           _impl_.old_dev_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
5425           CHK_(ptr);
5426         } else {
5427           goto handle_unusual;
5428         }
5429         continue;
5430       // optional uint64 old_sector = 5;
5431       case 5:
5432         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
5433           _Internal::set_has_old_sector(&has_bits);
5434           _impl_.old_sector_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
5435           CHK_(ptr);
5436         } else {
5437           goto handle_unusual;
5438         }
5439         continue;
5440       // optional uint32 nr_bios = 6;
5441       case 6:
5442         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 48)) {
5443           _Internal::set_has_nr_bios(&has_bits);
5444           _impl_.nr_bios_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
5445           CHK_(ptr);
5446         } else {
5447           goto handle_unusual;
5448         }
5449         continue;
5450       // optional string rwbs = 7;
5451       case 7:
5452         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 58)) {
5453           auto str = _internal_mutable_rwbs();
5454           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
5455           CHK_(ptr);
5456         } else {
5457           goto handle_unusual;
5458         }
5459         continue;
5460       default:
5461         goto handle_unusual;
5462     }  // switch
5463   handle_unusual:
5464     if ((tag == 0) || ((tag & 7) == 4)) {
5465       CHK_(ptr);
5466       ctx->SetLastTag(tag);
5467       goto message_done;
5468     }
5469     ptr = UnknownFieldParse(
5470         tag,
5471         _internal_metadata_.mutable_unknown_fields<std::string>(),
5472         ptr, ctx);
5473     CHK_(ptr != nullptr);
5474   }  // while
5475 message_done:
5476   _impl_._has_bits_.Or(has_bits);
5477   return ptr;
5478 failure:
5479   ptr = nullptr;
5480   goto message_done;
5481 #undef CHK_
5482 }
5483 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const5484 ::uint8_t* BlockRqRemapFtraceEvent::_InternalSerialize(
5485     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
5486   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.BlockRqRemapFtraceEvent)
5487   ::uint32_t cached_has_bits = 0;
5488   (void) cached_has_bits;
5489 
5490   cached_has_bits = _impl_._has_bits_[0];
5491   // optional uint64 dev = 1;
5492   if (cached_has_bits & 0x00000002u) {
5493     target = stream->EnsureSpace(target);
5494     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_dev(), target);
5495   }
5496 
5497   // optional uint64 sector = 2;
5498   if (cached_has_bits & 0x00000004u) {
5499     target = stream->EnsureSpace(target);
5500     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(2, this->_internal_sector(), target);
5501   }
5502 
5503   // optional uint32 nr_sector = 3;
5504   if (cached_has_bits & 0x00000010u) {
5505     target = stream->EnsureSpace(target);
5506     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_nr_sector(), target);
5507   }
5508 
5509   // optional uint64 old_dev = 4;
5510   if (cached_has_bits & 0x00000008u) {
5511     target = stream->EnsureSpace(target);
5512     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(4, this->_internal_old_dev(), target);
5513   }
5514 
5515   // optional uint64 old_sector = 5;
5516   if (cached_has_bits & 0x00000040u) {
5517     target = stream->EnsureSpace(target);
5518     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(5, this->_internal_old_sector(), target);
5519   }
5520 
5521   // optional uint32 nr_bios = 6;
5522   if (cached_has_bits & 0x00000020u) {
5523     target = stream->EnsureSpace(target);
5524     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(6, this->_internal_nr_bios(), target);
5525   }
5526 
5527   // optional string rwbs = 7;
5528   if (cached_has_bits & 0x00000001u) {
5529     target = stream->WriteStringMaybeAliased(
5530         7, this->_internal_rwbs(), target);
5531   }
5532 
5533   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
5534     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
5535         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
5536   }
5537   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.BlockRqRemapFtraceEvent)
5538   return target;
5539 }
5540 
ByteSizeLong() const5541 size_t BlockRqRemapFtraceEvent::ByteSizeLong() const {
5542 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.BlockRqRemapFtraceEvent)
5543   size_t total_size = 0;
5544 
5545   ::uint32_t cached_has_bits = 0;
5546   // Prevent compiler warnings about cached_has_bits being unused
5547   (void) cached_has_bits;
5548 
5549   cached_has_bits = _impl_._has_bits_[0];
5550   if (cached_has_bits & 0x0000007fu) {
5551     // optional string rwbs = 7;
5552     if (cached_has_bits & 0x00000001u) {
5553       total_size += 1 +
5554         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
5555           this->_internal_rwbs());
5556     }
5557 
5558     // optional uint64 dev = 1;
5559     if (cached_has_bits & 0x00000002u) {
5560       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_dev());
5561     }
5562 
5563     // optional uint64 sector = 2;
5564     if (cached_has_bits & 0x00000004u) {
5565       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_sector());
5566     }
5567 
5568     // optional uint64 old_dev = 4;
5569     if (cached_has_bits & 0x00000008u) {
5570       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_old_dev());
5571     }
5572 
5573     // optional uint32 nr_sector = 3;
5574     if (cached_has_bits & 0x00000010u) {
5575       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_nr_sector());
5576     }
5577 
5578     // optional uint32 nr_bios = 6;
5579     if (cached_has_bits & 0x00000020u) {
5580       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_nr_bios());
5581     }
5582 
5583     // optional uint64 old_sector = 5;
5584     if (cached_has_bits & 0x00000040u) {
5585       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_old_sector());
5586     }
5587 
5588   }
5589   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
5590     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
5591   }
5592   int cached_size = ::_pbi::ToCachedSize(total_size);
5593   SetCachedSize(cached_size);
5594   return total_size;
5595 }
5596 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)5597 void BlockRqRemapFtraceEvent::CheckTypeAndMergeFrom(
5598     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
5599   MergeFrom(*::_pbi::DownCast<const BlockRqRemapFtraceEvent*>(
5600       &from));
5601 }
5602 
MergeFrom(const BlockRqRemapFtraceEvent & from)5603 void BlockRqRemapFtraceEvent::MergeFrom(const BlockRqRemapFtraceEvent& from) {
5604   BlockRqRemapFtraceEvent* const _this = this;
5605   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.BlockRqRemapFtraceEvent)
5606   GOOGLE_DCHECK_NE(&from, _this);
5607   ::uint32_t cached_has_bits = 0;
5608   (void) cached_has_bits;
5609 
5610   cached_has_bits = from._impl_._has_bits_[0];
5611   if (cached_has_bits & 0x0000007fu) {
5612     if (cached_has_bits & 0x00000001u) {
5613       _this->_internal_set_rwbs(from._internal_rwbs());
5614     }
5615     if (cached_has_bits & 0x00000002u) {
5616       _this->_impl_.dev_ = from._impl_.dev_;
5617     }
5618     if (cached_has_bits & 0x00000004u) {
5619       _this->_impl_.sector_ = from._impl_.sector_;
5620     }
5621     if (cached_has_bits & 0x00000008u) {
5622       _this->_impl_.old_dev_ = from._impl_.old_dev_;
5623     }
5624     if (cached_has_bits & 0x00000010u) {
5625       _this->_impl_.nr_sector_ = from._impl_.nr_sector_;
5626     }
5627     if (cached_has_bits & 0x00000020u) {
5628       _this->_impl_.nr_bios_ = from._impl_.nr_bios_;
5629     }
5630     if (cached_has_bits & 0x00000040u) {
5631       _this->_impl_.old_sector_ = from._impl_.old_sector_;
5632     }
5633     _this->_impl_._has_bits_[0] |= cached_has_bits;
5634   }
5635   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
5636 }
5637 
CopyFrom(const BlockRqRemapFtraceEvent & from)5638 void BlockRqRemapFtraceEvent::CopyFrom(const BlockRqRemapFtraceEvent& from) {
5639 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.BlockRqRemapFtraceEvent)
5640   if (&from == this) return;
5641   Clear();
5642   MergeFrom(from);
5643 }
5644 
IsInitialized() const5645 bool BlockRqRemapFtraceEvent::IsInitialized() const {
5646   return true;
5647 }
5648 
InternalSwap(BlockRqRemapFtraceEvent * other)5649 void BlockRqRemapFtraceEvent::InternalSwap(BlockRqRemapFtraceEvent* other) {
5650   using std::swap;
5651   auto* lhs_arena = GetArenaForAllocation();
5652   auto* rhs_arena = other->GetArenaForAllocation();
5653   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
5654   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
5655   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
5656       &_impl_.rwbs_, lhs_arena,
5657       &other->_impl_.rwbs_, rhs_arena
5658   );
5659   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
5660       PROTOBUF_FIELD_OFFSET(BlockRqRemapFtraceEvent, _impl_.old_sector_)
5661       + sizeof(BlockRqRemapFtraceEvent::_impl_.old_sector_)  // NOLINT
5662       - PROTOBUF_FIELD_OFFSET(BlockRqRemapFtraceEvent, _impl_.dev_)>(
5663           reinterpret_cast<char*>(&_impl_.dev_),
5664           reinterpret_cast<char*>(&other->_impl_.dev_));
5665 }
5666 
GetTypeName() const5667 std::string BlockRqRemapFtraceEvent::GetTypeName() const {
5668   return "perfetto.protos.BlockRqRemapFtraceEvent";
5669 }
5670 
5671 
5672 // ===================================================================
5673 
5674 class BlockRqRequeueFtraceEvent::_Internal {
5675  public:
5676   using HasBits = decltype(std::declval<BlockRqRequeueFtraceEvent>()._impl_._has_bits_);
set_has_dev(HasBits * has_bits)5677   static void set_has_dev(HasBits* has_bits) {
5678     (*has_bits)[0] |= 4u;
5679   }
set_has_sector(HasBits * has_bits)5680   static void set_has_sector(HasBits* has_bits) {
5681     (*has_bits)[0] |= 8u;
5682   }
set_has_nr_sector(HasBits * has_bits)5683   static void set_has_nr_sector(HasBits* has_bits) {
5684     (*has_bits)[0] |= 16u;
5685   }
set_has_errors(HasBits * has_bits)5686   static void set_has_errors(HasBits* has_bits) {
5687     (*has_bits)[0] |= 32u;
5688   }
set_has_rwbs(HasBits * has_bits)5689   static void set_has_rwbs(HasBits* has_bits) {
5690     (*has_bits)[0] |= 1u;
5691   }
set_has_cmd(HasBits * has_bits)5692   static void set_has_cmd(HasBits* has_bits) {
5693     (*has_bits)[0] |= 2u;
5694   }
5695 };
5696 
BlockRqRequeueFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)5697 BlockRqRequeueFtraceEvent::BlockRqRequeueFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
5698                          bool is_message_owned)
5699   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
5700   SharedCtor(arena, is_message_owned);
5701   // @@protoc_insertion_point(arena_constructor:perfetto.protos.BlockRqRequeueFtraceEvent)
5702 }
BlockRqRequeueFtraceEvent(const BlockRqRequeueFtraceEvent & from)5703 BlockRqRequeueFtraceEvent::BlockRqRequeueFtraceEvent(const BlockRqRequeueFtraceEvent& from)
5704   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
5705   BlockRqRequeueFtraceEvent* const _this = this; (void)_this;
5706   new (&_impl_) Impl_{
5707       decltype(_impl_._has_bits_){from._impl_._has_bits_}
5708     , /*decltype(_impl_._cached_size_)*/{}
5709     , decltype(_impl_.rwbs_){}
5710     , decltype(_impl_.cmd_){}
5711     , decltype(_impl_.dev_){}
5712     , decltype(_impl_.sector_){}
5713     , decltype(_impl_.nr_sector_){}
5714     , decltype(_impl_.errors_){}};
5715 
5716   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
5717   _impl_.rwbs_.InitDefault();
5718   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
5719     _impl_.rwbs_.Set("", GetArenaForAllocation());
5720   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
5721   if (from._internal_has_rwbs()) {
5722     _this->_impl_.rwbs_.Set(from._internal_rwbs(),
5723       _this->GetArenaForAllocation());
5724   }
5725   _impl_.cmd_.InitDefault();
5726   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
5727     _impl_.cmd_.Set("", GetArenaForAllocation());
5728   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
5729   if (from._internal_has_cmd()) {
5730     _this->_impl_.cmd_.Set(from._internal_cmd(),
5731       _this->GetArenaForAllocation());
5732   }
5733   ::memcpy(&_impl_.dev_, &from._impl_.dev_,
5734     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.errors_) -
5735     reinterpret_cast<char*>(&_impl_.dev_)) + sizeof(_impl_.errors_));
5736   // @@protoc_insertion_point(copy_constructor:perfetto.protos.BlockRqRequeueFtraceEvent)
5737 }
5738 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)5739 inline void BlockRqRequeueFtraceEvent::SharedCtor(
5740     ::_pb::Arena* arena, bool is_message_owned) {
5741   (void)arena;
5742   (void)is_message_owned;
5743   new (&_impl_) Impl_{
5744       decltype(_impl_._has_bits_){}
5745     , /*decltype(_impl_._cached_size_)*/{}
5746     , decltype(_impl_.rwbs_){}
5747     , decltype(_impl_.cmd_){}
5748     , decltype(_impl_.dev_){::uint64_t{0u}}
5749     , decltype(_impl_.sector_){::uint64_t{0u}}
5750     , decltype(_impl_.nr_sector_){0u}
5751     , decltype(_impl_.errors_){0}
5752   };
5753   _impl_.rwbs_.InitDefault();
5754   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
5755     _impl_.rwbs_.Set("", GetArenaForAllocation());
5756   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
5757   _impl_.cmd_.InitDefault();
5758   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
5759     _impl_.cmd_.Set("", GetArenaForAllocation());
5760   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
5761 }
5762 
~BlockRqRequeueFtraceEvent()5763 BlockRqRequeueFtraceEvent::~BlockRqRequeueFtraceEvent() {
5764   // @@protoc_insertion_point(destructor:perfetto.protos.BlockRqRequeueFtraceEvent)
5765   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
5766   (void)arena;
5767     return;
5768   }
5769   SharedDtor();
5770 }
5771 
SharedDtor()5772 inline void BlockRqRequeueFtraceEvent::SharedDtor() {
5773   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
5774   _impl_.rwbs_.Destroy();
5775   _impl_.cmd_.Destroy();
5776 }
5777 
SetCachedSize(int size) const5778 void BlockRqRequeueFtraceEvent::SetCachedSize(int size) const {
5779   _impl_._cached_size_.Set(size);
5780 }
5781 
Clear()5782 void BlockRqRequeueFtraceEvent::Clear() {
5783 // @@protoc_insertion_point(message_clear_start:perfetto.protos.BlockRqRequeueFtraceEvent)
5784   ::uint32_t cached_has_bits = 0;
5785   // Prevent compiler warnings about cached_has_bits being unused
5786   (void) cached_has_bits;
5787 
5788   cached_has_bits = _impl_._has_bits_[0];
5789   if (cached_has_bits & 0x00000003u) {
5790     if (cached_has_bits & 0x00000001u) {
5791       _impl_.rwbs_.ClearNonDefaultToEmpty();
5792     }
5793     if (cached_has_bits & 0x00000002u) {
5794       _impl_.cmd_.ClearNonDefaultToEmpty();
5795     }
5796   }
5797   if (cached_has_bits & 0x0000003cu) {
5798     ::memset(&_impl_.dev_, 0, static_cast<size_t>(
5799         reinterpret_cast<char*>(&_impl_.errors_) -
5800         reinterpret_cast<char*>(&_impl_.dev_)) + sizeof(_impl_.errors_));
5801   }
5802   _impl_._has_bits_.Clear();
5803   _internal_metadata_.Clear<std::string>();
5804 }
5805 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)5806 const char* BlockRqRequeueFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
5807 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
5808   _Internal::HasBits has_bits{};
5809   while (!ctx->Done(&ptr)) {
5810     ::uint32_t tag;
5811     ptr = ::_pbi::ReadTag(ptr, &tag);
5812     switch (tag >> 3) {
5813       // optional uint64 dev = 1;
5814       case 1:
5815         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
5816           _Internal::set_has_dev(&has_bits);
5817           _impl_.dev_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
5818           CHK_(ptr);
5819         } else {
5820           goto handle_unusual;
5821         }
5822         continue;
5823       // optional uint64 sector = 2;
5824       case 2:
5825         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
5826           _Internal::set_has_sector(&has_bits);
5827           _impl_.sector_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
5828           CHK_(ptr);
5829         } else {
5830           goto handle_unusual;
5831         }
5832         continue;
5833       // optional uint32 nr_sector = 3;
5834       case 3:
5835         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
5836           _Internal::set_has_nr_sector(&has_bits);
5837           _impl_.nr_sector_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
5838           CHK_(ptr);
5839         } else {
5840           goto handle_unusual;
5841         }
5842         continue;
5843       // optional int32 errors = 4;
5844       case 4:
5845         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
5846           _Internal::set_has_errors(&has_bits);
5847           _impl_.errors_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
5848           CHK_(ptr);
5849         } else {
5850           goto handle_unusual;
5851         }
5852         continue;
5853       // optional string rwbs = 5;
5854       case 5:
5855         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 42)) {
5856           auto str = _internal_mutable_rwbs();
5857           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
5858           CHK_(ptr);
5859         } else {
5860           goto handle_unusual;
5861         }
5862         continue;
5863       // optional string cmd = 6;
5864       case 6:
5865         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 50)) {
5866           auto str = _internal_mutable_cmd();
5867           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
5868           CHK_(ptr);
5869         } else {
5870           goto handle_unusual;
5871         }
5872         continue;
5873       default:
5874         goto handle_unusual;
5875     }  // switch
5876   handle_unusual:
5877     if ((tag == 0) || ((tag & 7) == 4)) {
5878       CHK_(ptr);
5879       ctx->SetLastTag(tag);
5880       goto message_done;
5881     }
5882     ptr = UnknownFieldParse(
5883         tag,
5884         _internal_metadata_.mutable_unknown_fields<std::string>(),
5885         ptr, ctx);
5886     CHK_(ptr != nullptr);
5887   }  // while
5888 message_done:
5889   _impl_._has_bits_.Or(has_bits);
5890   return ptr;
5891 failure:
5892   ptr = nullptr;
5893   goto message_done;
5894 #undef CHK_
5895 }
5896 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const5897 ::uint8_t* BlockRqRequeueFtraceEvent::_InternalSerialize(
5898     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
5899   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.BlockRqRequeueFtraceEvent)
5900   ::uint32_t cached_has_bits = 0;
5901   (void) cached_has_bits;
5902 
5903   cached_has_bits = _impl_._has_bits_[0];
5904   // optional uint64 dev = 1;
5905   if (cached_has_bits & 0x00000004u) {
5906     target = stream->EnsureSpace(target);
5907     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_dev(), target);
5908   }
5909 
5910   // optional uint64 sector = 2;
5911   if (cached_has_bits & 0x00000008u) {
5912     target = stream->EnsureSpace(target);
5913     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(2, this->_internal_sector(), target);
5914   }
5915 
5916   // optional uint32 nr_sector = 3;
5917   if (cached_has_bits & 0x00000010u) {
5918     target = stream->EnsureSpace(target);
5919     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_nr_sector(), target);
5920   }
5921 
5922   // optional int32 errors = 4;
5923   if (cached_has_bits & 0x00000020u) {
5924     target = stream->EnsureSpace(target);
5925     target = ::_pbi::WireFormatLite::WriteInt32ToArray(4, this->_internal_errors(), target);
5926   }
5927 
5928   // optional string rwbs = 5;
5929   if (cached_has_bits & 0x00000001u) {
5930     target = stream->WriteStringMaybeAliased(
5931         5, this->_internal_rwbs(), target);
5932   }
5933 
5934   // optional string cmd = 6;
5935   if (cached_has_bits & 0x00000002u) {
5936     target = stream->WriteStringMaybeAliased(
5937         6, this->_internal_cmd(), target);
5938   }
5939 
5940   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
5941     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
5942         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
5943   }
5944   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.BlockRqRequeueFtraceEvent)
5945   return target;
5946 }
5947 
ByteSizeLong() const5948 size_t BlockRqRequeueFtraceEvent::ByteSizeLong() const {
5949 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.BlockRqRequeueFtraceEvent)
5950   size_t total_size = 0;
5951 
5952   ::uint32_t cached_has_bits = 0;
5953   // Prevent compiler warnings about cached_has_bits being unused
5954   (void) cached_has_bits;
5955 
5956   cached_has_bits = _impl_._has_bits_[0];
5957   if (cached_has_bits & 0x0000003fu) {
5958     // optional string rwbs = 5;
5959     if (cached_has_bits & 0x00000001u) {
5960       total_size += 1 +
5961         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
5962           this->_internal_rwbs());
5963     }
5964 
5965     // optional string cmd = 6;
5966     if (cached_has_bits & 0x00000002u) {
5967       total_size += 1 +
5968         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
5969           this->_internal_cmd());
5970     }
5971 
5972     // optional uint64 dev = 1;
5973     if (cached_has_bits & 0x00000004u) {
5974       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_dev());
5975     }
5976 
5977     // optional uint64 sector = 2;
5978     if (cached_has_bits & 0x00000008u) {
5979       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_sector());
5980     }
5981 
5982     // optional uint32 nr_sector = 3;
5983     if (cached_has_bits & 0x00000010u) {
5984       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_nr_sector());
5985     }
5986 
5987     // optional int32 errors = 4;
5988     if (cached_has_bits & 0x00000020u) {
5989       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_errors());
5990     }
5991 
5992   }
5993   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
5994     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
5995   }
5996   int cached_size = ::_pbi::ToCachedSize(total_size);
5997   SetCachedSize(cached_size);
5998   return total_size;
5999 }
6000 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)6001 void BlockRqRequeueFtraceEvent::CheckTypeAndMergeFrom(
6002     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
6003   MergeFrom(*::_pbi::DownCast<const BlockRqRequeueFtraceEvent*>(
6004       &from));
6005 }
6006 
MergeFrom(const BlockRqRequeueFtraceEvent & from)6007 void BlockRqRequeueFtraceEvent::MergeFrom(const BlockRqRequeueFtraceEvent& from) {
6008   BlockRqRequeueFtraceEvent* const _this = this;
6009   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.BlockRqRequeueFtraceEvent)
6010   GOOGLE_DCHECK_NE(&from, _this);
6011   ::uint32_t cached_has_bits = 0;
6012   (void) cached_has_bits;
6013 
6014   cached_has_bits = from._impl_._has_bits_[0];
6015   if (cached_has_bits & 0x0000003fu) {
6016     if (cached_has_bits & 0x00000001u) {
6017       _this->_internal_set_rwbs(from._internal_rwbs());
6018     }
6019     if (cached_has_bits & 0x00000002u) {
6020       _this->_internal_set_cmd(from._internal_cmd());
6021     }
6022     if (cached_has_bits & 0x00000004u) {
6023       _this->_impl_.dev_ = from._impl_.dev_;
6024     }
6025     if (cached_has_bits & 0x00000008u) {
6026       _this->_impl_.sector_ = from._impl_.sector_;
6027     }
6028     if (cached_has_bits & 0x00000010u) {
6029       _this->_impl_.nr_sector_ = from._impl_.nr_sector_;
6030     }
6031     if (cached_has_bits & 0x00000020u) {
6032       _this->_impl_.errors_ = from._impl_.errors_;
6033     }
6034     _this->_impl_._has_bits_[0] |= cached_has_bits;
6035   }
6036   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
6037 }
6038 
CopyFrom(const BlockRqRequeueFtraceEvent & from)6039 void BlockRqRequeueFtraceEvent::CopyFrom(const BlockRqRequeueFtraceEvent& from) {
6040 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.BlockRqRequeueFtraceEvent)
6041   if (&from == this) return;
6042   Clear();
6043   MergeFrom(from);
6044 }
6045 
IsInitialized() const6046 bool BlockRqRequeueFtraceEvent::IsInitialized() const {
6047   return true;
6048 }
6049 
InternalSwap(BlockRqRequeueFtraceEvent * other)6050 void BlockRqRequeueFtraceEvent::InternalSwap(BlockRqRequeueFtraceEvent* other) {
6051   using std::swap;
6052   auto* lhs_arena = GetArenaForAllocation();
6053   auto* rhs_arena = other->GetArenaForAllocation();
6054   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
6055   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
6056   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
6057       &_impl_.rwbs_, lhs_arena,
6058       &other->_impl_.rwbs_, rhs_arena
6059   );
6060   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
6061       &_impl_.cmd_, lhs_arena,
6062       &other->_impl_.cmd_, rhs_arena
6063   );
6064   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
6065       PROTOBUF_FIELD_OFFSET(BlockRqRequeueFtraceEvent, _impl_.errors_)
6066       + sizeof(BlockRqRequeueFtraceEvent::_impl_.errors_)  // NOLINT
6067       - PROTOBUF_FIELD_OFFSET(BlockRqRequeueFtraceEvent, _impl_.dev_)>(
6068           reinterpret_cast<char*>(&_impl_.dev_),
6069           reinterpret_cast<char*>(&other->_impl_.dev_));
6070 }
6071 
GetTypeName() const6072 std::string BlockRqRequeueFtraceEvent::GetTypeName() const {
6073   return "perfetto.protos.BlockRqRequeueFtraceEvent";
6074 }
6075 
6076 
6077 // ===================================================================
6078 
6079 class BlockSleeprqFtraceEvent::_Internal {
6080  public:
6081   using HasBits = decltype(std::declval<BlockSleeprqFtraceEvent>()._impl_._has_bits_);
set_has_dev(HasBits * has_bits)6082   static void set_has_dev(HasBits* has_bits) {
6083     (*has_bits)[0] |= 4u;
6084   }
set_has_sector(HasBits * has_bits)6085   static void set_has_sector(HasBits* has_bits) {
6086     (*has_bits)[0] |= 8u;
6087   }
set_has_nr_sector(HasBits * has_bits)6088   static void set_has_nr_sector(HasBits* has_bits) {
6089     (*has_bits)[0] |= 16u;
6090   }
set_has_rwbs(HasBits * has_bits)6091   static void set_has_rwbs(HasBits* has_bits) {
6092     (*has_bits)[0] |= 1u;
6093   }
set_has_comm(HasBits * has_bits)6094   static void set_has_comm(HasBits* has_bits) {
6095     (*has_bits)[0] |= 2u;
6096   }
6097 };
6098 
BlockSleeprqFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)6099 BlockSleeprqFtraceEvent::BlockSleeprqFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
6100                          bool is_message_owned)
6101   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
6102   SharedCtor(arena, is_message_owned);
6103   // @@protoc_insertion_point(arena_constructor:perfetto.protos.BlockSleeprqFtraceEvent)
6104 }
BlockSleeprqFtraceEvent(const BlockSleeprqFtraceEvent & from)6105 BlockSleeprqFtraceEvent::BlockSleeprqFtraceEvent(const BlockSleeprqFtraceEvent& from)
6106   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
6107   BlockSleeprqFtraceEvent* const _this = this; (void)_this;
6108   new (&_impl_) Impl_{
6109       decltype(_impl_._has_bits_){from._impl_._has_bits_}
6110     , /*decltype(_impl_._cached_size_)*/{}
6111     , decltype(_impl_.rwbs_){}
6112     , decltype(_impl_.comm_){}
6113     , decltype(_impl_.dev_){}
6114     , decltype(_impl_.sector_){}
6115     , decltype(_impl_.nr_sector_){}};
6116 
6117   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
6118   _impl_.rwbs_.InitDefault();
6119   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
6120     _impl_.rwbs_.Set("", GetArenaForAllocation());
6121   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
6122   if (from._internal_has_rwbs()) {
6123     _this->_impl_.rwbs_.Set(from._internal_rwbs(),
6124       _this->GetArenaForAllocation());
6125   }
6126   _impl_.comm_.InitDefault();
6127   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
6128     _impl_.comm_.Set("", GetArenaForAllocation());
6129   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
6130   if (from._internal_has_comm()) {
6131     _this->_impl_.comm_.Set(from._internal_comm(),
6132       _this->GetArenaForAllocation());
6133   }
6134   ::memcpy(&_impl_.dev_, &from._impl_.dev_,
6135     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.nr_sector_) -
6136     reinterpret_cast<char*>(&_impl_.dev_)) + sizeof(_impl_.nr_sector_));
6137   // @@protoc_insertion_point(copy_constructor:perfetto.protos.BlockSleeprqFtraceEvent)
6138 }
6139 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)6140 inline void BlockSleeprqFtraceEvent::SharedCtor(
6141     ::_pb::Arena* arena, bool is_message_owned) {
6142   (void)arena;
6143   (void)is_message_owned;
6144   new (&_impl_) Impl_{
6145       decltype(_impl_._has_bits_){}
6146     , /*decltype(_impl_._cached_size_)*/{}
6147     , decltype(_impl_.rwbs_){}
6148     , decltype(_impl_.comm_){}
6149     , decltype(_impl_.dev_){::uint64_t{0u}}
6150     , decltype(_impl_.sector_){::uint64_t{0u}}
6151     , decltype(_impl_.nr_sector_){0u}
6152   };
6153   _impl_.rwbs_.InitDefault();
6154   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
6155     _impl_.rwbs_.Set("", GetArenaForAllocation());
6156   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
6157   _impl_.comm_.InitDefault();
6158   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
6159     _impl_.comm_.Set("", GetArenaForAllocation());
6160   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
6161 }
6162 
~BlockSleeprqFtraceEvent()6163 BlockSleeprqFtraceEvent::~BlockSleeprqFtraceEvent() {
6164   // @@protoc_insertion_point(destructor:perfetto.protos.BlockSleeprqFtraceEvent)
6165   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
6166   (void)arena;
6167     return;
6168   }
6169   SharedDtor();
6170 }
6171 
SharedDtor()6172 inline void BlockSleeprqFtraceEvent::SharedDtor() {
6173   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
6174   _impl_.rwbs_.Destroy();
6175   _impl_.comm_.Destroy();
6176 }
6177 
SetCachedSize(int size) const6178 void BlockSleeprqFtraceEvent::SetCachedSize(int size) const {
6179   _impl_._cached_size_.Set(size);
6180 }
6181 
Clear()6182 void BlockSleeprqFtraceEvent::Clear() {
6183 // @@protoc_insertion_point(message_clear_start:perfetto.protos.BlockSleeprqFtraceEvent)
6184   ::uint32_t cached_has_bits = 0;
6185   // Prevent compiler warnings about cached_has_bits being unused
6186   (void) cached_has_bits;
6187 
6188   cached_has_bits = _impl_._has_bits_[0];
6189   if (cached_has_bits & 0x00000003u) {
6190     if (cached_has_bits & 0x00000001u) {
6191       _impl_.rwbs_.ClearNonDefaultToEmpty();
6192     }
6193     if (cached_has_bits & 0x00000002u) {
6194       _impl_.comm_.ClearNonDefaultToEmpty();
6195     }
6196   }
6197   if (cached_has_bits & 0x0000001cu) {
6198     ::memset(&_impl_.dev_, 0, static_cast<size_t>(
6199         reinterpret_cast<char*>(&_impl_.nr_sector_) -
6200         reinterpret_cast<char*>(&_impl_.dev_)) + sizeof(_impl_.nr_sector_));
6201   }
6202   _impl_._has_bits_.Clear();
6203   _internal_metadata_.Clear<std::string>();
6204 }
6205 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)6206 const char* BlockSleeprqFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
6207 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
6208   _Internal::HasBits has_bits{};
6209   while (!ctx->Done(&ptr)) {
6210     ::uint32_t tag;
6211     ptr = ::_pbi::ReadTag(ptr, &tag);
6212     switch (tag >> 3) {
6213       // optional uint64 dev = 1;
6214       case 1:
6215         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
6216           _Internal::set_has_dev(&has_bits);
6217           _impl_.dev_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
6218           CHK_(ptr);
6219         } else {
6220           goto handle_unusual;
6221         }
6222         continue;
6223       // optional uint64 sector = 2;
6224       case 2:
6225         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
6226           _Internal::set_has_sector(&has_bits);
6227           _impl_.sector_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
6228           CHK_(ptr);
6229         } else {
6230           goto handle_unusual;
6231         }
6232         continue;
6233       // optional uint32 nr_sector = 3;
6234       case 3:
6235         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
6236           _Internal::set_has_nr_sector(&has_bits);
6237           _impl_.nr_sector_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
6238           CHK_(ptr);
6239         } else {
6240           goto handle_unusual;
6241         }
6242         continue;
6243       // optional string rwbs = 4;
6244       case 4:
6245         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
6246           auto str = _internal_mutable_rwbs();
6247           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
6248           CHK_(ptr);
6249         } else {
6250           goto handle_unusual;
6251         }
6252         continue;
6253       // optional string comm = 5;
6254       case 5:
6255         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 42)) {
6256           auto str = _internal_mutable_comm();
6257           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
6258           CHK_(ptr);
6259         } else {
6260           goto handle_unusual;
6261         }
6262         continue;
6263       default:
6264         goto handle_unusual;
6265     }  // switch
6266   handle_unusual:
6267     if ((tag == 0) || ((tag & 7) == 4)) {
6268       CHK_(ptr);
6269       ctx->SetLastTag(tag);
6270       goto message_done;
6271     }
6272     ptr = UnknownFieldParse(
6273         tag,
6274         _internal_metadata_.mutable_unknown_fields<std::string>(),
6275         ptr, ctx);
6276     CHK_(ptr != nullptr);
6277   }  // while
6278 message_done:
6279   _impl_._has_bits_.Or(has_bits);
6280   return ptr;
6281 failure:
6282   ptr = nullptr;
6283   goto message_done;
6284 #undef CHK_
6285 }
6286 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const6287 ::uint8_t* BlockSleeprqFtraceEvent::_InternalSerialize(
6288     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
6289   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.BlockSleeprqFtraceEvent)
6290   ::uint32_t cached_has_bits = 0;
6291   (void) cached_has_bits;
6292 
6293   cached_has_bits = _impl_._has_bits_[0];
6294   // optional uint64 dev = 1;
6295   if (cached_has_bits & 0x00000004u) {
6296     target = stream->EnsureSpace(target);
6297     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_dev(), target);
6298   }
6299 
6300   // optional uint64 sector = 2;
6301   if (cached_has_bits & 0x00000008u) {
6302     target = stream->EnsureSpace(target);
6303     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(2, this->_internal_sector(), target);
6304   }
6305 
6306   // optional uint32 nr_sector = 3;
6307   if (cached_has_bits & 0x00000010u) {
6308     target = stream->EnsureSpace(target);
6309     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_nr_sector(), target);
6310   }
6311 
6312   // optional string rwbs = 4;
6313   if (cached_has_bits & 0x00000001u) {
6314     target = stream->WriteStringMaybeAliased(
6315         4, this->_internal_rwbs(), target);
6316   }
6317 
6318   // optional string comm = 5;
6319   if (cached_has_bits & 0x00000002u) {
6320     target = stream->WriteStringMaybeAliased(
6321         5, this->_internal_comm(), target);
6322   }
6323 
6324   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
6325     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
6326         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
6327   }
6328   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.BlockSleeprqFtraceEvent)
6329   return target;
6330 }
6331 
ByteSizeLong() const6332 size_t BlockSleeprqFtraceEvent::ByteSizeLong() const {
6333 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.BlockSleeprqFtraceEvent)
6334   size_t total_size = 0;
6335 
6336   ::uint32_t cached_has_bits = 0;
6337   // Prevent compiler warnings about cached_has_bits being unused
6338   (void) cached_has_bits;
6339 
6340   cached_has_bits = _impl_._has_bits_[0];
6341   if (cached_has_bits & 0x0000001fu) {
6342     // optional string rwbs = 4;
6343     if (cached_has_bits & 0x00000001u) {
6344       total_size += 1 +
6345         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
6346           this->_internal_rwbs());
6347     }
6348 
6349     // optional string comm = 5;
6350     if (cached_has_bits & 0x00000002u) {
6351       total_size += 1 +
6352         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
6353           this->_internal_comm());
6354     }
6355 
6356     // optional uint64 dev = 1;
6357     if (cached_has_bits & 0x00000004u) {
6358       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_dev());
6359     }
6360 
6361     // optional uint64 sector = 2;
6362     if (cached_has_bits & 0x00000008u) {
6363       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_sector());
6364     }
6365 
6366     // optional uint32 nr_sector = 3;
6367     if (cached_has_bits & 0x00000010u) {
6368       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_nr_sector());
6369     }
6370 
6371   }
6372   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
6373     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
6374   }
6375   int cached_size = ::_pbi::ToCachedSize(total_size);
6376   SetCachedSize(cached_size);
6377   return total_size;
6378 }
6379 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)6380 void BlockSleeprqFtraceEvent::CheckTypeAndMergeFrom(
6381     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
6382   MergeFrom(*::_pbi::DownCast<const BlockSleeprqFtraceEvent*>(
6383       &from));
6384 }
6385 
MergeFrom(const BlockSleeprqFtraceEvent & from)6386 void BlockSleeprqFtraceEvent::MergeFrom(const BlockSleeprqFtraceEvent& from) {
6387   BlockSleeprqFtraceEvent* const _this = this;
6388   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.BlockSleeprqFtraceEvent)
6389   GOOGLE_DCHECK_NE(&from, _this);
6390   ::uint32_t cached_has_bits = 0;
6391   (void) cached_has_bits;
6392 
6393   cached_has_bits = from._impl_._has_bits_[0];
6394   if (cached_has_bits & 0x0000001fu) {
6395     if (cached_has_bits & 0x00000001u) {
6396       _this->_internal_set_rwbs(from._internal_rwbs());
6397     }
6398     if (cached_has_bits & 0x00000002u) {
6399       _this->_internal_set_comm(from._internal_comm());
6400     }
6401     if (cached_has_bits & 0x00000004u) {
6402       _this->_impl_.dev_ = from._impl_.dev_;
6403     }
6404     if (cached_has_bits & 0x00000008u) {
6405       _this->_impl_.sector_ = from._impl_.sector_;
6406     }
6407     if (cached_has_bits & 0x00000010u) {
6408       _this->_impl_.nr_sector_ = from._impl_.nr_sector_;
6409     }
6410     _this->_impl_._has_bits_[0] |= cached_has_bits;
6411   }
6412   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
6413 }
6414 
CopyFrom(const BlockSleeprqFtraceEvent & from)6415 void BlockSleeprqFtraceEvent::CopyFrom(const BlockSleeprqFtraceEvent& from) {
6416 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.BlockSleeprqFtraceEvent)
6417   if (&from == this) return;
6418   Clear();
6419   MergeFrom(from);
6420 }
6421 
IsInitialized() const6422 bool BlockSleeprqFtraceEvent::IsInitialized() const {
6423   return true;
6424 }
6425 
InternalSwap(BlockSleeprqFtraceEvent * other)6426 void BlockSleeprqFtraceEvent::InternalSwap(BlockSleeprqFtraceEvent* other) {
6427   using std::swap;
6428   auto* lhs_arena = GetArenaForAllocation();
6429   auto* rhs_arena = other->GetArenaForAllocation();
6430   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
6431   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
6432   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
6433       &_impl_.rwbs_, lhs_arena,
6434       &other->_impl_.rwbs_, rhs_arena
6435   );
6436   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
6437       &_impl_.comm_, lhs_arena,
6438       &other->_impl_.comm_, rhs_arena
6439   );
6440   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
6441       PROTOBUF_FIELD_OFFSET(BlockSleeprqFtraceEvent, _impl_.nr_sector_)
6442       + sizeof(BlockSleeprqFtraceEvent::_impl_.nr_sector_)  // NOLINT
6443       - PROTOBUF_FIELD_OFFSET(BlockSleeprqFtraceEvent, _impl_.dev_)>(
6444           reinterpret_cast<char*>(&_impl_.dev_),
6445           reinterpret_cast<char*>(&other->_impl_.dev_));
6446 }
6447 
GetTypeName() const6448 std::string BlockSleeprqFtraceEvent::GetTypeName() const {
6449   return "perfetto.protos.BlockSleeprqFtraceEvent";
6450 }
6451 
6452 
6453 // ===================================================================
6454 
6455 class BlockSplitFtraceEvent::_Internal {
6456  public:
6457   using HasBits = decltype(std::declval<BlockSplitFtraceEvent>()._impl_._has_bits_);
set_has_dev(HasBits * has_bits)6458   static void set_has_dev(HasBits* has_bits) {
6459     (*has_bits)[0] |= 4u;
6460   }
set_has_sector(HasBits * has_bits)6461   static void set_has_sector(HasBits* has_bits) {
6462     (*has_bits)[0] |= 8u;
6463   }
set_has_new_sector(HasBits * has_bits)6464   static void set_has_new_sector(HasBits* has_bits) {
6465     (*has_bits)[0] |= 16u;
6466   }
set_has_rwbs(HasBits * has_bits)6467   static void set_has_rwbs(HasBits* has_bits) {
6468     (*has_bits)[0] |= 1u;
6469   }
set_has_comm(HasBits * has_bits)6470   static void set_has_comm(HasBits* has_bits) {
6471     (*has_bits)[0] |= 2u;
6472   }
6473 };
6474 
BlockSplitFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)6475 BlockSplitFtraceEvent::BlockSplitFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
6476                          bool is_message_owned)
6477   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
6478   SharedCtor(arena, is_message_owned);
6479   // @@protoc_insertion_point(arena_constructor:perfetto.protos.BlockSplitFtraceEvent)
6480 }
BlockSplitFtraceEvent(const BlockSplitFtraceEvent & from)6481 BlockSplitFtraceEvent::BlockSplitFtraceEvent(const BlockSplitFtraceEvent& from)
6482   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
6483   BlockSplitFtraceEvent* const _this = this; (void)_this;
6484   new (&_impl_) Impl_{
6485       decltype(_impl_._has_bits_){from._impl_._has_bits_}
6486     , /*decltype(_impl_._cached_size_)*/{}
6487     , decltype(_impl_.rwbs_){}
6488     , decltype(_impl_.comm_){}
6489     , decltype(_impl_.dev_){}
6490     , decltype(_impl_.sector_){}
6491     , decltype(_impl_.new_sector_){}};
6492 
6493   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
6494   _impl_.rwbs_.InitDefault();
6495   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
6496     _impl_.rwbs_.Set("", GetArenaForAllocation());
6497   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
6498   if (from._internal_has_rwbs()) {
6499     _this->_impl_.rwbs_.Set(from._internal_rwbs(),
6500       _this->GetArenaForAllocation());
6501   }
6502   _impl_.comm_.InitDefault();
6503   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
6504     _impl_.comm_.Set("", GetArenaForAllocation());
6505   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
6506   if (from._internal_has_comm()) {
6507     _this->_impl_.comm_.Set(from._internal_comm(),
6508       _this->GetArenaForAllocation());
6509   }
6510   ::memcpy(&_impl_.dev_, &from._impl_.dev_,
6511     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.new_sector_) -
6512     reinterpret_cast<char*>(&_impl_.dev_)) + sizeof(_impl_.new_sector_));
6513   // @@protoc_insertion_point(copy_constructor:perfetto.protos.BlockSplitFtraceEvent)
6514 }
6515 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)6516 inline void BlockSplitFtraceEvent::SharedCtor(
6517     ::_pb::Arena* arena, bool is_message_owned) {
6518   (void)arena;
6519   (void)is_message_owned;
6520   new (&_impl_) Impl_{
6521       decltype(_impl_._has_bits_){}
6522     , /*decltype(_impl_._cached_size_)*/{}
6523     , decltype(_impl_.rwbs_){}
6524     , decltype(_impl_.comm_){}
6525     , decltype(_impl_.dev_){::uint64_t{0u}}
6526     , decltype(_impl_.sector_){::uint64_t{0u}}
6527     , decltype(_impl_.new_sector_){::uint64_t{0u}}
6528   };
6529   _impl_.rwbs_.InitDefault();
6530   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
6531     _impl_.rwbs_.Set("", GetArenaForAllocation());
6532   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
6533   _impl_.comm_.InitDefault();
6534   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
6535     _impl_.comm_.Set("", GetArenaForAllocation());
6536   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
6537 }
6538 
~BlockSplitFtraceEvent()6539 BlockSplitFtraceEvent::~BlockSplitFtraceEvent() {
6540   // @@protoc_insertion_point(destructor:perfetto.protos.BlockSplitFtraceEvent)
6541   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
6542   (void)arena;
6543     return;
6544   }
6545   SharedDtor();
6546 }
6547 
SharedDtor()6548 inline void BlockSplitFtraceEvent::SharedDtor() {
6549   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
6550   _impl_.rwbs_.Destroy();
6551   _impl_.comm_.Destroy();
6552 }
6553 
SetCachedSize(int size) const6554 void BlockSplitFtraceEvent::SetCachedSize(int size) const {
6555   _impl_._cached_size_.Set(size);
6556 }
6557 
Clear()6558 void BlockSplitFtraceEvent::Clear() {
6559 // @@protoc_insertion_point(message_clear_start:perfetto.protos.BlockSplitFtraceEvent)
6560   ::uint32_t cached_has_bits = 0;
6561   // Prevent compiler warnings about cached_has_bits being unused
6562   (void) cached_has_bits;
6563 
6564   cached_has_bits = _impl_._has_bits_[0];
6565   if (cached_has_bits & 0x00000003u) {
6566     if (cached_has_bits & 0x00000001u) {
6567       _impl_.rwbs_.ClearNonDefaultToEmpty();
6568     }
6569     if (cached_has_bits & 0x00000002u) {
6570       _impl_.comm_.ClearNonDefaultToEmpty();
6571     }
6572   }
6573   if (cached_has_bits & 0x0000001cu) {
6574     ::memset(&_impl_.dev_, 0, static_cast<size_t>(
6575         reinterpret_cast<char*>(&_impl_.new_sector_) -
6576         reinterpret_cast<char*>(&_impl_.dev_)) + sizeof(_impl_.new_sector_));
6577   }
6578   _impl_._has_bits_.Clear();
6579   _internal_metadata_.Clear<std::string>();
6580 }
6581 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)6582 const char* BlockSplitFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
6583 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
6584   _Internal::HasBits has_bits{};
6585   while (!ctx->Done(&ptr)) {
6586     ::uint32_t tag;
6587     ptr = ::_pbi::ReadTag(ptr, &tag);
6588     switch (tag >> 3) {
6589       // optional uint64 dev = 1;
6590       case 1:
6591         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
6592           _Internal::set_has_dev(&has_bits);
6593           _impl_.dev_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
6594           CHK_(ptr);
6595         } else {
6596           goto handle_unusual;
6597         }
6598         continue;
6599       // optional uint64 sector = 2;
6600       case 2:
6601         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
6602           _Internal::set_has_sector(&has_bits);
6603           _impl_.sector_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
6604           CHK_(ptr);
6605         } else {
6606           goto handle_unusual;
6607         }
6608         continue;
6609       // optional uint64 new_sector = 3;
6610       case 3:
6611         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
6612           _Internal::set_has_new_sector(&has_bits);
6613           _impl_.new_sector_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
6614           CHK_(ptr);
6615         } else {
6616           goto handle_unusual;
6617         }
6618         continue;
6619       // optional string rwbs = 4;
6620       case 4:
6621         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
6622           auto str = _internal_mutable_rwbs();
6623           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
6624           CHK_(ptr);
6625         } else {
6626           goto handle_unusual;
6627         }
6628         continue;
6629       // optional string comm = 5;
6630       case 5:
6631         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 42)) {
6632           auto str = _internal_mutable_comm();
6633           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
6634           CHK_(ptr);
6635         } else {
6636           goto handle_unusual;
6637         }
6638         continue;
6639       default:
6640         goto handle_unusual;
6641     }  // switch
6642   handle_unusual:
6643     if ((tag == 0) || ((tag & 7) == 4)) {
6644       CHK_(ptr);
6645       ctx->SetLastTag(tag);
6646       goto message_done;
6647     }
6648     ptr = UnknownFieldParse(
6649         tag,
6650         _internal_metadata_.mutable_unknown_fields<std::string>(),
6651         ptr, ctx);
6652     CHK_(ptr != nullptr);
6653   }  // while
6654 message_done:
6655   _impl_._has_bits_.Or(has_bits);
6656   return ptr;
6657 failure:
6658   ptr = nullptr;
6659   goto message_done;
6660 #undef CHK_
6661 }
6662 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const6663 ::uint8_t* BlockSplitFtraceEvent::_InternalSerialize(
6664     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
6665   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.BlockSplitFtraceEvent)
6666   ::uint32_t cached_has_bits = 0;
6667   (void) cached_has_bits;
6668 
6669   cached_has_bits = _impl_._has_bits_[0];
6670   // optional uint64 dev = 1;
6671   if (cached_has_bits & 0x00000004u) {
6672     target = stream->EnsureSpace(target);
6673     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_dev(), target);
6674   }
6675 
6676   // optional uint64 sector = 2;
6677   if (cached_has_bits & 0x00000008u) {
6678     target = stream->EnsureSpace(target);
6679     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(2, this->_internal_sector(), target);
6680   }
6681 
6682   // optional uint64 new_sector = 3;
6683   if (cached_has_bits & 0x00000010u) {
6684     target = stream->EnsureSpace(target);
6685     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(3, this->_internal_new_sector(), target);
6686   }
6687 
6688   // optional string rwbs = 4;
6689   if (cached_has_bits & 0x00000001u) {
6690     target = stream->WriteStringMaybeAliased(
6691         4, this->_internal_rwbs(), target);
6692   }
6693 
6694   // optional string comm = 5;
6695   if (cached_has_bits & 0x00000002u) {
6696     target = stream->WriteStringMaybeAliased(
6697         5, this->_internal_comm(), target);
6698   }
6699 
6700   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
6701     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
6702         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
6703   }
6704   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.BlockSplitFtraceEvent)
6705   return target;
6706 }
6707 
ByteSizeLong() const6708 size_t BlockSplitFtraceEvent::ByteSizeLong() const {
6709 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.BlockSplitFtraceEvent)
6710   size_t total_size = 0;
6711 
6712   ::uint32_t cached_has_bits = 0;
6713   // Prevent compiler warnings about cached_has_bits being unused
6714   (void) cached_has_bits;
6715 
6716   cached_has_bits = _impl_._has_bits_[0];
6717   if (cached_has_bits & 0x0000001fu) {
6718     // optional string rwbs = 4;
6719     if (cached_has_bits & 0x00000001u) {
6720       total_size += 1 +
6721         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
6722           this->_internal_rwbs());
6723     }
6724 
6725     // optional string comm = 5;
6726     if (cached_has_bits & 0x00000002u) {
6727       total_size += 1 +
6728         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
6729           this->_internal_comm());
6730     }
6731 
6732     // optional uint64 dev = 1;
6733     if (cached_has_bits & 0x00000004u) {
6734       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_dev());
6735     }
6736 
6737     // optional uint64 sector = 2;
6738     if (cached_has_bits & 0x00000008u) {
6739       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_sector());
6740     }
6741 
6742     // optional uint64 new_sector = 3;
6743     if (cached_has_bits & 0x00000010u) {
6744       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_new_sector());
6745     }
6746 
6747   }
6748   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
6749     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
6750   }
6751   int cached_size = ::_pbi::ToCachedSize(total_size);
6752   SetCachedSize(cached_size);
6753   return total_size;
6754 }
6755 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)6756 void BlockSplitFtraceEvent::CheckTypeAndMergeFrom(
6757     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
6758   MergeFrom(*::_pbi::DownCast<const BlockSplitFtraceEvent*>(
6759       &from));
6760 }
6761 
MergeFrom(const BlockSplitFtraceEvent & from)6762 void BlockSplitFtraceEvent::MergeFrom(const BlockSplitFtraceEvent& from) {
6763   BlockSplitFtraceEvent* const _this = this;
6764   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.BlockSplitFtraceEvent)
6765   GOOGLE_DCHECK_NE(&from, _this);
6766   ::uint32_t cached_has_bits = 0;
6767   (void) cached_has_bits;
6768 
6769   cached_has_bits = from._impl_._has_bits_[0];
6770   if (cached_has_bits & 0x0000001fu) {
6771     if (cached_has_bits & 0x00000001u) {
6772       _this->_internal_set_rwbs(from._internal_rwbs());
6773     }
6774     if (cached_has_bits & 0x00000002u) {
6775       _this->_internal_set_comm(from._internal_comm());
6776     }
6777     if (cached_has_bits & 0x00000004u) {
6778       _this->_impl_.dev_ = from._impl_.dev_;
6779     }
6780     if (cached_has_bits & 0x00000008u) {
6781       _this->_impl_.sector_ = from._impl_.sector_;
6782     }
6783     if (cached_has_bits & 0x00000010u) {
6784       _this->_impl_.new_sector_ = from._impl_.new_sector_;
6785     }
6786     _this->_impl_._has_bits_[0] |= cached_has_bits;
6787   }
6788   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
6789 }
6790 
CopyFrom(const BlockSplitFtraceEvent & from)6791 void BlockSplitFtraceEvent::CopyFrom(const BlockSplitFtraceEvent& from) {
6792 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.BlockSplitFtraceEvent)
6793   if (&from == this) return;
6794   Clear();
6795   MergeFrom(from);
6796 }
6797 
IsInitialized() const6798 bool BlockSplitFtraceEvent::IsInitialized() const {
6799   return true;
6800 }
6801 
InternalSwap(BlockSplitFtraceEvent * other)6802 void BlockSplitFtraceEvent::InternalSwap(BlockSplitFtraceEvent* other) {
6803   using std::swap;
6804   auto* lhs_arena = GetArenaForAllocation();
6805   auto* rhs_arena = other->GetArenaForAllocation();
6806   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
6807   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
6808   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
6809       &_impl_.rwbs_, lhs_arena,
6810       &other->_impl_.rwbs_, rhs_arena
6811   );
6812   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
6813       &_impl_.comm_, lhs_arena,
6814       &other->_impl_.comm_, rhs_arena
6815   );
6816   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
6817       PROTOBUF_FIELD_OFFSET(BlockSplitFtraceEvent, _impl_.new_sector_)
6818       + sizeof(BlockSplitFtraceEvent::_impl_.new_sector_)  // NOLINT
6819       - PROTOBUF_FIELD_OFFSET(BlockSplitFtraceEvent, _impl_.dev_)>(
6820           reinterpret_cast<char*>(&_impl_.dev_),
6821           reinterpret_cast<char*>(&other->_impl_.dev_));
6822 }
6823 
GetTypeName() const6824 std::string BlockSplitFtraceEvent::GetTypeName() const {
6825   return "perfetto.protos.BlockSplitFtraceEvent";
6826 }
6827 
6828 
6829 // ===================================================================
6830 
6831 class BlockTouchBufferFtraceEvent::_Internal {
6832  public:
6833   using HasBits = decltype(std::declval<BlockTouchBufferFtraceEvent>()._impl_._has_bits_);
set_has_dev(HasBits * has_bits)6834   static void set_has_dev(HasBits* has_bits) {
6835     (*has_bits)[0] |= 1u;
6836   }
set_has_sector(HasBits * has_bits)6837   static void set_has_sector(HasBits* has_bits) {
6838     (*has_bits)[0] |= 2u;
6839   }
set_has_size(HasBits * has_bits)6840   static void set_has_size(HasBits* has_bits) {
6841     (*has_bits)[0] |= 4u;
6842   }
6843 };
6844 
BlockTouchBufferFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)6845 BlockTouchBufferFtraceEvent::BlockTouchBufferFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
6846                          bool is_message_owned)
6847   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
6848   SharedCtor(arena, is_message_owned);
6849   // @@protoc_insertion_point(arena_constructor:perfetto.protos.BlockTouchBufferFtraceEvent)
6850 }
BlockTouchBufferFtraceEvent(const BlockTouchBufferFtraceEvent & from)6851 BlockTouchBufferFtraceEvent::BlockTouchBufferFtraceEvent(const BlockTouchBufferFtraceEvent& from)
6852   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
6853   BlockTouchBufferFtraceEvent* const _this = this; (void)_this;
6854   new (&_impl_) Impl_{
6855       decltype(_impl_._has_bits_){from._impl_._has_bits_}
6856     , /*decltype(_impl_._cached_size_)*/{}
6857     , decltype(_impl_.dev_){}
6858     , decltype(_impl_.sector_){}
6859     , decltype(_impl_.size_){}};
6860 
6861   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
6862   ::memcpy(&_impl_.dev_, &from._impl_.dev_,
6863     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.size_) -
6864     reinterpret_cast<char*>(&_impl_.dev_)) + sizeof(_impl_.size_));
6865   // @@protoc_insertion_point(copy_constructor:perfetto.protos.BlockTouchBufferFtraceEvent)
6866 }
6867 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)6868 inline void BlockTouchBufferFtraceEvent::SharedCtor(
6869     ::_pb::Arena* arena, bool is_message_owned) {
6870   (void)arena;
6871   (void)is_message_owned;
6872   new (&_impl_) Impl_{
6873       decltype(_impl_._has_bits_){}
6874     , /*decltype(_impl_._cached_size_)*/{}
6875     , decltype(_impl_.dev_){::uint64_t{0u}}
6876     , decltype(_impl_.sector_){::uint64_t{0u}}
6877     , decltype(_impl_.size_){::uint64_t{0u}}
6878   };
6879 }
6880 
~BlockTouchBufferFtraceEvent()6881 BlockTouchBufferFtraceEvent::~BlockTouchBufferFtraceEvent() {
6882   // @@protoc_insertion_point(destructor:perfetto.protos.BlockTouchBufferFtraceEvent)
6883   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
6884   (void)arena;
6885     return;
6886   }
6887   SharedDtor();
6888 }
6889 
SharedDtor()6890 inline void BlockTouchBufferFtraceEvent::SharedDtor() {
6891   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
6892 }
6893 
SetCachedSize(int size) const6894 void BlockTouchBufferFtraceEvent::SetCachedSize(int size) const {
6895   _impl_._cached_size_.Set(size);
6896 }
6897 
Clear()6898 void BlockTouchBufferFtraceEvent::Clear() {
6899 // @@protoc_insertion_point(message_clear_start:perfetto.protos.BlockTouchBufferFtraceEvent)
6900   ::uint32_t cached_has_bits = 0;
6901   // Prevent compiler warnings about cached_has_bits being unused
6902   (void) cached_has_bits;
6903 
6904   cached_has_bits = _impl_._has_bits_[0];
6905   if (cached_has_bits & 0x00000007u) {
6906     ::memset(&_impl_.dev_, 0, static_cast<size_t>(
6907         reinterpret_cast<char*>(&_impl_.size_) -
6908         reinterpret_cast<char*>(&_impl_.dev_)) + sizeof(_impl_.size_));
6909   }
6910   _impl_._has_bits_.Clear();
6911   _internal_metadata_.Clear<std::string>();
6912 }
6913 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)6914 const char* BlockTouchBufferFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
6915 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
6916   _Internal::HasBits has_bits{};
6917   while (!ctx->Done(&ptr)) {
6918     ::uint32_t tag;
6919     ptr = ::_pbi::ReadTag(ptr, &tag);
6920     switch (tag >> 3) {
6921       // optional uint64 dev = 1;
6922       case 1:
6923         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
6924           _Internal::set_has_dev(&has_bits);
6925           _impl_.dev_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
6926           CHK_(ptr);
6927         } else {
6928           goto handle_unusual;
6929         }
6930         continue;
6931       // optional uint64 sector = 2;
6932       case 2:
6933         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
6934           _Internal::set_has_sector(&has_bits);
6935           _impl_.sector_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
6936           CHK_(ptr);
6937         } else {
6938           goto handle_unusual;
6939         }
6940         continue;
6941       // optional uint64 size = 3;
6942       case 3:
6943         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
6944           _Internal::set_has_size(&has_bits);
6945           _impl_.size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
6946           CHK_(ptr);
6947         } else {
6948           goto handle_unusual;
6949         }
6950         continue;
6951       default:
6952         goto handle_unusual;
6953     }  // switch
6954   handle_unusual:
6955     if ((tag == 0) || ((tag & 7) == 4)) {
6956       CHK_(ptr);
6957       ctx->SetLastTag(tag);
6958       goto message_done;
6959     }
6960     ptr = UnknownFieldParse(
6961         tag,
6962         _internal_metadata_.mutable_unknown_fields<std::string>(),
6963         ptr, ctx);
6964     CHK_(ptr != nullptr);
6965   }  // while
6966 message_done:
6967   _impl_._has_bits_.Or(has_bits);
6968   return ptr;
6969 failure:
6970   ptr = nullptr;
6971   goto message_done;
6972 #undef CHK_
6973 }
6974 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const6975 ::uint8_t* BlockTouchBufferFtraceEvent::_InternalSerialize(
6976     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
6977   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.BlockTouchBufferFtraceEvent)
6978   ::uint32_t cached_has_bits = 0;
6979   (void) cached_has_bits;
6980 
6981   cached_has_bits = _impl_._has_bits_[0];
6982   // optional uint64 dev = 1;
6983   if (cached_has_bits & 0x00000001u) {
6984     target = stream->EnsureSpace(target);
6985     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_dev(), target);
6986   }
6987 
6988   // optional uint64 sector = 2;
6989   if (cached_has_bits & 0x00000002u) {
6990     target = stream->EnsureSpace(target);
6991     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(2, this->_internal_sector(), target);
6992   }
6993 
6994   // optional uint64 size = 3;
6995   if (cached_has_bits & 0x00000004u) {
6996     target = stream->EnsureSpace(target);
6997     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(3, this->_internal_size(), target);
6998   }
6999 
7000   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
7001     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
7002         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
7003   }
7004   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.BlockTouchBufferFtraceEvent)
7005   return target;
7006 }
7007 
ByteSizeLong() const7008 size_t BlockTouchBufferFtraceEvent::ByteSizeLong() const {
7009 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.BlockTouchBufferFtraceEvent)
7010   size_t total_size = 0;
7011 
7012   ::uint32_t cached_has_bits = 0;
7013   // Prevent compiler warnings about cached_has_bits being unused
7014   (void) cached_has_bits;
7015 
7016   cached_has_bits = _impl_._has_bits_[0];
7017   if (cached_has_bits & 0x00000007u) {
7018     // optional uint64 dev = 1;
7019     if (cached_has_bits & 0x00000001u) {
7020       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_dev());
7021     }
7022 
7023     // optional uint64 sector = 2;
7024     if (cached_has_bits & 0x00000002u) {
7025       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_sector());
7026     }
7027 
7028     // optional uint64 size = 3;
7029     if (cached_has_bits & 0x00000004u) {
7030       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_size());
7031     }
7032 
7033   }
7034   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
7035     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
7036   }
7037   int cached_size = ::_pbi::ToCachedSize(total_size);
7038   SetCachedSize(cached_size);
7039   return total_size;
7040 }
7041 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)7042 void BlockTouchBufferFtraceEvent::CheckTypeAndMergeFrom(
7043     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
7044   MergeFrom(*::_pbi::DownCast<const BlockTouchBufferFtraceEvent*>(
7045       &from));
7046 }
7047 
MergeFrom(const BlockTouchBufferFtraceEvent & from)7048 void BlockTouchBufferFtraceEvent::MergeFrom(const BlockTouchBufferFtraceEvent& from) {
7049   BlockTouchBufferFtraceEvent* const _this = this;
7050   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.BlockTouchBufferFtraceEvent)
7051   GOOGLE_DCHECK_NE(&from, _this);
7052   ::uint32_t cached_has_bits = 0;
7053   (void) cached_has_bits;
7054 
7055   cached_has_bits = from._impl_._has_bits_[0];
7056   if (cached_has_bits & 0x00000007u) {
7057     if (cached_has_bits & 0x00000001u) {
7058       _this->_impl_.dev_ = from._impl_.dev_;
7059     }
7060     if (cached_has_bits & 0x00000002u) {
7061       _this->_impl_.sector_ = from._impl_.sector_;
7062     }
7063     if (cached_has_bits & 0x00000004u) {
7064       _this->_impl_.size_ = from._impl_.size_;
7065     }
7066     _this->_impl_._has_bits_[0] |= cached_has_bits;
7067   }
7068   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
7069 }
7070 
CopyFrom(const BlockTouchBufferFtraceEvent & from)7071 void BlockTouchBufferFtraceEvent::CopyFrom(const BlockTouchBufferFtraceEvent& from) {
7072 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.BlockTouchBufferFtraceEvent)
7073   if (&from == this) return;
7074   Clear();
7075   MergeFrom(from);
7076 }
7077 
IsInitialized() const7078 bool BlockTouchBufferFtraceEvent::IsInitialized() const {
7079   return true;
7080 }
7081 
InternalSwap(BlockTouchBufferFtraceEvent * other)7082 void BlockTouchBufferFtraceEvent::InternalSwap(BlockTouchBufferFtraceEvent* other) {
7083   using std::swap;
7084   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
7085   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
7086   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
7087       PROTOBUF_FIELD_OFFSET(BlockTouchBufferFtraceEvent, _impl_.size_)
7088       + sizeof(BlockTouchBufferFtraceEvent::_impl_.size_)  // NOLINT
7089       - PROTOBUF_FIELD_OFFSET(BlockTouchBufferFtraceEvent, _impl_.dev_)>(
7090           reinterpret_cast<char*>(&_impl_.dev_),
7091           reinterpret_cast<char*>(&other->_impl_.dev_));
7092 }
7093 
GetTypeName() const7094 std::string BlockTouchBufferFtraceEvent::GetTypeName() const {
7095   return "perfetto.protos.BlockTouchBufferFtraceEvent";
7096 }
7097 
7098 
7099 // ===================================================================
7100 
7101 class BlockUnplugFtraceEvent::_Internal {
7102  public:
7103   using HasBits = decltype(std::declval<BlockUnplugFtraceEvent>()._impl_._has_bits_);
set_has_nr_rq(HasBits * has_bits)7104   static void set_has_nr_rq(HasBits* has_bits) {
7105     (*has_bits)[0] |= 2u;
7106   }
set_has_comm(HasBits * has_bits)7107   static void set_has_comm(HasBits* has_bits) {
7108     (*has_bits)[0] |= 1u;
7109   }
7110 };
7111 
BlockUnplugFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)7112 BlockUnplugFtraceEvent::BlockUnplugFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
7113                          bool is_message_owned)
7114   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
7115   SharedCtor(arena, is_message_owned);
7116   // @@protoc_insertion_point(arena_constructor:perfetto.protos.BlockUnplugFtraceEvent)
7117 }
BlockUnplugFtraceEvent(const BlockUnplugFtraceEvent & from)7118 BlockUnplugFtraceEvent::BlockUnplugFtraceEvent(const BlockUnplugFtraceEvent& from)
7119   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
7120   BlockUnplugFtraceEvent* const _this = this; (void)_this;
7121   new (&_impl_) Impl_{
7122       decltype(_impl_._has_bits_){from._impl_._has_bits_}
7123     , /*decltype(_impl_._cached_size_)*/{}
7124     , decltype(_impl_.comm_){}
7125     , decltype(_impl_.nr_rq_){}};
7126 
7127   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
7128   _impl_.comm_.InitDefault();
7129   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
7130     _impl_.comm_.Set("", GetArenaForAllocation());
7131   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
7132   if (from._internal_has_comm()) {
7133     _this->_impl_.comm_.Set(from._internal_comm(),
7134       _this->GetArenaForAllocation());
7135   }
7136   _this->_impl_.nr_rq_ = from._impl_.nr_rq_;
7137   // @@protoc_insertion_point(copy_constructor:perfetto.protos.BlockUnplugFtraceEvent)
7138 }
7139 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)7140 inline void BlockUnplugFtraceEvent::SharedCtor(
7141     ::_pb::Arena* arena, bool is_message_owned) {
7142   (void)arena;
7143   (void)is_message_owned;
7144   new (&_impl_) Impl_{
7145       decltype(_impl_._has_bits_){}
7146     , /*decltype(_impl_._cached_size_)*/{}
7147     , decltype(_impl_.comm_){}
7148     , decltype(_impl_.nr_rq_){0}
7149   };
7150   _impl_.comm_.InitDefault();
7151   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
7152     _impl_.comm_.Set("", GetArenaForAllocation());
7153   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
7154 }
7155 
~BlockUnplugFtraceEvent()7156 BlockUnplugFtraceEvent::~BlockUnplugFtraceEvent() {
7157   // @@protoc_insertion_point(destructor:perfetto.protos.BlockUnplugFtraceEvent)
7158   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
7159   (void)arena;
7160     return;
7161   }
7162   SharedDtor();
7163 }
7164 
SharedDtor()7165 inline void BlockUnplugFtraceEvent::SharedDtor() {
7166   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
7167   _impl_.comm_.Destroy();
7168 }
7169 
SetCachedSize(int size) const7170 void BlockUnplugFtraceEvent::SetCachedSize(int size) const {
7171   _impl_._cached_size_.Set(size);
7172 }
7173 
Clear()7174 void BlockUnplugFtraceEvent::Clear() {
7175 // @@protoc_insertion_point(message_clear_start:perfetto.protos.BlockUnplugFtraceEvent)
7176   ::uint32_t cached_has_bits = 0;
7177   // Prevent compiler warnings about cached_has_bits being unused
7178   (void) cached_has_bits;
7179 
7180   cached_has_bits = _impl_._has_bits_[0];
7181   if (cached_has_bits & 0x00000001u) {
7182     _impl_.comm_.ClearNonDefaultToEmpty();
7183   }
7184   _impl_.nr_rq_ = 0;
7185   _impl_._has_bits_.Clear();
7186   _internal_metadata_.Clear<std::string>();
7187 }
7188 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)7189 const char* BlockUnplugFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
7190 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
7191   _Internal::HasBits has_bits{};
7192   while (!ctx->Done(&ptr)) {
7193     ::uint32_t tag;
7194     ptr = ::_pbi::ReadTag(ptr, &tag);
7195     switch (tag >> 3) {
7196       // optional int32 nr_rq = 1;
7197       case 1:
7198         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
7199           _Internal::set_has_nr_rq(&has_bits);
7200           _impl_.nr_rq_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
7201           CHK_(ptr);
7202         } else {
7203           goto handle_unusual;
7204         }
7205         continue;
7206       // optional string comm = 2;
7207       case 2:
7208         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
7209           auto str = _internal_mutable_comm();
7210           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
7211           CHK_(ptr);
7212         } else {
7213           goto handle_unusual;
7214         }
7215         continue;
7216       default:
7217         goto handle_unusual;
7218     }  // switch
7219   handle_unusual:
7220     if ((tag == 0) || ((tag & 7) == 4)) {
7221       CHK_(ptr);
7222       ctx->SetLastTag(tag);
7223       goto message_done;
7224     }
7225     ptr = UnknownFieldParse(
7226         tag,
7227         _internal_metadata_.mutable_unknown_fields<std::string>(),
7228         ptr, ctx);
7229     CHK_(ptr != nullptr);
7230   }  // while
7231 message_done:
7232   _impl_._has_bits_.Or(has_bits);
7233   return ptr;
7234 failure:
7235   ptr = nullptr;
7236   goto message_done;
7237 #undef CHK_
7238 }
7239 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const7240 ::uint8_t* BlockUnplugFtraceEvent::_InternalSerialize(
7241     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
7242   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.BlockUnplugFtraceEvent)
7243   ::uint32_t cached_has_bits = 0;
7244   (void) cached_has_bits;
7245 
7246   cached_has_bits = _impl_._has_bits_[0];
7247   // optional int32 nr_rq = 1;
7248   if (cached_has_bits & 0x00000002u) {
7249     target = stream->EnsureSpace(target);
7250     target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_nr_rq(), target);
7251   }
7252 
7253   // optional string comm = 2;
7254   if (cached_has_bits & 0x00000001u) {
7255     target = stream->WriteStringMaybeAliased(
7256         2, this->_internal_comm(), target);
7257   }
7258 
7259   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
7260     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
7261         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
7262   }
7263   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.BlockUnplugFtraceEvent)
7264   return target;
7265 }
7266 
ByteSizeLong() const7267 size_t BlockUnplugFtraceEvent::ByteSizeLong() const {
7268 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.BlockUnplugFtraceEvent)
7269   size_t total_size = 0;
7270 
7271   ::uint32_t cached_has_bits = 0;
7272   // Prevent compiler warnings about cached_has_bits being unused
7273   (void) cached_has_bits;
7274 
7275   cached_has_bits = _impl_._has_bits_[0];
7276   if (cached_has_bits & 0x00000003u) {
7277     // optional string comm = 2;
7278     if (cached_has_bits & 0x00000001u) {
7279       total_size += 1 +
7280         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
7281           this->_internal_comm());
7282     }
7283 
7284     // optional int32 nr_rq = 1;
7285     if (cached_has_bits & 0x00000002u) {
7286       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_nr_rq());
7287     }
7288 
7289   }
7290   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
7291     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
7292   }
7293   int cached_size = ::_pbi::ToCachedSize(total_size);
7294   SetCachedSize(cached_size);
7295   return total_size;
7296 }
7297 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)7298 void BlockUnplugFtraceEvent::CheckTypeAndMergeFrom(
7299     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
7300   MergeFrom(*::_pbi::DownCast<const BlockUnplugFtraceEvent*>(
7301       &from));
7302 }
7303 
MergeFrom(const BlockUnplugFtraceEvent & from)7304 void BlockUnplugFtraceEvent::MergeFrom(const BlockUnplugFtraceEvent& from) {
7305   BlockUnplugFtraceEvent* const _this = this;
7306   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.BlockUnplugFtraceEvent)
7307   GOOGLE_DCHECK_NE(&from, _this);
7308   ::uint32_t cached_has_bits = 0;
7309   (void) cached_has_bits;
7310 
7311   cached_has_bits = from._impl_._has_bits_[0];
7312   if (cached_has_bits & 0x00000003u) {
7313     if (cached_has_bits & 0x00000001u) {
7314       _this->_internal_set_comm(from._internal_comm());
7315     }
7316     if (cached_has_bits & 0x00000002u) {
7317       _this->_impl_.nr_rq_ = from._impl_.nr_rq_;
7318     }
7319     _this->_impl_._has_bits_[0] |= cached_has_bits;
7320   }
7321   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
7322 }
7323 
CopyFrom(const BlockUnplugFtraceEvent & from)7324 void BlockUnplugFtraceEvent::CopyFrom(const BlockUnplugFtraceEvent& from) {
7325 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.BlockUnplugFtraceEvent)
7326   if (&from == this) return;
7327   Clear();
7328   MergeFrom(from);
7329 }
7330 
IsInitialized() const7331 bool BlockUnplugFtraceEvent::IsInitialized() const {
7332   return true;
7333 }
7334 
InternalSwap(BlockUnplugFtraceEvent * other)7335 void BlockUnplugFtraceEvent::InternalSwap(BlockUnplugFtraceEvent* other) {
7336   using std::swap;
7337   auto* lhs_arena = GetArenaForAllocation();
7338   auto* rhs_arena = other->GetArenaForAllocation();
7339   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
7340   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
7341   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
7342       &_impl_.comm_, lhs_arena,
7343       &other->_impl_.comm_, rhs_arena
7344   );
7345   swap(_impl_.nr_rq_, other->_impl_.nr_rq_);
7346 }
7347 
GetTypeName() const7348 std::string BlockUnplugFtraceEvent::GetTypeName() const {
7349   return "perfetto.protos.BlockUnplugFtraceEvent";
7350 }
7351 
7352 
7353 // ===================================================================
7354 
7355 class BlockIoStartFtraceEvent::_Internal {
7356  public:
7357   using HasBits = decltype(std::declval<BlockIoStartFtraceEvent>()._impl_._has_bits_);
set_has_dev(HasBits * has_bits)7358   static void set_has_dev(HasBits* has_bits) {
7359     (*has_bits)[0] |= 8u;
7360   }
set_has_sector(HasBits * has_bits)7361   static void set_has_sector(HasBits* has_bits) {
7362     (*has_bits)[0] |= 16u;
7363   }
set_has_nr_sector(HasBits * has_bits)7364   static void set_has_nr_sector(HasBits* has_bits) {
7365     (*has_bits)[0] |= 32u;
7366   }
set_has_bytes(HasBits * has_bits)7367   static void set_has_bytes(HasBits* has_bits) {
7368     (*has_bits)[0] |= 64u;
7369   }
set_has_ioprio(HasBits * has_bits)7370   static void set_has_ioprio(HasBits* has_bits) {
7371     (*has_bits)[0] |= 128u;
7372   }
set_has_rwbs(HasBits * has_bits)7373   static void set_has_rwbs(HasBits* has_bits) {
7374     (*has_bits)[0] |= 1u;
7375   }
set_has_comm(HasBits * has_bits)7376   static void set_has_comm(HasBits* has_bits) {
7377     (*has_bits)[0] |= 2u;
7378   }
set_has_cmd(HasBits * has_bits)7379   static void set_has_cmd(HasBits* has_bits) {
7380     (*has_bits)[0] |= 4u;
7381   }
7382 };
7383 
BlockIoStartFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)7384 BlockIoStartFtraceEvent::BlockIoStartFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
7385                          bool is_message_owned)
7386   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
7387   SharedCtor(arena, is_message_owned);
7388   // @@protoc_insertion_point(arena_constructor:perfetto.protos.BlockIoStartFtraceEvent)
7389 }
BlockIoStartFtraceEvent(const BlockIoStartFtraceEvent & from)7390 BlockIoStartFtraceEvent::BlockIoStartFtraceEvent(const BlockIoStartFtraceEvent& from)
7391   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
7392   BlockIoStartFtraceEvent* const _this = this; (void)_this;
7393   new (&_impl_) Impl_{
7394       decltype(_impl_._has_bits_){from._impl_._has_bits_}
7395     , /*decltype(_impl_._cached_size_)*/{}
7396     , decltype(_impl_.rwbs_){}
7397     , decltype(_impl_.comm_){}
7398     , decltype(_impl_.cmd_){}
7399     , decltype(_impl_.dev_){}
7400     , decltype(_impl_.sector_){}
7401     , decltype(_impl_.nr_sector_){}
7402     , decltype(_impl_.bytes_){}
7403     , decltype(_impl_.ioprio_){}};
7404 
7405   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
7406   _impl_.rwbs_.InitDefault();
7407   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
7408     _impl_.rwbs_.Set("", GetArenaForAllocation());
7409   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
7410   if (from._internal_has_rwbs()) {
7411     _this->_impl_.rwbs_.Set(from._internal_rwbs(),
7412       _this->GetArenaForAllocation());
7413   }
7414   _impl_.comm_.InitDefault();
7415   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
7416     _impl_.comm_.Set("", GetArenaForAllocation());
7417   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
7418   if (from._internal_has_comm()) {
7419     _this->_impl_.comm_.Set(from._internal_comm(),
7420       _this->GetArenaForAllocation());
7421   }
7422   _impl_.cmd_.InitDefault();
7423   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
7424     _impl_.cmd_.Set("", GetArenaForAllocation());
7425   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
7426   if (from._internal_has_cmd()) {
7427     _this->_impl_.cmd_.Set(from._internal_cmd(),
7428       _this->GetArenaForAllocation());
7429   }
7430   ::memcpy(&_impl_.dev_, &from._impl_.dev_,
7431     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.ioprio_) -
7432     reinterpret_cast<char*>(&_impl_.dev_)) + sizeof(_impl_.ioprio_));
7433   // @@protoc_insertion_point(copy_constructor:perfetto.protos.BlockIoStartFtraceEvent)
7434 }
7435 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)7436 inline void BlockIoStartFtraceEvent::SharedCtor(
7437     ::_pb::Arena* arena, bool is_message_owned) {
7438   (void)arena;
7439   (void)is_message_owned;
7440   new (&_impl_) Impl_{
7441       decltype(_impl_._has_bits_){}
7442     , /*decltype(_impl_._cached_size_)*/{}
7443     , decltype(_impl_.rwbs_){}
7444     , decltype(_impl_.comm_){}
7445     , decltype(_impl_.cmd_){}
7446     , decltype(_impl_.dev_){::uint64_t{0u}}
7447     , decltype(_impl_.sector_){::uint64_t{0u}}
7448     , decltype(_impl_.nr_sector_){0u}
7449     , decltype(_impl_.bytes_){0u}
7450     , decltype(_impl_.ioprio_){0u}
7451   };
7452   _impl_.rwbs_.InitDefault();
7453   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
7454     _impl_.rwbs_.Set("", GetArenaForAllocation());
7455   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
7456   _impl_.comm_.InitDefault();
7457   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
7458     _impl_.comm_.Set("", GetArenaForAllocation());
7459   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
7460   _impl_.cmd_.InitDefault();
7461   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
7462     _impl_.cmd_.Set("", GetArenaForAllocation());
7463   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
7464 }
7465 
~BlockIoStartFtraceEvent()7466 BlockIoStartFtraceEvent::~BlockIoStartFtraceEvent() {
7467   // @@protoc_insertion_point(destructor:perfetto.protos.BlockIoStartFtraceEvent)
7468   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
7469   (void)arena;
7470     return;
7471   }
7472   SharedDtor();
7473 }
7474 
SharedDtor()7475 inline void BlockIoStartFtraceEvent::SharedDtor() {
7476   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
7477   _impl_.rwbs_.Destroy();
7478   _impl_.comm_.Destroy();
7479   _impl_.cmd_.Destroy();
7480 }
7481 
SetCachedSize(int size) const7482 void BlockIoStartFtraceEvent::SetCachedSize(int size) const {
7483   _impl_._cached_size_.Set(size);
7484 }
7485 
Clear()7486 void BlockIoStartFtraceEvent::Clear() {
7487 // @@protoc_insertion_point(message_clear_start:perfetto.protos.BlockIoStartFtraceEvent)
7488   ::uint32_t cached_has_bits = 0;
7489   // Prevent compiler warnings about cached_has_bits being unused
7490   (void) cached_has_bits;
7491 
7492   cached_has_bits = _impl_._has_bits_[0];
7493   if (cached_has_bits & 0x00000007u) {
7494     if (cached_has_bits & 0x00000001u) {
7495       _impl_.rwbs_.ClearNonDefaultToEmpty();
7496     }
7497     if (cached_has_bits & 0x00000002u) {
7498       _impl_.comm_.ClearNonDefaultToEmpty();
7499     }
7500     if (cached_has_bits & 0x00000004u) {
7501       _impl_.cmd_.ClearNonDefaultToEmpty();
7502     }
7503   }
7504   if (cached_has_bits & 0x000000f8u) {
7505     ::memset(&_impl_.dev_, 0, static_cast<size_t>(
7506         reinterpret_cast<char*>(&_impl_.ioprio_) -
7507         reinterpret_cast<char*>(&_impl_.dev_)) + sizeof(_impl_.ioprio_));
7508   }
7509   _impl_._has_bits_.Clear();
7510   _internal_metadata_.Clear<std::string>();
7511 }
7512 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)7513 const char* BlockIoStartFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
7514 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
7515   _Internal::HasBits has_bits{};
7516   while (!ctx->Done(&ptr)) {
7517     ::uint32_t tag;
7518     ptr = ::_pbi::ReadTag(ptr, &tag);
7519     switch (tag >> 3) {
7520       // optional uint64 dev = 1;
7521       case 1:
7522         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
7523           _Internal::set_has_dev(&has_bits);
7524           _impl_.dev_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
7525           CHK_(ptr);
7526         } else {
7527           goto handle_unusual;
7528         }
7529         continue;
7530       // optional uint64 sector = 2;
7531       case 2:
7532         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
7533           _Internal::set_has_sector(&has_bits);
7534           _impl_.sector_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
7535           CHK_(ptr);
7536         } else {
7537           goto handle_unusual;
7538         }
7539         continue;
7540       // optional uint32 nr_sector = 3;
7541       case 3:
7542         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
7543           _Internal::set_has_nr_sector(&has_bits);
7544           _impl_.nr_sector_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
7545           CHK_(ptr);
7546         } else {
7547           goto handle_unusual;
7548         }
7549         continue;
7550       // optional uint32 bytes = 4;
7551       case 4:
7552         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
7553           _Internal::set_has_bytes(&has_bits);
7554           _impl_.bytes_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
7555           CHK_(ptr);
7556         } else {
7557           goto handle_unusual;
7558         }
7559         continue;
7560       // optional uint32 ioprio = 5;
7561       case 5:
7562         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
7563           _Internal::set_has_ioprio(&has_bits);
7564           _impl_.ioprio_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
7565           CHK_(ptr);
7566         } else {
7567           goto handle_unusual;
7568         }
7569         continue;
7570       // optional string rwbs = 6;
7571       case 6:
7572         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 50)) {
7573           auto str = _internal_mutable_rwbs();
7574           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
7575           CHK_(ptr);
7576         } else {
7577           goto handle_unusual;
7578         }
7579         continue;
7580       // optional string comm = 7;
7581       case 7:
7582         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 58)) {
7583           auto str = _internal_mutable_comm();
7584           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
7585           CHK_(ptr);
7586         } else {
7587           goto handle_unusual;
7588         }
7589         continue;
7590       // optional string cmd = 8;
7591       case 8:
7592         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 66)) {
7593           auto str = _internal_mutable_cmd();
7594           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
7595           CHK_(ptr);
7596         } else {
7597           goto handle_unusual;
7598         }
7599         continue;
7600       default:
7601         goto handle_unusual;
7602     }  // switch
7603   handle_unusual:
7604     if ((tag == 0) || ((tag & 7) == 4)) {
7605       CHK_(ptr);
7606       ctx->SetLastTag(tag);
7607       goto message_done;
7608     }
7609     ptr = UnknownFieldParse(
7610         tag,
7611         _internal_metadata_.mutable_unknown_fields<std::string>(),
7612         ptr, ctx);
7613     CHK_(ptr != nullptr);
7614   }  // while
7615 message_done:
7616   _impl_._has_bits_.Or(has_bits);
7617   return ptr;
7618 failure:
7619   ptr = nullptr;
7620   goto message_done;
7621 #undef CHK_
7622 }
7623 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const7624 ::uint8_t* BlockIoStartFtraceEvent::_InternalSerialize(
7625     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
7626   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.BlockIoStartFtraceEvent)
7627   ::uint32_t cached_has_bits = 0;
7628   (void) cached_has_bits;
7629 
7630   cached_has_bits = _impl_._has_bits_[0];
7631   // optional uint64 dev = 1;
7632   if (cached_has_bits & 0x00000008u) {
7633     target = stream->EnsureSpace(target);
7634     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_dev(), target);
7635   }
7636 
7637   // optional uint64 sector = 2;
7638   if (cached_has_bits & 0x00000010u) {
7639     target = stream->EnsureSpace(target);
7640     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(2, this->_internal_sector(), target);
7641   }
7642 
7643   // optional uint32 nr_sector = 3;
7644   if (cached_has_bits & 0x00000020u) {
7645     target = stream->EnsureSpace(target);
7646     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_nr_sector(), target);
7647   }
7648 
7649   // optional uint32 bytes = 4;
7650   if (cached_has_bits & 0x00000040u) {
7651     target = stream->EnsureSpace(target);
7652     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(4, this->_internal_bytes(), target);
7653   }
7654 
7655   // optional uint32 ioprio = 5;
7656   if (cached_has_bits & 0x00000080u) {
7657     target = stream->EnsureSpace(target);
7658     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(5, this->_internal_ioprio(), target);
7659   }
7660 
7661   // optional string rwbs = 6;
7662   if (cached_has_bits & 0x00000001u) {
7663     target = stream->WriteStringMaybeAliased(
7664         6, this->_internal_rwbs(), target);
7665   }
7666 
7667   // optional string comm = 7;
7668   if (cached_has_bits & 0x00000002u) {
7669     target = stream->WriteStringMaybeAliased(
7670         7, this->_internal_comm(), target);
7671   }
7672 
7673   // optional string cmd = 8;
7674   if (cached_has_bits & 0x00000004u) {
7675     target = stream->WriteStringMaybeAliased(
7676         8, this->_internal_cmd(), target);
7677   }
7678 
7679   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
7680     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
7681         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
7682   }
7683   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.BlockIoStartFtraceEvent)
7684   return target;
7685 }
7686 
ByteSizeLong() const7687 size_t BlockIoStartFtraceEvent::ByteSizeLong() const {
7688 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.BlockIoStartFtraceEvent)
7689   size_t total_size = 0;
7690 
7691   ::uint32_t cached_has_bits = 0;
7692   // Prevent compiler warnings about cached_has_bits being unused
7693   (void) cached_has_bits;
7694 
7695   cached_has_bits = _impl_._has_bits_[0];
7696   if (cached_has_bits & 0x000000ffu) {
7697     // optional string rwbs = 6;
7698     if (cached_has_bits & 0x00000001u) {
7699       total_size += 1 +
7700         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
7701           this->_internal_rwbs());
7702     }
7703 
7704     // optional string comm = 7;
7705     if (cached_has_bits & 0x00000002u) {
7706       total_size += 1 +
7707         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
7708           this->_internal_comm());
7709     }
7710 
7711     // optional string cmd = 8;
7712     if (cached_has_bits & 0x00000004u) {
7713       total_size += 1 +
7714         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
7715           this->_internal_cmd());
7716     }
7717 
7718     // optional uint64 dev = 1;
7719     if (cached_has_bits & 0x00000008u) {
7720       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_dev());
7721     }
7722 
7723     // optional uint64 sector = 2;
7724     if (cached_has_bits & 0x00000010u) {
7725       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_sector());
7726     }
7727 
7728     // optional uint32 nr_sector = 3;
7729     if (cached_has_bits & 0x00000020u) {
7730       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_nr_sector());
7731     }
7732 
7733     // optional uint32 bytes = 4;
7734     if (cached_has_bits & 0x00000040u) {
7735       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_bytes());
7736     }
7737 
7738     // optional uint32 ioprio = 5;
7739     if (cached_has_bits & 0x00000080u) {
7740       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_ioprio());
7741     }
7742 
7743   }
7744   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
7745     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
7746   }
7747   int cached_size = ::_pbi::ToCachedSize(total_size);
7748   SetCachedSize(cached_size);
7749   return total_size;
7750 }
7751 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)7752 void BlockIoStartFtraceEvent::CheckTypeAndMergeFrom(
7753     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
7754   MergeFrom(*::_pbi::DownCast<const BlockIoStartFtraceEvent*>(
7755       &from));
7756 }
7757 
MergeFrom(const BlockIoStartFtraceEvent & from)7758 void BlockIoStartFtraceEvent::MergeFrom(const BlockIoStartFtraceEvent& from) {
7759   BlockIoStartFtraceEvent* const _this = this;
7760   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.BlockIoStartFtraceEvent)
7761   GOOGLE_DCHECK_NE(&from, _this);
7762   ::uint32_t cached_has_bits = 0;
7763   (void) cached_has_bits;
7764 
7765   cached_has_bits = from._impl_._has_bits_[0];
7766   if (cached_has_bits & 0x000000ffu) {
7767     if (cached_has_bits & 0x00000001u) {
7768       _this->_internal_set_rwbs(from._internal_rwbs());
7769     }
7770     if (cached_has_bits & 0x00000002u) {
7771       _this->_internal_set_comm(from._internal_comm());
7772     }
7773     if (cached_has_bits & 0x00000004u) {
7774       _this->_internal_set_cmd(from._internal_cmd());
7775     }
7776     if (cached_has_bits & 0x00000008u) {
7777       _this->_impl_.dev_ = from._impl_.dev_;
7778     }
7779     if (cached_has_bits & 0x00000010u) {
7780       _this->_impl_.sector_ = from._impl_.sector_;
7781     }
7782     if (cached_has_bits & 0x00000020u) {
7783       _this->_impl_.nr_sector_ = from._impl_.nr_sector_;
7784     }
7785     if (cached_has_bits & 0x00000040u) {
7786       _this->_impl_.bytes_ = from._impl_.bytes_;
7787     }
7788     if (cached_has_bits & 0x00000080u) {
7789       _this->_impl_.ioprio_ = from._impl_.ioprio_;
7790     }
7791     _this->_impl_._has_bits_[0] |= cached_has_bits;
7792   }
7793   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
7794 }
7795 
CopyFrom(const BlockIoStartFtraceEvent & from)7796 void BlockIoStartFtraceEvent::CopyFrom(const BlockIoStartFtraceEvent& from) {
7797 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.BlockIoStartFtraceEvent)
7798   if (&from == this) return;
7799   Clear();
7800   MergeFrom(from);
7801 }
7802 
IsInitialized() const7803 bool BlockIoStartFtraceEvent::IsInitialized() const {
7804   return true;
7805 }
7806 
InternalSwap(BlockIoStartFtraceEvent * other)7807 void BlockIoStartFtraceEvent::InternalSwap(BlockIoStartFtraceEvent* other) {
7808   using std::swap;
7809   auto* lhs_arena = GetArenaForAllocation();
7810   auto* rhs_arena = other->GetArenaForAllocation();
7811   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
7812   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
7813   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
7814       &_impl_.rwbs_, lhs_arena,
7815       &other->_impl_.rwbs_, rhs_arena
7816   );
7817   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
7818       &_impl_.comm_, lhs_arena,
7819       &other->_impl_.comm_, rhs_arena
7820   );
7821   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
7822       &_impl_.cmd_, lhs_arena,
7823       &other->_impl_.cmd_, rhs_arena
7824   );
7825   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
7826       PROTOBUF_FIELD_OFFSET(BlockIoStartFtraceEvent, _impl_.ioprio_)
7827       + sizeof(BlockIoStartFtraceEvent::_impl_.ioprio_)  // NOLINT
7828       - PROTOBUF_FIELD_OFFSET(BlockIoStartFtraceEvent, _impl_.dev_)>(
7829           reinterpret_cast<char*>(&_impl_.dev_),
7830           reinterpret_cast<char*>(&other->_impl_.dev_));
7831 }
7832 
GetTypeName() const7833 std::string BlockIoStartFtraceEvent::GetTypeName() const {
7834   return "perfetto.protos.BlockIoStartFtraceEvent";
7835 }
7836 
7837 
7838 // ===================================================================
7839 
7840 class BlockIoDoneFtraceEvent::_Internal {
7841  public:
7842   using HasBits = decltype(std::declval<BlockIoDoneFtraceEvent>()._impl_._has_bits_);
set_has_dev(HasBits * has_bits)7843   static void set_has_dev(HasBits* has_bits) {
7844     (*has_bits)[0] |= 8u;
7845   }
set_has_sector(HasBits * has_bits)7846   static void set_has_sector(HasBits* has_bits) {
7847     (*has_bits)[0] |= 16u;
7848   }
set_has_nr_sector(HasBits * has_bits)7849   static void set_has_nr_sector(HasBits* has_bits) {
7850     (*has_bits)[0] |= 32u;
7851   }
set_has_bytes(HasBits * has_bits)7852   static void set_has_bytes(HasBits* has_bits) {
7853     (*has_bits)[0] |= 64u;
7854   }
set_has_ioprio(HasBits * has_bits)7855   static void set_has_ioprio(HasBits* has_bits) {
7856     (*has_bits)[0] |= 128u;
7857   }
set_has_rwbs(HasBits * has_bits)7858   static void set_has_rwbs(HasBits* has_bits) {
7859     (*has_bits)[0] |= 1u;
7860   }
set_has_comm(HasBits * has_bits)7861   static void set_has_comm(HasBits* has_bits) {
7862     (*has_bits)[0] |= 2u;
7863   }
set_has_cmd(HasBits * has_bits)7864   static void set_has_cmd(HasBits* has_bits) {
7865     (*has_bits)[0] |= 4u;
7866   }
7867 };
7868 
BlockIoDoneFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)7869 BlockIoDoneFtraceEvent::BlockIoDoneFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
7870                          bool is_message_owned)
7871   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
7872   SharedCtor(arena, is_message_owned);
7873   // @@protoc_insertion_point(arena_constructor:perfetto.protos.BlockIoDoneFtraceEvent)
7874 }
BlockIoDoneFtraceEvent(const BlockIoDoneFtraceEvent & from)7875 BlockIoDoneFtraceEvent::BlockIoDoneFtraceEvent(const BlockIoDoneFtraceEvent& from)
7876   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
7877   BlockIoDoneFtraceEvent* const _this = this; (void)_this;
7878   new (&_impl_) Impl_{
7879       decltype(_impl_._has_bits_){from._impl_._has_bits_}
7880     , /*decltype(_impl_._cached_size_)*/{}
7881     , decltype(_impl_.rwbs_){}
7882     , decltype(_impl_.comm_){}
7883     , decltype(_impl_.cmd_){}
7884     , decltype(_impl_.dev_){}
7885     , decltype(_impl_.sector_){}
7886     , decltype(_impl_.nr_sector_){}
7887     , decltype(_impl_.bytes_){}
7888     , decltype(_impl_.ioprio_){}};
7889 
7890   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
7891   _impl_.rwbs_.InitDefault();
7892   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
7893     _impl_.rwbs_.Set("", GetArenaForAllocation());
7894   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
7895   if (from._internal_has_rwbs()) {
7896     _this->_impl_.rwbs_.Set(from._internal_rwbs(),
7897       _this->GetArenaForAllocation());
7898   }
7899   _impl_.comm_.InitDefault();
7900   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
7901     _impl_.comm_.Set("", GetArenaForAllocation());
7902   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
7903   if (from._internal_has_comm()) {
7904     _this->_impl_.comm_.Set(from._internal_comm(),
7905       _this->GetArenaForAllocation());
7906   }
7907   _impl_.cmd_.InitDefault();
7908   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
7909     _impl_.cmd_.Set("", GetArenaForAllocation());
7910   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
7911   if (from._internal_has_cmd()) {
7912     _this->_impl_.cmd_.Set(from._internal_cmd(),
7913       _this->GetArenaForAllocation());
7914   }
7915   ::memcpy(&_impl_.dev_, &from._impl_.dev_,
7916     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.ioprio_) -
7917     reinterpret_cast<char*>(&_impl_.dev_)) + sizeof(_impl_.ioprio_));
7918   // @@protoc_insertion_point(copy_constructor:perfetto.protos.BlockIoDoneFtraceEvent)
7919 }
7920 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)7921 inline void BlockIoDoneFtraceEvent::SharedCtor(
7922     ::_pb::Arena* arena, bool is_message_owned) {
7923   (void)arena;
7924   (void)is_message_owned;
7925   new (&_impl_) Impl_{
7926       decltype(_impl_._has_bits_){}
7927     , /*decltype(_impl_._cached_size_)*/{}
7928     , decltype(_impl_.rwbs_){}
7929     , decltype(_impl_.comm_){}
7930     , decltype(_impl_.cmd_){}
7931     , decltype(_impl_.dev_){::uint64_t{0u}}
7932     , decltype(_impl_.sector_){::uint64_t{0u}}
7933     , decltype(_impl_.nr_sector_){0u}
7934     , decltype(_impl_.bytes_){0u}
7935     , decltype(_impl_.ioprio_){0u}
7936   };
7937   _impl_.rwbs_.InitDefault();
7938   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
7939     _impl_.rwbs_.Set("", GetArenaForAllocation());
7940   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
7941   _impl_.comm_.InitDefault();
7942   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
7943     _impl_.comm_.Set("", GetArenaForAllocation());
7944   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
7945   _impl_.cmd_.InitDefault();
7946   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
7947     _impl_.cmd_.Set("", GetArenaForAllocation());
7948   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
7949 }
7950 
~BlockIoDoneFtraceEvent()7951 BlockIoDoneFtraceEvent::~BlockIoDoneFtraceEvent() {
7952   // @@protoc_insertion_point(destructor:perfetto.protos.BlockIoDoneFtraceEvent)
7953   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
7954   (void)arena;
7955     return;
7956   }
7957   SharedDtor();
7958 }
7959 
SharedDtor()7960 inline void BlockIoDoneFtraceEvent::SharedDtor() {
7961   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
7962   _impl_.rwbs_.Destroy();
7963   _impl_.comm_.Destroy();
7964   _impl_.cmd_.Destroy();
7965 }
7966 
SetCachedSize(int size) const7967 void BlockIoDoneFtraceEvent::SetCachedSize(int size) const {
7968   _impl_._cached_size_.Set(size);
7969 }
7970 
Clear()7971 void BlockIoDoneFtraceEvent::Clear() {
7972 // @@protoc_insertion_point(message_clear_start:perfetto.protos.BlockIoDoneFtraceEvent)
7973   ::uint32_t cached_has_bits = 0;
7974   // Prevent compiler warnings about cached_has_bits being unused
7975   (void) cached_has_bits;
7976 
7977   cached_has_bits = _impl_._has_bits_[0];
7978   if (cached_has_bits & 0x00000007u) {
7979     if (cached_has_bits & 0x00000001u) {
7980       _impl_.rwbs_.ClearNonDefaultToEmpty();
7981     }
7982     if (cached_has_bits & 0x00000002u) {
7983       _impl_.comm_.ClearNonDefaultToEmpty();
7984     }
7985     if (cached_has_bits & 0x00000004u) {
7986       _impl_.cmd_.ClearNonDefaultToEmpty();
7987     }
7988   }
7989   if (cached_has_bits & 0x000000f8u) {
7990     ::memset(&_impl_.dev_, 0, static_cast<size_t>(
7991         reinterpret_cast<char*>(&_impl_.ioprio_) -
7992         reinterpret_cast<char*>(&_impl_.dev_)) + sizeof(_impl_.ioprio_));
7993   }
7994   _impl_._has_bits_.Clear();
7995   _internal_metadata_.Clear<std::string>();
7996 }
7997 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)7998 const char* BlockIoDoneFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
7999 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
8000   _Internal::HasBits has_bits{};
8001   while (!ctx->Done(&ptr)) {
8002     ::uint32_t tag;
8003     ptr = ::_pbi::ReadTag(ptr, &tag);
8004     switch (tag >> 3) {
8005       // optional uint64 dev = 1;
8006       case 1:
8007         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
8008           _Internal::set_has_dev(&has_bits);
8009           _impl_.dev_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
8010           CHK_(ptr);
8011         } else {
8012           goto handle_unusual;
8013         }
8014         continue;
8015       // optional uint64 sector = 2;
8016       case 2:
8017         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
8018           _Internal::set_has_sector(&has_bits);
8019           _impl_.sector_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
8020           CHK_(ptr);
8021         } else {
8022           goto handle_unusual;
8023         }
8024         continue;
8025       // optional uint32 nr_sector = 3;
8026       case 3:
8027         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
8028           _Internal::set_has_nr_sector(&has_bits);
8029           _impl_.nr_sector_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
8030           CHK_(ptr);
8031         } else {
8032           goto handle_unusual;
8033         }
8034         continue;
8035       // optional uint32 bytes = 4;
8036       case 4:
8037         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
8038           _Internal::set_has_bytes(&has_bits);
8039           _impl_.bytes_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
8040           CHK_(ptr);
8041         } else {
8042           goto handle_unusual;
8043         }
8044         continue;
8045       // optional uint32 ioprio = 5;
8046       case 5:
8047         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
8048           _Internal::set_has_ioprio(&has_bits);
8049           _impl_.ioprio_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
8050           CHK_(ptr);
8051         } else {
8052           goto handle_unusual;
8053         }
8054         continue;
8055       // optional string rwbs = 6;
8056       case 6:
8057         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 50)) {
8058           auto str = _internal_mutable_rwbs();
8059           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
8060           CHK_(ptr);
8061         } else {
8062           goto handle_unusual;
8063         }
8064         continue;
8065       // optional string comm = 7;
8066       case 7:
8067         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 58)) {
8068           auto str = _internal_mutable_comm();
8069           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
8070           CHK_(ptr);
8071         } else {
8072           goto handle_unusual;
8073         }
8074         continue;
8075       // optional string cmd = 8;
8076       case 8:
8077         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 66)) {
8078           auto str = _internal_mutable_cmd();
8079           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
8080           CHK_(ptr);
8081         } else {
8082           goto handle_unusual;
8083         }
8084         continue;
8085       default:
8086         goto handle_unusual;
8087     }  // switch
8088   handle_unusual:
8089     if ((tag == 0) || ((tag & 7) == 4)) {
8090       CHK_(ptr);
8091       ctx->SetLastTag(tag);
8092       goto message_done;
8093     }
8094     ptr = UnknownFieldParse(
8095         tag,
8096         _internal_metadata_.mutable_unknown_fields<std::string>(),
8097         ptr, ctx);
8098     CHK_(ptr != nullptr);
8099   }  // while
8100 message_done:
8101   _impl_._has_bits_.Or(has_bits);
8102   return ptr;
8103 failure:
8104   ptr = nullptr;
8105   goto message_done;
8106 #undef CHK_
8107 }
8108 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const8109 ::uint8_t* BlockIoDoneFtraceEvent::_InternalSerialize(
8110     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
8111   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.BlockIoDoneFtraceEvent)
8112   ::uint32_t cached_has_bits = 0;
8113   (void) cached_has_bits;
8114 
8115   cached_has_bits = _impl_._has_bits_[0];
8116   // optional uint64 dev = 1;
8117   if (cached_has_bits & 0x00000008u) {
8118     target = stream->EnsureSpace(target);
8119     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_dev(), target);
8120   }
8121 
8122   // optional uint64 sector = 2;
8123   if (cached_has_bits & 0x00000010u) {
8124     target = stream->EnsureSpace(target);
8125     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(2, this->_internal_sector(), target);
8126   }
8127 
8128   // optional uint32 nr_sector = 3;
8129   if (cached_has_bits & 0x00000020u) {
8130     target = stream->EnsureSpace(target);
8131     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_nr_sector(), target);
8132   }
8133 
8134   // optional uint32 bytes = 4;
8135   if (cached_has_bits & 0x00000040u) {
8136     target = stream->EnsureSpace(target);
8137     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(4, this->_internal_bytes(), target);
8138   }
8139 
8140   // optional uint32 ioprio = 5;
8141   if (cached_has_bits & 0x00000080u) {
8142     target = stream->EnsureSpace(target);
8143     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(5, this->_internal_ioprio(), target);
8144   }
8145 
8146   // optional string rwbs = 6;
8147   if (cached_has_bits & 0x00000001u) {
8148     target = stream->WriteStringMaybeAliased(
8149         6, this->_internal_rwbs(), target);
8150   }
8151 
8152   // optional string comm = 7;
8153   if (cached_has_bits & 0x00000002u) {
8154     target = stream->WriteStringMaybeAliased(
8155         7, this->_internal_comm(), target);
8156   }
8157 
8158   // optional string cmd = 8;
8159   if (cached_has_bits & 0x00000004u) {
8160     target = stream->WriteStringMaybeAliased(
8161         8, this->_internal_cmd(), target);
8162   }
8163 
8164   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
8165     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
8166         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
8167   }
8168   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.BlockIoDoneFtraceEvent)
8169   return target;
8170 }
8171 
ByteSizeLong() const8172 size_t BlockIoDoneFtraceEvent::ByteSizeLong() const {
8173 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.BlockIoDoneFtraceEvent)
8174   size_t total_size = 0;
8175 
8176   ::uint32_t cached_has_bits = 0;
8177   // Prevent compiler warnings about cached_has_bits being unused
8178   (void) cached_has_bits;
8179 
8180   cached_has_bits = _impl_._has_bits_[0];
8181   if (cached_has_bits & 0x000000ffu) {
8182     // optional string rwbs = 6;
8183     if (cached_has_bits & 0x00000001u) {
8184       total_size += 1 +
8185         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
8186           this->_internal_rwbs());
8187     }
8188 
8189     // optional string comm = 7;
8190     if (cached_has_bits & 0x00000002u) {
8191       total_size += 1 +
8192         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
8193           this->_internal_comm());
8194     }
8195 
8196     // optional string cmd = 8;
8197     if (cached_has_bits & 0x00000004u) {
8198       total_size += 1 +
8199         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
8200           this->_internal_cmd());
8201     }
8202 
8203     // optional uint64 dev = 1;
8204     if (cached_has_bits & 0x00000008u) {
8205       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_dev());
8206     }
8207 
8208     // optional uint64 sector = 2;
8209     if (cached_has_bits & 0x00000010u) {
8210       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_sector());
8211     }
8212 
8213     // optional uint32 nr_sector = 3;
8214     if (cached_has_bits & 0x00000020u) {
8215       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_nr_sector());
8216     }
8217 
8218     // optional uint32 bytes = 4;
8219     if (cached_has_bits & 0x00000040u) {
8220       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_bytes());
8221     }
8222 
8223     // optional uint32 ioprio = 5;
8224     if (cached_has_bits & 0x00000080u) {
8225       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_ioprio());
8226     }
8227 
8228   }
8229   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
8230     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
8231   }
8232   int cached_size = ::_pbi::ToCachedSize(total_size);
8233   SetCachedSize(cached_size);
8234   return total_size;
8235 }
8236 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)8237 void BlockIoDoneFtraceEvent::CheckTypeAndMergeFrom(
8238     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
8239   MergeFrom(*::_pbi::DownCast<const BlockIoDoneFtraceEvent*>(
8240       &from));
8241 }
8242 
MergeFrom(const BlockIoDoneFtraceEvent & from)8243 void BlockIoDoneFtraceEvent::MergeFrom(const BlockIoDoneFtraceEvent& from) {
8244   BlockIoDoneFtraceEvent* const _this = this;
8245   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.BlockIoDoneFtraceEvent)
8246   GOOGLE_DCHECK_NE(&from, _this);
8247   ::uint32_t cached_has_bits = 0;
8248   (void) cached_has_bits;
8249 
8250   cached_has_bits = from._impl_._has_bits_[0];
8251   if (cached_has_bits & 0x000000ffu) {
8252     if (cached_has_bits & 0x00000001u) {
8253       _this->_internal_set_rwbs(from._internal_rwbs());
8254     }
8255     if (cached_has_bits & 0x00000002u) {
8256       _this->_internal_set_comm(from._internal_comm());
8257     }
8258     if (cached_has_bits & 0x00000004u) {
8259       _this->_internal_set_cmd(from._internal_cmd());
8260     }
8261     if (cached_has_bits & 0x00000008u) {
8262       _this->_impl_.dev_ = from._impl_.dev_;
8263     }
8264     if (cached_has_bits & 0x00000010u) {
8265       _this->_impl_.sector_ = from._impl_.sector_;
8266     }
8267     if (cached_has_bits & 0x00000020u) {
8268       _this->_impl_.nr_sector_ = from._impl_.nr_sector_;
8269     }
8270     if (cached_has_bits & 0x00000040u) {
8271       _this->_impl_.bytes_ = from._impl_.bytes_;
8272     }
8273     if (cached_has_bits & 0x00000080u) {
8274       _this->_impl_.ioprio_ = from._impl_.ioprio_;
8275     }
8276     _this->_impl_._has_bits_[0] |= cached_has_bits;
8277   }
8278   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
8279 }
8280 
CopyFrom(const BlockIoDoneFtraceEvent & from)8281 void BlockIoDoneFtraceEvent::CopyFrom(const BlockIoDoneFtraceEvent& from) {
8282 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.BlockIoDoneFtraceEvent)
8283   if (&from == this) return;
8284   Clear();
8285   MergeFrom(from);
8286 }
8287 
IsInitialized() const8288 bool BlockIoDoneFtraceEvent::IsInitialized() const {
8289   return true;
8290 }
8291 
InternalSwap(BlockIoDoneFtraceEvent * other)8292 void BlockIoDoneFtraceEvent::InternalSwap(BlockIoDoneFtraceEvent* other) {
8293   using std::swap;
8294   auto* lhs_arena = GetArenaForAllocation();
8295   auto* rhs_arena = other->GetArenaForAllocation();
8296   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
8297   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
8298   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
8299       &_impl_.rwbs_, lhs_arena,
8300       &other->_impl_.rwbs_, rhs_arena
8301   );
8302   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
8303       &_impl_.comm_, lhs_arena,
8304       &other->_impl_.comm_, rhs_arena
8305   );
8306   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
8307       &_impl_.cmd_, lhs_arena,
8308       &other->_impl_.cmd_, rhs_arena
8309   );
8310   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
8311       PROTOBUF_FIELD_OFFSET(BlockIoDoneFtraceEvent, _impl_.ioprio_)
8312       + sizeof(BlockIoDoneFtraceEvent::_impl_.ioprio_)  // NOLINT
8313       - PROTOBUF_FIELD_OFFSET(BlockIoDoneFtraceEvent, _impl_.dev_)>(
8314           reinterpret_cast<char*>(&_impl_.dev_),
8315           reinterpret_cast<char*>(&other->_impl_.dev_));
8316 }
8317 
GetTypeName() const8318 std::string BlockIoDoneFtraceEvent::GetTypeName() const {
8319   return "perfetto.protos.BlockIoDoneFtraceEvent";
8320 }
8321 
8322 
8323 // @@protoc_insertion_point(namespace_scope)
8324 }  // namespace protos
8325 }  // namespace perfetto
8326 PROTOBUF_NAMESPACE_OPEN
8327 template<> PROTOBUF_NOINLINE ::perfetto::protos::BlockRqIssueFtraceEvent*
CreateMaybeMessage(Arena * arena)8328 Arena::CreateMaybeMessage< ::perfetto::protos::BlockRqIssueFtraceEvent >(Arena* arena) {
8329   return Arena::CreateMessageInternal< ::perfetto::protos::BlockRqIssueFtraceEvent >(arena);
8330 }
8331 template<> PROTOBUF_NOINLINE ::perfetto::protos::BlockBioBackmergeFtraceEvent*
CreateMaybeMessage(Arena * arena)8332 Arena::CreateMaybeMessage< ::perfetto::protos::BlockBioBackmergeFtraceEvent >(Arena* arena) {
8333   return Arena::CreateMessageInternal< ::perfetto::protos::BlockBioBackmergeFtraceEvent >(arena);
8334 }
8335 template<> PROTOBUF_NOINLINE ::perfetto::protos::BlockBioBounceFtraceEvent*
CreateMaybeMessage(Arena * arena)8336 Arena::CreateMaybeMessage< ::perfetto::protos::BlockBioBounceFtraceEvent >(Arena* arena) {
8337   return Arena::CreateMessageInternal< ::perfetto::protos::BlockBioBounceFtraceEvent >(arena);
8338 }
8339 template<> PROTOBUF_NOINLINE ::perfetto::protos::BlockBioCompleteFtraceEvent*
CreateMaybeMessage(Arena * arena)8340 Arena::CreateMaybeMessage< ::perfetto::protos::BlockBioCompleteFtraceEvent >(Arena* arena) {
8341   return Arena::CreateMessageInternal< ::perfetto::protos::BlockBioCompleteFtraceEvent >(arena);
8342 }
8343 template<> PROTOBUF_NOINLINE ::perfetto::protos::BlockBioFrontmergeFtraceEvent*
CreateMaybeMessage(Arena * arena)8344 Arena::CreateMaybeMessage< ::perfetto::protos::BlockBioFrontmergeFtraceEvent >(Arena* arena) {
8345   return Arena::CreateMessageInternal< ::perfetto::protos::BlockBioFrontmergeFtraceEvent >(arena);
8346 }
8347 template<> PROTOBUF_NOINLINE ::perfetto::protos::BlockBioQueueFtraceEvent*
CreateMaybeMessage(Arena * arena)8348 Arena::CreateMaybeMessage< ::perfetto::protos::BlockBioQueueFtraceEvent >(Arena* arena) {
8349   return Arena::CreateMessageInternal< ::perfetto::protos::BlockBioQueueFtraceEvent >(arena);
8350 }
8351 template<> PROTOBUF_NOINLINE ::perfetto::protos::BlockBioRemapFtraceEvent*
CreateMaybeMessage(Arena * arena)8352 Arena::CreateMaybeMessage< ::perfetto::protos::BlockBioRemapFtraceEvent >(Arena* arena) {
8353   return Arena::CreateMessageInternal< ::perfetto::protos::BlockBioRemapFtraceEvent >(arena);
8354 }
8355 template<> PROTOBUF_NOINLINE ::perfetto::protos::BlockDirtyBufferFtraceEvent*
CreateMaybeMessage(Arena * arena)8356 Arena::CreateMaybeMessage< ::perfetto::protos::BlockDirtyBufferFtraceEvent >(Arena* arena) {
8357   return Arena::CreateMessageInternal< ::perfetto::protos::BlockDirtyBufferFtraceEvent >(arena);
8358 }
8359 template<> PROTOBUF_NOINLINE ::perfetto::protos::BlockGetrqFtraceEvent*
CreateMaybeMessage(Arena * arena)8360 Arena::CreateMaybeMessage< ::perfetto::protos::BlockGetrqFtraceEvent >(Arena* arena) {
8361   return Arena::CreateMessageInternal< ::perfetto::protos::BlockGetrqFtraceEvent >(arena);
8362 }
8363 template<> PROTOBUF_NOINLINE ::perfetto::protos::BlockPlugFtraceEvent*
CreateMaybeMessage(Arena * arena)8364 Arena::CreateMaybeMessage< ::perfetto::protos::BlockPlugFtraceEvent >(Arena* arena) {
8365   return Arena::CreateMessageInternal< ::perfetto::protos::BlockPlugFtraceEvent >(arena);
8366 }
8367 template<> PROTOBUF_NOINLINE ::perfetto::protos::BlockRqAbortFtraceEvent*
CreateMaybeMessage(Arena * arena)8368 Arena::CreateMaybeMessage< ::perfetto::protos::BlockRqAbortFtraceEvent >(Arena* arena) {
8369   return Arena::CreateMessageInternal< ::perfetto::protos::BlockRqAbortFtraceEvent >(arena);
8370 }
8371 template<> PROTOBUF_NOINLINE ::perfetto::protos::BlockRqCompleteFtraceEvent*
CreateMaybeMessage(Arena * arena)8372 Arena::CreateMaybeMessage< ::perfetto::protos::BlockRqCompleteFtraceEvent >(Arena* arena) {
8373   return Arena::CreateMessageInternal< ::perfetto::protos::BlockRqCompleteFtraceEvent >(arena);
8374 }
8375 template<> PROTOBUF_NOINLINE ::perfetto::protos::BlockRqInsertFtraceEvent*
CreateMaybeMessage(Arena * arena)8376 Arena::CreateMaybeMessage< ::perfetto::protos::BlockRqInsertFtraceEvent >(Arena* arena) {
8377   return Arena::CreateMessageInternal< ::perfetto::protos::BlockRqInsertFtraceEvent >(arena);
8378 }
8379 template<> PROTOBUF_NOINLINE ::perfetto::protos::BlockRqRemapFtraceEvent*
CreateMaybeMessage(Arena * arena)8380 Arena::CreateMaybeMessage< ::perfetto::protos::BlockRqRemapFtraceEvent >(Arena* arena) {
8381   return Arena::CreateMessageInternal< ::perfetto::protos::BlockRqRemapFtraceEvent >(arena);
8382 }
8383 template<> PROTOBUF_NOINLINE ::perfetto::protos::BlockRqRequeueFtraceEvent*
CreateMaybeMessage(Arena * arena)8384 Arena::CreateMaybeMessage< ::perfetto::protos::BlockRqRequeueFtraceEvent >(Arena* arena) {
8385   return Arena::CreateMessageInternal< ::perfetto::protos::BlockRqRequeueFtraceEvent >(arena);
8386 }
8387 template<> PROTOBUF_NOINLINE ::perfetto::protos::BlockSleeprqFtraceEvent*
CreateMaybeMessage(Arena * arena)8388 Arena::CreateMaybeMessage< ::perfetto::protos::BlockSleeprqFtraceEvent >(Arena* arena) {
8389   return Arena::CreateMessageInternal< ::perfetto::protos::BlockSleeprqFtraceEvent >(arena);
8390 }
8391 template<> PROTOBUF_NOINLINE ::perfetto::protos::BlockSplitFtraceEvent*
CreateMaybeMessage(Arena * arena)8392 Arena::CreateMaybeMessage< ::perfetto::protos::BlockSplitFtraceEvent >(Arena* arena) {
8393   return Arena::CreateMessageInternal< ::perfetto::protos::BlockSplitFtraceEvent >(arena);
8394 }
8395 template<> PROTOBUF_NOINLINE ::perfetto::protos::BlockTouchBufferFtraceEvent*
CreateMaybeMessage(Arena * arena)8396 Arena::CreateMaybeMessage< ::perfetto::protos::BlockTouchBufferFtraceEvent >(Arena* arena) {
8397   return Arena::CreateMessageInternal< ::perfetto::protos::BlockTouchBufferFtraceEvent >(arena);
8398 }
8399 template<> PROTOBUF_NOINLINE ::perfetto::protos::BlockUnplugFtraceEvent*
CreateMaybeMessage(Arena * arena)8400 Arena::CreateMaybeMessage< ::perfetto::protos::BlockUnplugFtraceEvent >(Arena* arena) {
8401   return Arena::CreateMessageInternal< ::perfetto::protos::BlockUnplugFtraceEvent >(arena);
8402 }
8403 template<> PROTOBUF_NOINLINE ::perfetto::protos::BlockIoStartFtraceEvent*
CreateMaybeMessage(Arena * arena)8404 Arena::CreateMaybeMessage< ::perfetto::protos::BlockIoStartFtraceEvent >(Arena* arena) {
8405   return Arena::CreateMessageInternal< ::perfetto::protos::BlockIoStartFtraceEvent >(arena);
8406 }
8407 template<> PROTOBUF_NOINLINE ::perfetto::protos::BlockIoDoneFtraceEvent*
CreateMaybeMessage(Arena * arena)8408 Arena::CreateMaybeMessage< ::perfetto::protos::BlockIoDoneFtraceEvent >(Arena* arena) {
8409   return Arena::CreateMessageInternal< ::perfetto::protos::BlockIoDoneFtraceEvent >(arena);
8410 }
8411 PROTOBUF_NAMESPACE_CLOSE
8412 
8413 // @@protoc_insertion_point(global_scope)
8414 #include <google/protobuf/port_undef.inc>
8415