1 // Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
2 
3 #ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_PROCESSOR_SERIALIZATION_PROTO_H_
4 #define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_PROCESSOR_SERIALIZATION_PROTO_H_
5 
6 #include <stddef.h>
7 #include <stdint.h>
8 
9 #include "perfetto/protozero/field_writer.h"
10 #include "perfetto/protozero/message.h"
11 #include "perfetto/protozero/packed_repeated_fields.h"
12 #include "perfetto/protozero/proto_decoder.h"
13 #include "perfetto/protozero/proto_utils.h"
14 
15 namespace perfetto {
16 namespace protos {
17 namespace pbzero {
18 class SerializedColumn;
19 class SerializedColumn_BitVector;
20 class SerializedColumn_Storage;
21 class SerializedColumn_Storage_ArrangementOverlay;
22 class SerializedColumn_Storage_DenseNullOverlay;
23 class SerializedColumn_Storage_DummyStorage;
24 class SerializedColumn_Storage_IdStorage;
25 class SerializedColumn_Storage_NullOverlay;
26 class SerializedColumn_Storage_NumericStorage;
27 class SerializedColumn_Storage_SelectorOverlay;
28 class SerializedColumn_Storage_SetIdStorage;
29 class SerializedColumn_Storage_StringStorage;
30 class SerializedTraceProcessorPacket;
31 } // Namespace pbzero.
32 } // Namespace protos.
33 } // Namespace perfetto.
34 
35 namespace perfetto {
36 namespace protos {
37 namespace pbzero {
38 
39 class SerializedColumn_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
40  public:
SerializedColumn_Decoder(const uint8_t * data,size_t len)41   SerializedColumn_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
SerializedColumn_Decoder(const std::string & raw)42   explicit SerializedColumn_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
SerializedColumn_Decoder(const::protozero::ConstBytes & raw)43   explicit SerializedColumn_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
has_table_name()44   bool has_table_name() const { return at<1>().valid(); }
table_name()45   ::protozero::ConstChars table_name() const { return at<1>().as_string(); }
has_column_name()46   bool has_column_name() const { return at<2>().valid(); }
column_name()47   ::protozero::ConstChars column_name() const { return at<2>().as_string(); }
has_storage()48   bool has_storage() const { return at<3>().valid(); }
storage()49   ::protozero::ConstBytes storage() const { return at<3>().as_bytes(); }
50 };
51 
52 class SerializedColumn : public ::protozero::Message {
53  public:
54   using Decoder = SerializedColumn_Decoder;
55   enum : int32_t {
56     kTableNameFieldNumber = 1,
57     kColumnNameFieldNumber = 2,
58     kStorageFieldNumber = 3,
59   };
GetName()60   static constexpr const char* GetName() { return ".perfetto.protos.SerializedColumn"; }
61 
62   using BitVector = ::perfetto::protos::pbzero::SerializedColumn_BitVector;
63   using Storage = ::perfetto::protos::pbzero::SerializedColumn_Storage;
64 
65   using FieldMetadata_TableName =
66     ::protozero::proto_utils::FieldMetadata<
67       1,
68       ::protozero::proto_utils::RepetitionType::kNotRepeated,
69       ::protozero::proto_utils::ProtoSchemaType::kString,
70       std::string,
71       SerializedColumn>;
72 
73   static constexpr FieldMetadata_TableName kTableName{};
set_table_name(const char * data,size_t size)74   void set_table_name(const char* data, size_t size) {
75     AppendBytes(FieldMetadata_TableName::kFieldId, data, size);
76   }
set_table_name(::protozero::ConstChars chars)77   void set_table_name(::protozero::ConstChars chars) {
78     AppendBytes(FieldMetadata_TableName::kFieldId, chars.data, chars.size);
79   }
set_table_name(std::string value)80   void set_table_name(std::string value) {
81     static constexpr uint32_t field_id = FieldMetadata_TableName::kFieldId;
82     // Call the appropriate protozero::Message::Append(field_id, ...)
83     // method based on the type of the field.
84     ::protozero::internal::FieldWriter<
85       ::protozero::proto_utils::ProtoSchemaType::kString>
86         ::Append(*this, field_id, value);
87   }
88 
89   using FieldMetadata_ColumnName =
90     ::protozero::proto_utils::FieldMetadata<
91       2,
92       ::protozero::proto_utils::RepetitionType::kNotRepeated,
93       ::protozero::proto_utils::ProtoSchemaType::kString,
94       std::string,
95       SerializedColumn>;
96 
97   static constexpr FieldMetadata_ColumnName kColumnName{};
set_column_name(const char * data,size_t size)98   void set_column_name(const char* data, size_t size) {
99     AppendBytes(FieldMetadata_ColumnName::kFieldId, data, size);
100   }
set_column_name(::protozero::ConstChars chars)101   void set_column_name(::protozero::ConstChars chars) {
102     AppendBytes(FieldMetadata_ColumnName::kFieldId, chars.data, chars.size);
103   }
set_column_name(std::string value)104   void set_column_name(std::string value) {
105     static constexpr uint32_t field_id = FieldMetadata_ColumnName::kFieldId;
106     // Call the appropriate protozero::Message::Append(field_id, ...)
107     // method based on the type of the field.
108     ::protozero::internal::FieldWriter<
109       ::protozero::proto_utils::ProtoSchemaType::kString>
110         ::Append(*this, field_id, value);
111   }
112 
113   using FieldMetadata_Storage =
114     ::protozero::proto_utils::FieldMetadata<
115       3,
116       ::protozero::proto_utils::RepetitionType::kNotRepeated,
117       ::protozero::proto_utils::ProtoSchemaType::kMessage,
118       SerializedColumn_Storage,
119       SerializedColumn>;
120 
121   static constexpr FieldMetadata_Storage kStorage{};
set_storage()122   template <typename T = SerializedColumn_Storage> T* set_storage() {
123     return BeginNestedMessage<T>(3);
124   }
125 
126 };
127 
128 class SerializedColumn_Storage_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/9, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
129  public:
SerializedColumn_Storage_Decoder(const uint8_t * data,size_t len)130   SerializedColumn_Storage_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
SerializedColumn_Storage_Decoder(const std::string & raw)131   explicit SerializedColumn_Storage_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
SerializedColumn_Storage_Decoder(const::protozero::ConstBytes & raw)132   explicit SerializedColumn_Storage_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
has_dummy_storage()133   bool has_dummy_storage() const { return at<1>().valid(); }
dummy_storage()134   ::protozero::ConstBytes dummy_storage() const { return at<1>().as_bytes(); }
has_id_storage()135   bool has_id_storage() const { return at<2>().valid(); }
id_storage()136   ::protozero::ConstBytes id_storage() const { return at<2>().as_bytes(); }
has_numeric_storage()137   bool has_numeric_storage() const { return at<3>().valid(); }
numeric_storage()138   ::protozero::ConstBytes numeric_storage() const { return at<3>().as_bytes(); }
has_set_id_storage()139   bool has_set_id_storage() const { return at<4>().valid(); }
set_id_storage()140   ::protozero::ConstBytes set_id_storage() const { return at<4>().as_bytes(); }
has_string_storage()141   bool has_string_storage() const { return at<5>().valid(); }
string_storage()142   ::protozero::ConstBytes string_storage() const { return at<5>().as_bytes(); }
has_null_overlay()143   bool has_null_overlay() const { return at<6>().valid(); }
null_overlay()144   ::protozero::ConstBytes null_overlay() const { return at<6>().as_bytes(); }
has_arrangement_overlay()145   bool has_arrangement_overlay() const { return at<7>().valid(); }
arrangement_overlay()146   ::protozero::ConstBytes arrangement_overlay() const { return at<7>().as_bytes(); }
has_selector_overlay()147   bool has_selector_overlay() const { return at<8>().valid(); }
selector_overlay()148   ::protozero::ConstBytes selector_overlay() const { return at<8>().as_bytes(); }
has_dense_null_overlay()149   bool has_dense_null_overlay() const { return at<9>().valid(); }
dense_null_overlay()150   ::protozero::ConstBytes dense_null_overlay() const { return at<9>().as_bytes(); }
151 };
152 
153 class SerializedColumn_Storage : public ::protozero::Message {
154  public:
155   using Decoder = SerializedColumn_Storage_Decoder;
156   enum : int32_t {
157     kDummyStorageFieldNumber = 1,
158     kIdStorageFieldNumber = 2,
159     kNumericStorageFieldNumber = 3,
160     kSetIdStorageFieldNumber = 4,
161     kStringStorageFieldNumber = 5,
162     kNullOverlayFieldNumber = 6,
163     kArrangementOverlayFieldNumber = 7,
164     kSelectorOverlayFieldNumber = 8,
165     kDenseNullOverlayFieldNumber = 9,
166   };
GetName()167   static constexpr const char* GetName() { return ".perfetto.protos.SerializedColumn.Storage"; }
168 
169   using DummyStorage = ::perfetto::protos::pbzero::SerializedColumn_Storage_DummyStorage;
170   using IdStorage = ::perfetto::protos::pbzero::SerializedColumn_Storage_IdStorage;
171   using NumericStorage = ::perfetto::protos::pbzero::SerializedColumn_Storage_NumericStorage;
172   using SetIdStorage = ::perfetto::protos::pbzero::SerializedColumn_Storage_SetIdStorage;
173   using StringStorage = ::perfetto::protos::pbzero::SerializedColumn_Storage_StringStorage;
174   using NullOverlay = ::perfetto::protos::pbzero::SerializedColumn_Storage_NullOverlay;
175   using ArrangementOverlay = ::perfetto::protos::pbzero::SerializedColumn_Storage_ArrangementOverlay;
176   using SelectorOverlay = ::perfetto::protos::pbzero::SerializedColumn_Storage_SelectorOverlay;
177   using DenseNullOverlay = ::perfetto::protos::pbzero::SerializedColumn_Storage_DenseNullOverlay;
178 
179   using FieldMetadata_DummyStorage =
180     ::protozero::proto_utils::FieldMetadata<
181       1,
182       ::protozero::proto_utils::RepetitionType::kNotRepeated,
183       ::protozero::proto_utils::ProtoSchemaType::kMessage,
184       SerializedColumn_Storage_DummyStorage,
185       SerializedColumn_Storage>;
186 
187   static constexpr FieldMetadata_DummyStorage kDummyStorage{};
set_dummy_storage()188   template <typename T = SerializedColumn_Storage_DummyStorage> T* set_dummy_storage() {
189     return BeginNestedMessage<T>(1);
190   }
191 
192 
193   using FieldMetadata_IdStorage =
194     ::protozero::proto_utils::FieldMetadata<
195       2,
196       ::protozero::proto_utils::RepetitionType::kNotRepeated,
197       ::protozero::proto_utils::ProtoSchemaType::kMessage,
198       SerializedColumn_Storage_IdStorage,
199       SerializedColumn_Storage>;
200 
201   static constexpr FieldMetadata_IdStorage kIdStorage{};
set_id_storage()202   template <typename T = SerializedColumn_Storage_IdStorage> T* set_id_storage() {
203     return BeginNestedMessage<T>(2);
204   }
205 
206 
207   using FieldMetadata_NumericStorage =
208     ::protozero::proto_utils::FieldMetadata<
209       3,
210       ::protozero::proto_utils::RepetitionType::kNotRepeated,
211       ::protozero::proto_utils::ProtoSchemaType::kMessage,
212       SerializedColumn_Storage_NumericStorage,
213       SerializedColumn_Storage>;
214 
215   static constexpr FieldMetadata_NumericStorage kNumericStorage{};
set_numeric_storage()216   template <typename T = SerializedColumn_Storage_NumericStorage> T* set_numeric_storage() {
217     return BeginNestedMessage<T>(3);
218   }
219 
220 
221   using FieldMetadata_SetIdStorage =
222     ::protozero::proto_utils::FieldMetadata<
223       4,
224       ::protozero::proto_utils::RepetitionType::kNotRepeated,
225       ::protozero::proto_utils::ProtoSchemaType::kMessage,
226       SerializedColumn_Storage_SetIdStorage,
227       SerializedColumn_Storage>;
228 
229   static constexpr FieldMetadata_SetIdStorage kSetIdStorage{};
set_set_id_storage()230   template <typename T = SerializedColumn_Storage_SetIdStorage> T* set_set_id_storage() {
231     return BeginNestedMessage<T>(4);
232   }
233 
234 
235   using FieldMetadata_StringStorage =
236     ::protozero::proto_utils::FieldMetadata<
237       5,
238       ::protozero::proto_utils::RepetitionType::kNotRepeated,
239       ::protozero::proto_utils::ProtoSchemaType::kMessage,
240       SerializedColumn_Storage_StringStorage,
241       SerializedColumn_Storage>;
242 
243   static constexpr FieldMetadata_StringStorage kStringStorage{};
set_string_storage()244   template <typename T = SerializedColumn_Storage_StringStorage> T* set_string_storage() {
245     return BeginNestedMessage<T>(5);
246   }
247 
248 
249   using FieldMetadata_NullOverlay =
250     ::protozero::proto_utils::FieldMetadata<
251       6,
252       ::protozero::proto_utils::RepetitionType::kNotRepeated,
253       ::protozero::proto_utils::ProtoSchemaType::kMessage,
254       SerializedColumn_Storage_NullOverlay,
255       SerializedColumn_Storage>;
256 
257   static constexpr FieldMetadata_NullOverlay kNullOverlay{};
set_null_overlay()258   template <typename T = SerializedColumn_Storage_NullOverlay> T* set_null_overlay() {
259     return BeginNestedMessage<T>(6);
260   }
261 
262 
263   using FieldMetadata_ArrangementOverlay =
264     ::protozero::proto_utils::FieldMetadata<
265       7,
266       ::protozero::proto_utils::RepetitionType::kNotRepeated,
267       ::protozero::proto_utils::ProtoSchemaType::kMessage,
268       SerializedColumn_Storage_ArrangementOverlay,
269       SerializedColumn_Storage>;
270 
271   static constexpr FieldMetadata_ArrangementOverlay kArrangementOverlay{};
set_arrangement_overlay()272   template <typename T = SerializedColumn_Storage_ArrangementOverlay> T* set_arrangement_overlay() {
273     return BeginNestedMessage<T>(7);
274   }
275 
276 
277   using FieldMetadata_SelectorOverlay =
278     ::protozero::proto_utils::FieldMetadata<
279       8,
280       ::protozero::proto_utils::RepetitionType::kNotRepeated,
281       ::protozero::proto_utils::ProtoSchemaType::kMessage,
282       SerializedColumn_Storage_SelectorOverlay,
283       SerializedColumn_Storage>;
284 
285   static constexpr FieldMetadata_SelectorOverlay kSelectorOverlay{};
set_selector_overlay()286   template <typename T = SerializedColumn_Storage_SelectorOverlay> T* set_selector_overlay() {
287     return BeginNestedMessage<T>(8);
288   }
289 
290 
291   using FieldMetadata_DenseNullOverlay =
292     ::protozero::proto_utils::FieldMetadata<
293       9,
294       ::protozero::proto_utils::RepetitionType::kNotRepeated,
295       ::protozero::proto_utils::ProtoSchemaType::kMessage,
296       SerializedColumn_Storage_DenseNullOverlay,
297       SerializedColumn_Storage>;
298 
299   static constexpr FieldMetadata_DenseNullOverlay kDenseNullOverlay{};
set_dense_null_overlay()300   template <typename T = SerializedColumn_Storage_DenseNullOverlay> T* set_dense_null_overlay() {
301     return BeginNestedMessage<T>(9);
302   }
303 
304 };
305 
306 class SerializedColumn_Storage_DenseNullOverlay_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
307  public:
SerializedColumn_Storage_DenseNullOverlay_Decoder(const uint8_t * data,size_t len)308   SerializedColumn_Storage_DenseNullOverlay_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
SerializedColumn_Storage_DenseNullOverlay_Decoder(const std::string & raw)309   explicit SerializedColumn_Storage_DenseNullOverlay_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
SerializedColumn_Storage_DenseNullOverlay_Decoder(const::protozero::ConstBytes & raw)310   explicit SerializedColumn_Storage_DenseNullOverlay_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
has_bit_vector()311   bool has_bit_vector() const { return at<1>().valid(); }
bit_vector()312   ::protozero::ConstBytes bit_vector() const { return at<1>().as_bytes(); }
has_storage()313   bool has_storage() const { return at<2>().valid(); }
storage()314   ::protozero::ConstBytes storage() const { return at<2>().as_bytes(); }
315 };
316 
317 class SerializedColumn_Storage_DenseNullOverlay : public ::protozero::Message {
318  public:
319   using Decoder = SerializedColumn_Storage_DenseNullOverlay_Decoder;
320   enum : int32_t {
321     kBitVectorFieldNumber = 1,
322     kStorageFieldNumber = 2,
323   };
GetName()324   static constexpr const char* GetName() { return ".perfetto.protos.SerializedColumn.Storage.DenseNullOverlay"; }
325 
326 
327   using FieldMetadata_BitVector =
328     ::protozero::proto_utils::FieldMetadata<
329       1,
330       ::protozero::proto_utils::RepetitionType::kNotRepeated,
331       ::protozero::proto_utils::ProtoSchemaType::kMessage,
332       SerializedColumn_BitVector,
333       SerializedColumn_Storage_DenseNullOverlay>;
334 
335   static constexpr FieldMetadata_BitVector kBitVector{};
set_bit_vector()336   template <typename T = SerializedColumn_BitVector> T* set_bit_vector() {
337     return BeginNestedMessage<T>(1);
338   }
339 
340 
341   using FieldMetadata_Storage =
342     ::protozero::proto_utils::FieldMetadata<
343       2,
344       ::protozero::proto_utils::RepetitionType::kNotRepeated,
345       ::protozero::proto_utils::ProtoSchemaType::kMessage,
346       SerializedColumn_Storage,
347       SerializedColumn_Storage_DenseNullOverlay>;
348 
349   static constexpr FieldMetadata_Storage kStorage{};
set_storage()350   template <typename T = SerializedColumn_Storage> T* set_storage() {
351     return BeginNestedMessage<T>(2);
352   }
353 
354 };
355 
356 class SerializedColumn_Storage_SelectorOverlay_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
357  public:
SerializedColumn_Storage_SelectorOverlay_Decoder(const uint8_t * data,size_t len)358   SerializedColumn_Storage_SelectorOverlay_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
SerializedColumn_Storage_SelectorOverlay_Decoder(const std::string & raw)359   explicit SerializedColumn_Storage_SelectorOverlay_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
SerializedColumn_Storage_SelectorOverlay_Decoder(const::protozero::ConstBytes & raw)360   explicit SerializedColumn_Storage_SelectorOverlay_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
has_bit_vector()361   bool has_bit_vector() const { return at<1>().valid(); }
bit_vector()362   ::protozero::ConstBytes bit_vector() const { return at<1>().as_bytes(); }
has_storage()363   bool has_storage() const { return at<2>().valid(); }
storage()364   ::protozero::ConstBytes storage() const { return at<2>().as_bytes(); }
365 };
366 
367 class SerializedColumn_Storage_SelectorOverlay : public ::protozero::Message {
368  public:
369   using Decoder = SerializedColumn_Storage_SelectorOverlay_Decoder;
370   enum : int32_t {
371     kBitVectorFieldNumber = 1,
372     kStorageFieldNumber = 2,
373   };
GetName()374   static constexpr const char* GetName() { return ".perfetto.protos.SerializedColumn.Storage.SelectorOverlay"; }
375 
376 
377   using FieldMetadata_BitVector =
378     ::protozero::proto_utils::FieldMetadata<
379       1,
380       ::protozero::proto_utils::RepetitionType::kNotRepeated,
381       ::protozero::proto_utils::ProtoSchemaType::kMessage,
382       SerializedColumn_BitVector,
383       SerializedColumn_Storage_SelectorOverlay>;
384 
385   static constexpr FieldMetadata_BitVector kBitVector{};
set_bit_vector()386   template <typename T = SerializedColumn_BitVector> T* set_bit_vector() {
387     return BeginNestedMessage<T>(1);
388   }
389 
390 
391   using FieldMetadata_Storage =
392     ::protozero::proto_utils::FieldMetadata<
393       2,
394       ::protozero::proto_utils::RepetitionType::kNotRepeated,
395       ::protozero::proto_utils::ProtoSchemaType::kMessage,
396       SerializedColumn_Storage,
397       SerializedColumn_Storage_SelectorOverlay>;
398 
399   static constexpr FieldMetadata_Storage kStorage{};
set_storage()400   template <typename T = SerializedColumn_Storage> T* set_storage() {
401     return BeginNestedMessage<T>(2);
402   }
403 
404 };
405 
406 class SerializedColumn_Storage_ArrangementOverlay_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
407  public:
SerializedColumn_Storage_ArrangementOverlay_Decoder(const uint8_t * data,size_t len)408   SerializedColumn_Storage_ArrangementOverlay_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
SerializedColumn_Storage_ArrangementOverlay_Decoder(const std::string & raw)409   explicit SerializedColumn_Storage_ArrangementOverlay_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
SerializedColumn_Storage_ArrangementOverlay_Decoder(const::protozero::ConstBytes & raw)410   explicit SerializedColumn_Storage_ArrangementOverlay_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
has_values()411   bool has_values() const { return at<1>().valid(); }
values()412   ::protozero::ConstBytes values() const { return at<1>().as_bytes(); }
has_storage()413   bool has_storage() const { return at<2>().valid(); }
storage()414   ::protozero::ConstBytes storage() const { return at<2>().as_bytes(); }
415 };
416 
417 class SerializedColumn_Storage_ArrangementOverlay : public ::protozero::Message {
418  public:
419   using Decoder = SerializedColumn_Storage_ArrangementOverlay_Decoder;
420   enum : int32_t {
421     kValuesFieldNumber = 1,
422     kStorageFieldNumber = 2,
423   };
GetName()424   static constexpr const char* GetName() { return ".perfetto.protos.SerializedColumn.Storage.ArrangementOverlay"; }
425 
426 
427   using FieldMetadata_Values =
428     ::protozero::proto_utils::FieldMetadata<
429       1,
430       ::protozero::proto_utils::RepetitionType::kNotRepeated,
431       ::protozero::proto_utils::ProtoSchemaType::kBytes,
432       std::string,
433       SerializedColumn_Storage_ArrangementOverlay>;
434 
435   static constexpr FieldMetadata_Values kValues{};
set_values(const uint8_t * data,size_t size)436   void set_values(const uint8_t* data, size_t size) {
437     AppendBytes(FieldMetadata_Values::kFieldId, data, size);
438   }
set_values(::protozero::ConstBytes bytes)439   void set_values(::protozero::ConstBytes bytes) {
440     AppendBytes(FieldMetadata_Values::kFieldId, bytes.data, bytes.size);
441   }
set_values(std::string value)442   void set_values(std::string value) {
443     static constexpr uint32_t field_id = FieldMetadata_Values::kFieldId;
444     // Call the appropriate protozero::Message::Append(field_id, ...)
445     // method based on the type of the field.
446     ::protozero::internal::FieldWriter<
447       ::protozero::proto_utils::ProtoSchemaType::kBytes>
448         ::Append(*this, field_id, value);
449   }
450 
451   using FieldMetadata_Storage =
452     ::protozero::proto_utils::FieldMetadata<
453       2,
454       ::protozero::proto_utils::RepetitionType::kNotRepeated,
455       ::protozero::proto_utils::ProtoSchemaType::kMessage,
456       SerializedColumn_Storage,
457       SerializedColumn_Storage_ArrangementOverlay>;
458 
459   static constexpr FieldMetadata_Storage kStorage{};
set_storage()460   template <typename T = SerializedColumn_Storage> T* set_storage() {
461     return BeginNestedMessage<T>(2);
462   }
463 
464 };
465 
466 class SerializedColumn_Storage_NullOverlay_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
467  public:
SerializedColumn_Storage_NullOverlay_Decoder(const uint8_t * data,size_t len)468   SerializedColumn_Storage_NullOverlay_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
SerializedColumn_Storage_NullOverlay_Decoder(const std::string & raw)469   explicit SerializedColumn_Storage_NullOverlay_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
SerializedColumn_Storage_NullOverlay_Decoder(const::protozero::ConstBytes & raw)470   explicit SerializedColumn_Storage_NullOverlay_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
has_bit_vector()471   bool has_bit_vector() const { return at<1>().valid(); }
bit_vector()472   ::protozero::ConstBytes bit_vector() const { return at<1>().as_bytes(); }
has_storage()473   bool has_storage() const { return at<2>().valid(); }
storage()474   ::protozero::ConstBytes storage() const { return at<2>().as_bytes(); }
475 };
476 
477 class SerializedColumn_Storage_NullOverlay : public ::protozero::Message {
478  public:
479   using Decoder = SerializedColumn_Storage_NullOverlay_Decoder;
480   enum : int32_t {
481     kBitVectorFieldNumber = 1,
482     kStorageFieldNumber = 2,
483   };
GetName()484   static constexpr const char* GetName() { return ".perfetto.protos.SerializedColumn.Storage.NullOverlay"; }
485 
486 
487   using FieldMetadata_BitVector =
488     ::protozero::proto_utils::FieldMetadata<
489       1,
490       ::protozero::proto_utils::RepetitionType::kNotRepeated,
491       ::protozero::proto_utils::ProtoSchemaType::kMessage,
492       SerializedColumn_BitVector,
493       SerializedColumn_Storage_NullOverlay>;
494 
495   static constexpr FieldMetadata_BitVector kBitVector{};
set_bit_vector()496   template <typename T = SerializedColumn_BitVector> T* set_bit_vector() {
497     return BeginNestedMessage<T>(1);
498   }
499 
500 
501   using FieldMetadata_Storage =
502     ::protozero::proto_utils::FieldMetadata<
503       2,
504       ::protozero::proto_utils::RepetitionType::kNotRepeated,
505       ::protozero::proto_utils::ProtoSchemaType::kMessage,
506       SerializedColumn_Storage,
507       SerializedColumn_Storage_NullOverlay>;
508 
509   static constexpr FieldMetadata_Storage kStorage{};
set_storage()510   template <typename T = SerializedColumn_Storage> T* set_storage() {
511     return BeginNestedMessage<T>(2);
512   }
513 
514 };
515 
516 class SerializedColumn_Storage_StringStorage_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
517  public:
SerializedColumn_Storage_StringStorage_Decoder(const uint8_t * data,size_t len)518   SerializedColumn_Storage_StringStorage_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
SerializedColumn_Storage_StringStorage_Decoder(const std::string & raw)519   explicit SerializedColumn_Storage_StringStorage_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
SerializedColumn_Storage_StringStorage_Decoder(const::protozero::ConstBytes & raw)520   explicit SerializedColumn_Storage_StringStorage_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
has_values()521   bool has_values() const { return at<1>().valid(); }
values()522   ::protozero::ConstBytes values() const { return at<1>().as_bytes(); }
has_is_sorted()523   bool has_is_sorted() const { return at<2>().valid(); }
is_sorted()524   bool is_sorted() const { return at<2>().as_bool(); }
525 };
526 
527 class SerializedColumn_Storage_StringStorage : public ::protozero::Message {
528  public:
529   using Decoder = SerializedColumn_Storage_StringStorage_Decoder;
530   enum : int32_t {
531     kValuesFieldNumber = 1,
532     kIsSortedFieldNumber = 2,
533   };
GetName()534   static constexpr const char* GetName() { return ".perfetto.protos.SerializedColumn.Storage.StringStorage"; }
535 
536 
537   using FieldMetadata_Values =
538     ::protozero::proto_utils::FieldMetadata<
539       1,
540       ::protozero::proto_utils::RepetitionType::kNotRepeated,
541       ::protozero::proto_utils::ProtoSchemaType::kBytes,
542       std::string,
543       SerializedColumn_Storage_StringStorage>;
544 
545   static constexpr FieldMetadata_Values kValues{};
set_values(const uint8_t * data,size_t size)546   void set_values(const uint8_t* data, size_t size) {
547     AppendBytes(FieldMetadata_Values::kFieldId, data, size);
548   }
set_values(::protozero::ConstBytes bytes)549   void set_values(::protozero::ConstBytes bytes) {
550     AppendBytes(FieldMetadata_Values::kFieldId, bytes.data, bytes.size);
551   }
set_values(std::string value)552   void set_values(std::string value) {
553     static constexpr uint32_t field_id = FieldMetadata_Values::kFieldId;
554     // Call the appropriate protozero::Message::Append(field_id, ...)
555     // method based on the type of the field.
556     ::protozero::internal::FieldWriter<
557       ::protozero::proto_utils::ProtoSchemaType::kBytes>
558         ::Append(*this, field_id, value);
559   }
560 
561   using FieldMetadata_IsSorted =
562     ::protozero::proto_utils::FieldMetadata<
563       2,
564       ::protozero::proto_utils::RepetitionType::kNotRepeated,
565       ::protozero::proto_utils::ProtoSchemaType::kBool,
566       bool,
567       SerializedColumn_Storage_StringStorage>;
568 
569   static constexpr FieldMetadata_IsSorted kIsSorted{};
set_is_sorted(bool value)570   void set_is_sorted(bool value) {
571     static constexpr uint32_t field_id = FieldMetadata_IsSorted::kFieldId;
572     // Call the appropriate protozero::Message::Append(field_id, ...)
573     // method based on the type of the field.
574     ::protozero::internal::FieldWriter<
575       ::protozero::proto_utils::ProtoSchemaType::kBool>
576         ::Append(*this, field_id, value);
577   }
578 };
579 
580 class SerializedColumn_Storage_SetIdStorage_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
581  public:
SerializedColumn_Storage_SetIdStorage_Decoder(const uint8_t * data,size_t len)582   SerializedColumn_Storage_SetIdStorage_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
SerializedColumn_Storage_SetIdStorage_Decoder(const std::string & raw)583   explicit SerializedColumn_Storage_SetIdStorage_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
SerializedColumn_Storage_SetIdStorage_Decoder(const::protozero::ConstBytes & raw)584   explicit SerializedColumn_Storage_SetIdStorage_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
has_values()585   bool has_values() const { return at<1>().valid(); }
values()586   ::protozero::ConstBytes values() const { return at<1>().as_bytes(); }
587 };
588 
589 class SerializedColumn_Storage_SetIdStorage : public ::protozero::Message {
590  public:
591   using Decoder = SerializedColumn_Storage_SetIdStorage_Decoder;
592   enum : int32_t {
593     kValuesFieldNumber = 1,
594   };
GetName()595   static constexpr const char* GetName() { return ".perfetto.protos.SerializedColumn.Storage.SetIdStorage"; }
596 
597 
598   using FieldMetadata_Values =
599     ::protozero::proto_utils::FieldMetadata<
600       1,
601       ::protozero::proto_utils::RepetitionType::kNotRepeated,
602       ::protozero::proto_utils::ProtoSchemaType::kBytes,
603       std::string,
604       SerializedColumn_Storage_SetIdStorage>;
605 
606   static constexpr FieldMetadata_Values kValues{};
set_values(const uint8_t * data,size_t size)607   void set_values(const uint8_t* data, size_t size) {
608     AppendBytes(FieldMetadata_Values::kFieldId, data, size);
609   }
set_values(::protozero::ConstBytes bytes)610   void set_values(::protozero::ConstBytes bytes) {
611     AppendBytes(FieldMetadata_Values::kFieldId, bytes.data, bytes.size);
612   }
set_values(std::string value)613   void set_values(std::string value) {
614     static constexpr uint32_t field_id = FieldMetadata_Values::kFieldId;
615     // Call the appropriate protozero::Message::Append(field_id, ...)
616     // method based on the type of the field.
617     ::protozero::internal::FieldWriter<
618       ::protozero::proto_utils::ProtoSchemaType::kBytes>
619         ::Append(*this, field_id, value);
620   }
621 };
622 
623 class SerializedColumn_Storage_NumericStorage_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
624  public:
SerializedColumn_Storage_NumericStorage_Decoder(const uint8_t * data,size_t len)625   SerializedColumn_Storage_NumericStorage_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
SerializedColumn_Storage_NumericStorage_Decoder(const std::string & raw)626   explicit SerializedColumn_Storage_NumericStorage_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
SerializedColumn_Storage_NumericStorage_Decoder(const::protozero::ConstBytes & raw)627   explicit SerializedColumn_Storage_NumericStorage_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
has_values()628   bool has_values() const { return at<1>().valid(); }
values()629   ::protozero::ConstBytes values() const { return at<1>().as_bytes(); }
has_is_sorted()630   bool has_is_sorted() const { return at<2>().valid(); }
is_sorted()631   bool is_sorted() const { return at<2>().as_bool(); }
has_column_type()632   bool has_column_type() const { return at<3>().valid(); }
column_type()633   uint32_t column_type() const { return at<3>().as_uint32(); }
634 };
635 
636 class SerializedColumn_Storage_NumericStorage : public ::protozero::Message {
637  public:
638   using Decoder = SerializedColumn_Storage_NumericStorage_Decoder;
639   enum : int32_t {
640     kValuesFieldNumber = 1,
641     kIsSortedFieldNumber = 2,
642     kColumnTypeFieldNumber = 3,
643   };
GetName()644   static constexpr const char* GetName() { return ".perfetto.protos.SerializedColumn.Storage.NumericStorage"; }
645 
646 
647   using FieldMetadata_Values =
648     ::protozero::proto_utils::FieldMetadata<
649       1,
650       ::protozero::proto_utils::RepetitionType::kNotRepeated,
651       ::protozero::proto_utils::ProtoSchemaType::kBytes,
652       std::string,
653       SerializedColumn_Storage_NumericStorage>;
654 
655   static constexpr FieldMetadata_Values kValues{};
set_values(const uint8_t * data,size_t size)656   void set_values(const uint8_t* data, size_t size) {
657     AppendBytes(FieldMetadata_Values::kFieldId, data, size);
658   }
set_values(::protozero::ConstBytes bytes)659   void set_values(::protozero::ConstBytes bytes) {
660     AppendBytes(FieldMetadata_Values::kFieldId, bytes.data, bytes.size);
661   }
set_values(std::string value)662   void set_values(std::string value) {
663     static constexpr uint32_t field_id = FieldMetadata_Values::kFieldId;
664     // Call the appropriate protozero::Message::Append(field_id, ...)
665     // method based on the type of the field.
666     ::protozero::internal::FieldWriter<
667       ::protozero::proto_utils::ProtoSchemaType::kBytes>
668         ::Append(*this, field_id, value);
669   }
670 
671   using FieldMetadata_IsSorted =
672     ::protozero::proto_utils::FieldMetadata<
673       2,
674       ::protozero::proto_utils::RepetitionType::kNotRepeated,
675       ::protozero::proto_utils::ProtoSchemaType::kBool,
676       bool,
677       SerializedColumn_Storage_NumericStorage>;
678 
679   static constexpr FieldMetadata_IsSorted kIsSorted{};
set_is_sorted(bool value)680   void set_is_sorted(bool value) {
681     static constexpr uint32_t field_id = FieldMetadata_IsSorted::kFieldId;
682     // Call the appropriate protozero::Message::Append(field_id, ...)
683     // method based on the type of the field.
684     ::protozero::internal::FieldWriter<
685       ::protozero::proto_utils::ProtoSchemaType::kBool>
686         ::Append(*this, field_id, value);
687   }
688 
689   using FieldMetadata_ColumnType =
690     ::protozero::proto_utils::FieldMetadata<
691       3,
692       ::protozero::proto_utils::RepetitionType::kNotRepeated,
693       ::protozero::proto_utils::ProtoSchemaType::kUint32,
694       uint32_t,
695       SerializedColumn_Storage_NumericStorage>;
696 
697   static constexpr FieldMetadata_ColumnType kColumnType{};
set_column_type(uint32_t value)698   void set_column_type(uint32_t value) {
699     static constexpr uint32_t field_id = FieldMetadata_ColumnType::kFieldId;
700     // Call the appropriate protozero::Message::Append(field_id, ...)
701     // method based on the type of the field.
702     ::protozero::internal::FieldWriter<
703       ::protozero::proto_utils::ProtoSchemaType::kUint32>
704         ::Append(*this, field_id, value);
705   }
706 };
707 
708 class SerializedColumn_Storage_IdStorage_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
709  public:
SerializedColumn_Storage_IdStorage_Decoder(const uint8_t * data,size_t len)710   SerializedColumn_Storage_IdStorage_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
SerializedColumn_Storage_IdStorage_Decoder(const std::string & raw)711   explicit SerializedColumn_Storage_IdStorage_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
SerializedColumn_Storage_IdStorage_Decoder(const::protozero::ConstBytes & raw)712   explicit SerializedColumn_Storage_IdStorage_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
has_size()713   bool has_size() const { return at<1>().valid(); }
size()714   uint64_t size() const { return at<1>().as_uint64(); }
715 };
716 
717 class SerializedColumn_Storage_IdStorage : public ::protozero::Message {
718  public:
719   using Decoder = SerializedColumn_Storage_IdStorage_Decoder;
720   enum : int32_t {
721     kSizeFieldNumber = 1,
722   };
GetName()723   static constexpr const char* GetName() { return ".perfetto.protos.SerializedColumn.Storage.IdStorage"; }
724 
725 
726   using FieldMetadata_Size =
727     ::protozero::proto_utils::FieldMetadata<
728       1,
729       ::protozero::proto_utils::RepetitionType::kNotRepeated,
730       ::protozero::proto_utils::ProtoSchemaType::kUint64,
731       uint64_t,
732       SerializedColumn_Storage_IdStorage>;
733 
734   static constexpr FieldMetadata_Size kSize{};
set_size(uint64_t value)735   void set_size(uint64_t value) {
736     static constexpr uint32_t field_id = FieldMetadata_Size::kFieldId;
737     // Call the appropriate protozero::Message::Append(field_id, ...)
738     // method based on the type of the field.
739     ::protozero::internal::FieldWriter<
740       ::protozero::proto_utils::ProtoSchemaType::kUint64>
741         ::Append(*this, field_id, value);
742   }
743 };
744 
745 class SerializedColumn_Storage_DummyStorage_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/0, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
746  public:
SerializedColumn_Storage_DummyStorage_Decoder(const uint8_t * data,size_t len)747   SerializedColumn_Storage_DummyStorage_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
SerializedColumn_Storage_DummyStorage_Decoder(const std::string & raw)748   explicit SerializedColumn_Storage_DummyStorage_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
SerializedColumn_Storage_DummyStorage_Decoder(const::protozero::ConstBytes & raw)749   explicit SerializedColumn_Storage_DummyStorage_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
750 };
751 
752 class SerializedColumn_Storage_DummyStorage : public ::protozero::Message {
753  public:
754   using Decoder = SerializedColumn_Storage_DummyStorage_Decoder;
GetName()755   static constexpr const char* GetName() { return ".perfetto.protos.SerializedColumn.Storage.DummyStorage"; }
756 
757 };
758 
759 class SerializedColumn_BitVector_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
760  public:
SerializedColumn_BitVector_Decoder(const uint8_t * data,size_t len)761   SerializedColumn_BitVector_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
SerializedColumn_BitVector_Decoder(const std::string & raw)762   explicit SerializedColumn_BitVector_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
SerializedColumn_BitVector_Decoder(const::protozero::ConstBytes & raw)763   explicit SerializedColumn_BitVector_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
has_words()764   bool has_words() const { return at<1>().valid(); }
words()765   ::protozero::ConstBytes words() const { return at<1>().as_bytes(); }
has_counts()766   bool has_counts() const { return at<2>().valid(); }
counts()767   ::protozero::ConstBytes counts() const { return at<2>().as_bytes(); }
has_size()768   bool has_size() const { return at<3>().valid(); }
size()769   uint32_t size() const { return at<3>().as_uint32(); }
770 };
771 
772 class SerializedColumn_BitVector : public ::protozero::Message {
773  public:
774   using Decoder = SerializedColumn_BitVector_Decoder;
775   enum : int32_t {
776     kWordsFieldNumber = 1,
777     kCountsFieldNumber = 2,
778     kSizeFieldNumber = 3,
779   };
GetName()780   static constexpr const char* GetName() { return ".perfetto.protos.SerializedColumn.BitVector"; }
781 
782 
783   using FieldMetadata_Words =
784     ::protozero::proto_utils::FieldMetadata<
785       1,
786       ::protozero::proto_utils::RepetitionType::kNotRepeated,
787       ::protozero::proto_utils::ProtoSchemaType::kBytes,
788       std::string,
789       SerializedColumn_BitVector>;
790 
791   static constexpr FieldMetadata_Words kWords{};
set_words(const uint8_t * data,size_t size)792   void set_words(const uint8_t* data, size_t size) {
793     AppendBytes(FieldMetadata_Words::kFieldId, data, size);
794   }
set_words(::protozero::ConstBytes bytes)795   void set_words(::protozero::ConstBytes bytes) {
796     AppendBytes(FieldMetadata_Words::kFieldId, bytes.data, bytes.size);
797   }
set_words(std::string value)798   void set_words(std::string value) {
799     static constexpr uint32_t field_id = FieldMetadata_Words::kFieldId;
800     // Call the appropriate protozero::Message::Append(field_id, ...)
801     // method based on the type of the field.
802     ::protozero::internal::FieldWriter<
803       ::protozero::proto_utils::ProtoSchemaType::kBytes>
804         ::Append(*this, field_id, value);
805   }
806 
807   using FieldMetadata_Counts =
808     ::protozero::proto_utils::FieldMetadata<
809       2,
810       ::protozero::proto_utils::RepetitionType::kNotRepeated,
811       ::protozero::proto_utils::ProtoSchemaType::kBytes,
812       std::string,
813       SerializedColumn_BitVector>;
814 
815   static constexpr FieldMetadata_Counts kCounts{};
set_counts(const uint8_t * data,size_t size)816   void set_counts(const uint8_t* data, size_t size) {
817     AppendBytes(FieldMetadata_Counts::kFieldId, data, size);
818   }
set_counts(::protozero::ConstBytes bytes)819   void set_counts(::protozero::ConstBytes bytes) {
820     AppendBytes(FieldMetadata_Counts::kFieldId, bytes.data, bytes.size);
821   }
set_counts(std::string value)822   void set_counts(std::string value) {
823     static constexpr uint32_t field_id = FieldMetadata_Counts::kFieldId;
824     // Call the appropriate protozero::Message::Append(field_id, ...)
825     // method based on the type of the field.
826     ::protozero::internal::FieldWriter<
827       ::protozero::proto_utils::ProtoSchemaType::kBytes>
828         ::Append(*this, field_id, value);
829   }
830 
831   using FieldMetadata_Size =
832     ::protozero::proto_utils::FieldMetadata<
833       3,
834       ::protozero::proto_utils::RepetitionType::kNotRepeated,
835       ::protozero::proto_utils::ProtoSchemaType::kUint32,
836       uint32_t,
837       SerializedColumn_BitVector>;
838 
839   static constexpr FieldMetadata_Size kSize{};
set_size(uint32_t value)840   void set_size(uint32_t value) {
841     static constexpr uint32_t field_id = FieldMetadata_Size::kFieldId;
842     // Call the appropriate protozero::Message::Append(field_id, ...)
843     // method based on the type of the field.
844     ::protozero::internal::FieldWriter<
845       ::protozero::proto_utils::ProtoSchemaType::kUint32>
846         ::Append(*this, field_id, value);
847   }
848 };
849 
850 class SerializedTraceProcessorPacket_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
851  public:
SerializedTraceProcessorPacket_Decoder(const uint8_t * data,size_t len)852   SerializedTraceProcessorPacket_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
SerializedTraceProcessorPacket_Decoder(const std::string & raw)853   explicit SerializedTraceProcessorPacket_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
SerializedTraceProcessorPacket_Decoder(const::protozero::ConstBytes & raw)854   explicit SerializedTraceProcessorPacket_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
has_column()855   bool has_column() const { return at<1>().valid(); }
column()856   ::protozero::ConstBytes column() const { return at<1>().as_bytes(); }
857 };
858 
859 class SerializedTraceProcessorPacket : public ::protozero::Message {
860  public:
861   using Decoder = SerializedTraceProcessorPacket_Decoder;
862   enum : int32_t {
863     kColumnFieldNumber = 1,
864   };
GetName()865   static constexpr const char* GetName() { return ".perfetto.protos.SerializedTraceProcessorPacket"; }
866 
867 
868   using FieldMetadata_Column =
869     ::protozero::proto_utils::FieldMetadata<
870       1,
871       ::protozero::proto_utils::RepetitionType::kNotRepeated,
872       ::protozero::proto_utils::ProtoSchemaType::kMessage,
873       SerializedColumn,
874       SerializedTraceProcessorPacket>;
875 
876   static constexpr FieldMetadata_Column kColumn{};
set_column()877   template <typename T = SerializedColumn> T* set_column() {
878     return BeginNestedMessage<T>(1);
879   }
880 
881 };
882 
883 class SerializedTraceProcessor_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
884  public:
SerializedTraceProcessor_Decoder(const uint8_t * data,size_t len)885   SerializedTraceProcessor_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
SerializedTraceProcessor_Decoder(const std::string & raw)886   explicit SerializedTraceProcessor_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
SerializedTraceProcessor_Decoder(const::protozero::ConstBytes & raw)887   explicit SerializedTraceProcessor_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
has_packet()888   bool has_packet() const { return at<1>().valid(); }
packet()889   ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> packet() const { return GetRepeated<::protozero::ConstBytes>(1); }
890 };
891 
892 class SerializedTraceProcessor : public ::protozero::Message {
893  public:
894   using Decoder = SerializedTraceProcessor_Decoder;
895   enum : int32_t {
896     kPacketFieldNumber = 1,
897   };
GetName()898   static constexpr const char* GetName() { return ".perfetto.protos.SerializedTraceProcessor"; }
899 
900 
901   using FieldMetadata_Packet =
902     ::protozero::proto_utils::FieldMetadata<
903       1,
904       ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
905       ::protozero::proto_utils::ProtoSchemaType::kMessage,
906       SerializedTraceProcessorPacket,
907       SerializedTraceProcessor>;
908 
909   static constexpr FieldMetadata_Packet kPacket{};
add_packet()910   template <typename T = SerializedTraceProcessorPacket> T* add_packet() {
911     return BeginNestedMessage<T>(1);
912   }
913 
914 };
915 
916 } // Namespace.
917 } // Namespace.
918 } // Namespace.
919 #endif  // Include guard.
920