1 // Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
2 
3 #ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_PROCESSOR_TRACE_PROCESSOR_PROTO_H_
4 #define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_PROCESSOR_TRACE_PROCESSOR_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 AppendTraceDataResult;
19 class ComputeMetricArgs;
20 class ComputeMetricResult;
21 class DescriptorProto;
22 class DescriptorSet;
23 class DisableAndReadMetatraceResult;
24 class EnableMetatraceArgs;
25 class FinalizeDataResult;
26 class QueryArgs;
27 class QueryResult;
28 class QueryResult_CellsBatch;
29 class RegisterSqlPackageArgs;
30 class RegisterSqlPackageArgs_Module;
31 class RegisterSqlPackageResult;
32 class ResetTraceProcessorArgs;
33 class StatusResult;
34 class TraceProcessorRpc;
35 namespace perfetto_pbzero_enum_ComputeMetricArgs {
36 enum ResultFormat : int32_t;
37 }  // namespace perfetto_pbzero_enum_ComputeMetricArgs
38 using ComputeMetricArgs_ResultFormat = perfetto_pbzero_enum_ComputeMetricArgs::ResultFormat;
39 enum MetatraceCategories : int32_t;
40 namespace perfetto_pbzero_enum_QueryResult_CellsBatch {
41 enum CellType : int32_t;
42 }  // namespace perfetto_pbzero_enum_QueryResult_CellsBatch
43 using QueryResult_CellsBatch_CellType = perfetto_pbzero_enum_QueryResult_CellsBatch::CellType;
44 namespace perfetto_pbzero_enum_ResetTraceProcessorArgs {
45 enum DropTrackEventDataBefore : int32_t;
46 }  // namespace perfetto_pbzero_enum_ResetTraceProcessorArgs
47 using ResetTraceProcessorArgs_DropTrackEventDataBefore = perfetto_pbzero_enum_ResetTraceProcessorArgs::DropTrackEventDataBefore;
48 namespace perfetto_pbzero_enum_ResetTraceProcessorArgs {
49 enum ParsingMode : int32_t;
50 }  // namespace perfetto_pbzero_enum_ResetTraceProcessorArgs
51 using ResetTraceProcessorArgs_ParsingMode = perfetto_pbzero_enum_ResetTraceProcessorArgs::ParsingMode;
52 namespace perfetto_pbzero_enum_TraceProcessorRpc {
53 enum TraceProcessorMethod : int32_t;
54 }  // namespace perfetto_pbzero_enum_TraceProcessorRpc
55 using TraceProcessorRpc_TraceProcessorMethod = perfetto_pbzero_enum_TraceProcessorRpc::TraceProcessorMethod;
56 } // Namespace pbzero.
57 } // Namespace protos.
58 } // Namespace perfetto.
59 
60 namespace perfetto {
61 namespace protos {
62 namespace pbzero {
63 
64 enum TraceProcessorApiVersion : int32_t {
65   TRACE_PROCESSOR_CURRENT_API_VERSION = 14,
66 };
67 
68 constexpr TraceProcessorApiVersion TraceProcessorApiVersion_MIN = TraceProcessorApiVersion::TRACE_PROCESSOR_CURRENT_API_VERSION;
69 constexpr TraceProcessorApiVersion TraceProcessorApiVersion_MAX = TraceProcessorApiVersion::TRACE_PROCESSOR_CURRENT_API_VERSION;
70 
71 
72 PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
TraceProcessorApiVersion_Name(::perfetto::protos::pbzero::TraceProcessorApiVersion value)73 const char* TraceProcessorApiVersion_Name(::perfetto::protos::pbzero::TraceProcessorApiVersion value) {
74   switch (value) {
75   case ::perfetto::protos::pbzero::TraceProcessorApiVersion::TRACE_PROCESSOR_CURRENT_API_VERSION:
76     return "TRACE_PROCESSOR_CURRENT_API_VERSION";
77   }
78   return "PBZERO_UNKNOWN_ENUM_VALUE";
79 }
80 
81 namespace perfetto_pbzero_enum_ResetTraceProcessorArgs {
82 enum DropTrackEventDataBefore : int32_t {
83   NO_DROP = 0,
84   TRACK_EVENT_RANGE_OF_INTEREST = 1,
85 };
86 } // namespace perfetto_pbzero_enum_ResetTraceProcessorArgs
87 using ResetTraceProcessorArgs_DropTrackEventDataBefore = perfetto_pbzero_enum_ResetTraceProcessorArgs::DropTrackEventDataBefore;
88 
89 
90 constexpr ResetTraceProcessorArgs_DropTrackEventDataBefore ResetTraceProcessorArgs_DropTrackEventDataBefore_MIN = ResetTraceProcessorArgs_DropTrackEventDataBefore::NO_DROP;
91 constexpr ResetTraceProcessorArgs_DropTrackEventDataBefore ResetTraceProcessorArgs_DropTrackEventDataBefore_MAX = ResetTraceProcessorArgs_DropTrackEventDataBefore::TRACK_EVENT_RANGE_OF_INTEREST;
92 
93 
94 PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
ResetTraceProcessorArgs_DropTrackEventDataBefore_Name(::perfetto::protos::pbzero::ResetTraceProcessorArgs_DropTrackEventDataBefore value)95 const char* ResetTraceProcessorArgs_DropTrackEventDataBefore_Name(::perfetto::protos::pbzero::ResetTraceProcessorArgs_DropTrackEventDataBefore value) {
96   switch (value) {
97   case ::perfetto::protos::pbzero::ResetTraceProcessorArgs_DropTrackEventDataBefore::NO_DROP:
98     return "NO_DROP";
99 
100   case ::perfetto::protos::pbzero::ResetTraceProcessorArgs_DropTrackEventDataBefore::TRACK_EVENT_RANGE_OF_INTEREST:
101     return "TRACK_EVENT_RANGE_OF_INTEREST";
102   }
103   return "PBZERO_UNKNOWN_ENUM_VALUE";
104 }
105 
106 namespace perfetto_pbzero_enum_ResetTraceProcessorArgs {
107 enum ParsingMode : int32_t {
108   DEFAULT = 0,
109   TOKENIZE_ONLY = 1,
110   TOKENIZE_AND_SORT = 2,
111 };
112 } // namespace perfetto_pbzero_enum_ResetTraceProcessorArgs
113 using ResetTraceProcessorArgs_ParsingMode = perfetto_pbzero_enum_ResetTraceProcessorArgs::ParsingMode;
114 
115 
116 constexpr ResetTraceProcessorArgs_ParsingMode ResetTraceProcessorArgs_ParsingMode_MIN = ResetTraceProcessorArgs_ParsingMode::DEFAULT;
117 constexpr ResetTraceProcessorArgs_ParsingMode ResetTraceProcessorArgs_ParsingMode_MAX = ResetTraceProcessorArgs_ParsingMode::TOKENIZE_AND_SORT;
118 
119 
120 PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
ResetTraceProcessorArgs_ParsingMode_Name(::perfetto::protos::pbzero::ResetTraceProcessorArgs_ParsingMode value)121 const char* ResetTraceProcessorArgs_ParsingMode_Name(::perfetto::protos::pbzero::ResetTraceProcessorArgs_ParsingMode value) {
122   switch (value) {
123   case ::perfetto::protos::pbzero::ResetTraceProcessorArgs_ParsingMode::DEFAULT:
124     return "DEFAULT";
125 
126   case ::perfetto::protos::pbzero::ResetTraceProcessorArgs_ParsingMode::TOKENIZE_ONLY:
127     return "TOKENIZE_ONLY";
128 
129   case ::perfetto::protos::pbzero::ResetTraceProcessorArgs_ParsingMode::TOKENIZE_AND_SORT:
130     return "TOKENIZE_AND_SORT";
131   }
132   return "PBZERO_UNKNOWN_ENUM_VALUE";
133 }
134 
135 namespace perfetto_pbzero_enum_ComputeMetricArgs {
136 enum ResultFormat : int32_t {
137   BINARY_PROTOBUF = 0,
138   TEXTPROTO = 1,
139   JSON = 2,
140 };
141 } // namespace perfetto_pbzero_enum_ComputeMetricArgs
142 using ComputeMetricArgs_ResultFormat = perfetto_pbzero_enum_ComputeMetricArgs::ResultFormat;
143 
144 
145 constexpr ComputeMetricArgs_ResultFormat ComputeMetricArgs_ResultFormat_MIN = ComputeMetricArgs_ResultFormat::BINARY_PROTOBUF;
146 constexpr ComputeMetricArgs_ResultFormat ComputeMetricArgs_ResultFormat_MAX = ComputeMetricArgs_ResultFormat::JSON;
147 
148 
149 PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
ComputeMetricArgs_ResultFormat_Name(::perfetto::protos::pbzero::ComputeMetricArgs_ResultFormat value)150 const char* ComputeMetricArgs_ResultFormat_Name(::perfetto::protos::pbzero::ComputeMetricArgs_ResultFormat value) {
151   switch (value) {
152   case ::perfetto::protos::pbzero::ComputeMetricArgs_ResultFormat::BINARY_PROTOBUF:
153     return "BINARY_PROTOBUF";
154 
155   case ::perfetto::protos::pbzero::ComputeMetricArgs_ResultFormat::TEXTPROTO:
156     return "TEXTPROTO";
157 
158   case ::perfetto::protos::pbzero::ComputeMetricArgs_ResultFormat::JSON:
159     return "JSON";
160   }
161   return "PBZERO_UNKNOWN_ENUM_VALUE";
162 }
163 
164 namespace perfetto_pbzero_enum_QueryResult_CellsBatch {
165 enum CellType : int32_t {
166   CELL_INVALID = 0,
167   CELL_NULL = 1,
168   CELL_VARINT = 2,
169   CELL_FLOAT64 = 3,
170   CELL_STRING = 4,
171   CELL_BLOB = 5,
172 };
173 } // namespace perfetto_pbzero_enum_QueryResult_CellsBatch
174 using QueryResult_CellsBatch_CellType = perfetto_pbzero_enum_QueryResult_CellsBatch::CellType;
175 
176 
177 constexpr QueryResult_CellsBatch_CellType QueryResult_CellsBatch_CellType_MIN = QueryResult_CellsBatch_CellType::CELL_INVALID;
178 constexpr QueryResult_CellsBatch_CellType QueryResult_CellsBatch_CellType_MAX = QueryResult_CellsBatch_CellType::CELL_BLOB;
179 
180 
181 PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
QueryResult_CellsBatch_CellType_Name(::perfetto::protos::pbzero::QueryResult_CellsBatch_CellType value)182 const char* QueryResult_CellsBatch_CellType_Name(::perfetto::protos::pbzero::QueryResult_CellsBatch_CellType value) {
183   switch (value) {
184   case ::perfetto::protos::pbzero::QueryResult_CellsBatch_CellType::CELL_INVALID:
185     return "CELL_INVALID";
186 
187   case ::perfetto::protos::pbzero::QueryResult_CellsBatch_CellType::CELL_NULL:
188     return "CELL_NULL";
189 
190   case ::perfetto::protos::pbzero::QueryResult_CellsBatch_CellType::CELL_VARINT:
191     return "CELL_VARINT";
192 
193   case ::perfetto::protos::pbzero::QueryResult_CellsBatch_CellType::CELL_FLOAT64:
194     return "CELL_FLOAT64";
195 
196   case ::perfetto::protos::pbzero::QueryResult_CellsBatch_CellType::CELL_STRING:
197     return "CELL_STRING";
198 
199   case ::perfetto::protos::pbzero::QueryResult_CellsBatch_CellType::CELL_BLOB:
200     return "CELL_BLOB";
201   }
202   return "PBZERO_UNKNOWN_ENUM_VALUE";
203 }
204 
205 namespace perfetto_pbzero_enum_TraceProcessorRpc {
206 enum TraceProcessorMethod : int32_t {
207   TPM_UNSPECIFIED = 0,
208   TPM_APPEND_TRACE_DATA = 1,
209   TPM_FINALIZE_TRACE_DATA = 2,
210   TPM_QUERY_STREAMING = 3,
211   TPM_COMPUTE_METRIC = 5,
212   TPM_GET_METRIC_DESCRIPTORS = 6,
213   TPM_RESTORE_INITIAL_TABLES = 7,
214   TPM_ENABLE_METATRACE = 8,
215   TPM_DISABLE_AND_READ_METATRACE = 9,
216   TPM_GET_STATUS = 10,
217   TPM_RESET_TRACE_PROCESSOR = 11,
218   TPM_REGISTER_SQL_PACKAGE = 13,
219 };
220 } // namespace perfetto_pbzero_enum_TraceProcessorRpc
221 using TraceProcessorRpc_TraceProcessorMethod = perfetto_pbzero_enum_TraceProcessorRpc::TraceProcessorMethod;
222 
223 
224 constexpr TraceProcessorRpc_TraceProcessorMethod TraceProcessorRpc_TraceProcessorMethod_MIN = TraceProcessorRpc_TraceProcessorMethod::TPM_UNSPECIFIED;
225 constexpr TraceProcessorRpc_TraceProcessorMethod TraceProcessorRpc_TraceProcessorMethod_MAX = TraceProcessorRpc_TraceProcessorMethod::TPM_REGISTER_SQL_PACKAGE;
226 
227 
228 PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
TraceProcessorRpc_TraceProcessorMethod_Name(::perfetto::protos::pbzero::TraceProcessorRpc_TraceProcessorMethod value)229 const char* TraceProcessorRpc_TraceProcessorMethod_Name(::perfetto::protos::pbzero::TraceProcessorRpc_TraceProcessorMethod value) {
230   switch (value) {
231   case ::perfetto::protos::pbzero::TraceProcessorRpc_TraceProcessorMethod::TPM_UNSPECIFIED:
232     return "TPM_UNSPECIFIED";
233 
234   case ::perfetto::protos::pbzero::TraceProcessorRpc_TraceProcessorMethod::TPM_APPEND_TRACE_DATA:
235     return "TPM_APPEND_TRACE_DATA";
236 
237   case ::perfetto::protos::pbzero::TraceProcessorRpc_TraceProcessorMethod::TPM_FINALIZE_TRACE_DATA:
238     return "TPM_FINALIZE_TRACE_DATA";
239 
240   case ::perfetto::protos::pbzero::TraceProcessorRpc_TraceProcessorMethod::TPM_QUERY_STREAMING:
241     return "TPM_QUERY_STREAMING";
242 
243   case ::perfetto::protos::pbzero::TraceProcessorRpc_TraceProcessorMethod::TPM_COMPUTE_METRIC:
244     return "TPM_COMPUTE_METRIC";
245 
246   case ::perfetto::protos::pbzero::TraceProcessorRpc_TraceProcessorMethod::TPM_GET_METRIC_DESCRIPTORS:
247     return "TPM_GET_METRIC_DESCRIPTORS";
248 
249   case ::perfetto::protos::pbzero::TraceProcessorRpc_TraceProcessorMethod::TPM_RESTORE_INITIAL_TABLES:
250     return "TPM_RESTORE_INITIAL_TABLES";
251 
252   case ::perfetto::protos::pbzero::TraceProcessorRpc_TraceProcessorMethod::TPM_ENABLE_METATRACE:
253     return "TPM_ENABLE_METATRACE";
254 
255   case ::perfetto::protos::pbzero::TraceProcessorRpc_TraceProcessorMethod::TPM_DISABLE_AND_READ_METATRACE:
256     return "TPM_DISABLE_AND_READ_METATRACE";
257 
258   case ::perfetto::protos::pbzero::TraceProcessorRpc_TraceProcessorMethod::TPM_GET_STATUS:
259     return "TPM_GET_STATUS";
260 
261   case ::perfetto::protos::pbzero::TraceProcessorRpc_TraceProcessorMethod::TPM_RESET_TRACE_PROCESSOR:
262     return "TPM_RESET_TRACE_PROCESSOR";
263 
264   case ::perfetto::protos::pbzero::TraceProcessorRpc_TraceProcessorMethod::TPM_REGISTER_SQL_PACKAGE:
265     return "TPM_REGISTER_SQL_PACKAGE";
266   }
267   return "PBZERO_UNKNOWN_ENUM_VALUE";
268 }
269 
270 class FinalizeDataResult_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
271  public:
FinalizeDataResult_Decoder(const uint8_t * data,size_t len)272   FinalizeDataResult_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
FinalizeDataResult_Decoder(const std::string & raw)273   explicit FinalizeDataResult_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
FinalizeDataResult_Decoder(const::protozero::ConstBytes & raw)274   explicit FinalizeDataResult_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
has_error()275   bool has_error() const { return at<1>().valid(); }
error()276   ::protozero::ConstChars error() const { return at<1>().as_string(); }
277 };
278 
279 class FinalizeDataResult : public ::protozero::Message {
280  public:
281   using Decoder = FinalizeDataResult_Decoder;
282   enum : int32_t {
283     kErrorFieldNumber = 1,
284   };
GetName()285   static constexpr const char* GetName() { return ".perfetto.protos.FinalizeDataResult"; }
286 
287 
288   using FieldMetadata_Error =
289     ::protozero::proto_utils::FieldMetadata<
290       1,
291       ::protozero::proto_utils::RepetitionType::kNotRepeated,
292       ::protozero::proto_utils::ProtoSchemaType::kString,
293       std::string,
294       FinalizeDataResult>;
295 
296   static constexpr FieldMetadata_Error kError{};
set_error(const char * data,size_t size)297   void set_error(const char* data, size_t size) {
298     AppendBytes(FieldMetadata_Error::kFieldId, data, size);
299   }
set_error(::protozero::ConstChars chars)300   void set_error(::protozero::ConstChars chars) {
301     AppendBytes(FieldMetadata_Error::kFieldId, chars.data, chars.size);
302   }
set_error(std::string value)303   void set_error(std::string value) {
304     static constexpr uint32_t field_id = FieldMetadata_Error::kFieldId;
305     // Call the appropriate protozero::Message::Append(field_id, ...)
306     // method based on the type of the field.
307     ::protozero::internal::FieldWriter<
308       ::protozero::proto_utils::ProtoSchemaType::kString>
309         ::Append(*this, field_id, value);
310   }
311 };
312 
313 class RegisterSqlPackageResult_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
314  public:
RegisterSqlPackageResult_Decoder(const uint8_t * data,size_t len)315   RegisterSqlPackageResult_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
RegisterSqlPackageResult_Decoder(const std::string & raw)316   explicit RegisterSqlPackageResult_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
RegisterSqlPackageResult_Decoder(const::protozero::ConstBytes & raw)317   explicit RegisterSqlPackageResult_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
has_error()318   bool has_error() const { return at<1>().valid(); }
error()319   ::protozero::ConstChars error() const { return at<1>().as_string(); }
320 };
321 
322 class RegisterSqlPackageResult : public ::protozero::Message {
323  public:
324   using Decoder = RegisterSqlPackageResult_Decoder;
325   enum : int32_t {
326     kErrorFieldNumber = 1,
327   };
GetName()328   static constexpr const char* GetName() { return ".perfetto.protos.RegisterSqlPackageResult"; }
329 
330 
331   using FieldMetadata_Error =
332     ::protozero::proto_utils::FieldMetadata<
333       1,
334       ::protozero::proto_utils::RepetitionType::kNotRepeated,
335       ::protozero::proto_utils::ProtoSchemaType::kString,
336       std::string,
337       RegisterSqlPackageResult>;
338 
339   static constexpr FieldMetadata_Error kError{};
set_error(const char * data,size_t size)340   void set_error(const char* data, size_t size) {
341     AppendBytes(FieldMetadata_Error::kFieldId, data, size);
342   }
set_error(::protozero::ConstChars chars)343   void set_error(::protozero::ConstChars chars) {
344     AppendBytes(FieldMetadata_Error::kFieldId, chars.data, chars.size);
345   }
set_error(std::string value)346   void set_error(std::string value) {
347     static constexpr uint32_t field_id = FieldMetadata_Error::kFieldId;
348     // Call the appropriate protozero::Message::Append(field_id, ...)
349     // method based on the type of the field.
350     ::protozero::internal::FieldWriter<
351       ::protozero::proto_utils::ProtoSchemaType::kString>
352         ::Append(*this, field_id, value);
353   }
354 };
355 
356 class RegisterSqlPackageArgs_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
357  public:
RegisterSqlPackageArgs_Decoder(const uint8_t * data,size_t len)358   RegisterSqlPackageArgs_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
RegisterSqlPackageArgs_Decoder(const std::string & raw)359   explicit RegisterSqlPackageArgs_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
RegisterSqlPackageArgs_Decoder(const::protozero::ConstBytes & raw)360   explicit RegisterSqlPackageArgs_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
has_package_name()361   bool has_package_name() const { return at<1>().valid(); }
package_name()362   ::protozero::ConstChars package_name() const { return at<1>().as_string(); }
has_modules()363   bool has_modules() const { return at<2>().valid(); }
modules()364   ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> modules() const { return GetRepeated<::protozero::ConstBytes>(2); }
has_allow_override()365   bool has_allow_override() const { return at<3>().valid(); }
allow_override()366   bool allow_override() const { return at<3>().as_bool(); }
367 };
368 
369 class RegisterSqlPackageArgs : public ::protozero::Message {
370  public:
371   using Decoder = RegisterSqlPackageArgs_Decoder;
372   enum : int32_t {
373     kPackageNameFieldNumber = 1,
374     kModulesFieldNumber = 2,
375     kAllowOverrideFieldNumber = 3,
376   };
GetName()377   static constexpr const char* GetName() { return ".perfetto.protos.RegisterSqlPackageArgs"; }
378 
379   using Module = ::perfetto::protos::pbzero::RegisterSqlPackageArgs_Module;
380 
381   using FieldMetadata_PackageName =
382     ::protozero::proto_utils::FieldMetadata<
383       1,
384       ::protozero::proto_utils::RepetitionType::kNotRepeated,
385       ::protozero::proto_utils::ProtoSchemaType::kString,
386       std::string,
387       RegisterSqlPackageArgs>;
388 
389   static constexpr FieldMetadata_PackageName kPackageName{};
set_package_name(const char * data,size_t size)390   void set_package_name(const char* data, size_t size) {
391     AppendBytes(FieldMetadata_PackageName::kFieldId, data, size);
392   }
set_package_name(::protozero::ConstChars chars)393   void set_package_name(::protozero::ConstChars chars) {
394     AppendBytes(FieldMetadata_PackageName::kFieldId, chars.data, chars.size);
395   }
set_package_name(std::string value)396   void set_package_name(std::string value) {
397     static constexpr uint32_t field_id = FieldMetadata_PackageName::kFieldId;
398     // Call the appropriate protozero::Message::Append(field_id, ...)
399     // method based on the type of the field.
400     ::protozero::internal::FieldWriter<
401       ::protozero::proto_utils::ProtoSchemaType::kString>
402         ::Append(*this, field_id, value);
403   }
404 
405   using FieldMetadata_Modules =
406     ::protozero::proto_utils::FieldMetadata<
407       2,
408       ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
409       ::protozero::proto_utils::ProtoSchemaType::kMessage,
410       RegisterSqlPackageArgs_Module,
411       RegisterSqlPackageArgs>;
412 
413   static constexpr FieldMetadata_Modules kModules{};
add_modules()414   template <typename T = RegisterSqlPackageArgs_Module> T* add_modules() {
415     return BeginNestedMessage<T>(2);
416   }
417 
418 
419   using FieldMetadata_AllowOverride =
420     ::protozero::proto_utils::FieldMetadata<
421       3,
422       ::protozero::proto_utils::RepetitionType::kNotRepeated,
423       ::protozero::proto_utils::ProtoSchemaType::kBool,
424       bool,
425       RegisterSqlPackageArgs>;
426 
427   static constexpr FieldMetadata_AllowOverride kAllowOverride{};
set_allow_override(bool value)428   void set_allow_override(bool value) {
429     static constexpr uint32_t field_id = FieldMetadata_AllowOverride::kFieldId;
430     // Call the appropriate protozero::Message::Append(field_id, ...)
431     // method based on the type of the field.
432     ::protozero::internal::FieldWriter<
433       ::protozero::proto_utils::ProtoSchemaType::kBool>
434         ::Append(*this, field_id, value);
435   }
436 };
437 
438 class RegisterSqlPackageArgs_Module_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
439  public:
RegisterSqlPackageArgs_Module_Decoder(const uint8_t * data,size_t len)440   RegisterSqlPackageArgs_Module_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
RegisterSqlPackageArgs_Module_Decoder(const std::string & raw)441   explicit RegisterSqlPackageArgs_Module_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
RegisterSqlPackageArgs_Module_Decoder(const::protozero::ConstBytes & raw)442   explicit RegisterSqlPackageArgs_Module_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
has_name()443   bool has_name() const { return at<1>().valid(); }
name()444   ::protozero::ConstChars name() const { return at<1>().as_string(); }
has_sql()445   bool has_sql() const { return at<2>().valid(); }
sql()446   ::protozero::ConstChars sql() const { return at<2>().as_string(); }
447 };
448 
449 class RegisterSqlPackageArgs_Module : public ::protozero::Message {
450  public:
451   using Decoder = RegisterSqlPackageArgs_Module_Decoder;
452   enum : int32_t {
453     kNameFieldNumber = 1,
454     kSqlFieldNumber = 2,
455   };
GetName()456   static constexpr const char* GetName() { return ".perfetto.protos.RegisterSqlPackageArgs.Module"; }
457 
458 
459   using FieldMetadata_Name =
460     ::protozero::proto_utils::FieldMetadata<
461       1,
462       ::protozero::proto_utils::RepetitionType::kNotRepeated,
463       ::protozero::proto_utils::ProtoSchemaType::kString,
464       std::string,
465       RegisterSqlPackageArgs_Module>;
466 
467   static constexpr FieldMetadata_Name kName{};
set_name(const char * data,size_t size)468   void set_name(const char* data, size_t size) {
469     AppendBytes(FieldMetadata_Name::kFieldId, data, size);
470   }
set_name(::protozero::ConstChars chars)471   void set_name(::protozero::ConstChars chars) {
472     AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size);
473   }
set_name(std::string value)474   void set_name(std::string value) {
475     static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId;
476     // Call the appropriate protozero::Message::Append(field_id, ...)
477     // method based on the type of the field.
478     ::protozero::internal::FieldWriter<
479       ::protozero::proto_utils::ProtoSchemaType::kString>
480         ::Append(*this, field_id, value);
481   }
482 
483   using FieldMetadata_Sql =
484     ::protozero::proto_utils::FieldMetadata<
485       2,
486       ::protozero::proto_utils::RepetitionType::kNotRepeated,
487       ::protozero::proto_utils::ProtoSchemaType::kString,
488       std::string,
489       RegisterSqlPackageArgs_Module>;
490 
491   static constexpr FieldMetadata_Sql kSql{};
set_sql(const char * data,size_t size)492   void set_sql(const char* data, size_t size) {
493     AppendBytes(FieldMetadata_Sql::kFieldId, data, size);
494   }
set_sql(::protozero::ConstChars chars)495   void set_sql(::protozero::ConstChars chars) {
496     AppendBytes(FieldMetadata_Sql::kFieldId, chars.data, chars.size);
497   }
set_sql(std::string value)498   void set_sql(std::string value) {
499     static constexpr uint32_t field_id = FieldMetadata_Sql::kFieldId;
500     // Call the appropriate protozero::Message::Append(field_id, ...)
501     // method based on the type of the field.
502     ::protozero::internal::FieldWriter<
503       ::protozero::proto_utils::ProtoSchemaType::kString>
504         ::Append(*this, field_id, value);
505   }
506 };
507 
508 class ResetTraceProcessorArgs_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
509  public:
ResetTraceProcessorArgs_Decoder(const uint8_t * data,size_t len)510   ResetTraceProcessorArgs_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
ResetTraceProcessorArgs_Decoder(const std::string & raw)511   explicit ResetTraceProcessorArgs_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
ResetTraceProcessorArgs_Decoder(const::protozero::ConstBytes & raw)512   explicit ResetTraceProcessorArgs_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
has_drop_track_event_data_before()513   bool has_drop_track_event_data_before() const { return at<1>().valid(); }
drop_track_event_data_before()514   int32_t drop_track_event_data_before() const { return at<1>().as_int32(); }
has_ingest_ftrace_in_raw_table()515   bool has_ingest_ftrace_in_raw_table() const { return at<2>().valid(); }
ingest_ftrace_in_raw_table()516   bool ingest_ftrace_in_raw_table() const { return at<2>().as_bool(); }
has_analyze_trace_proto_content()517   bool has_analyze_trace_proto_content() const { return at<3>().valid(); }
analyze_trace_proto_content()518   bool analyze_trace_proto_content() const { return at<3>().as_bool(); }
has_ftrace_drop_until_all_cpus_valid()519   bool has_ftrace_drop_until_all_cpus_valid() const { return at<4>().valid(); }
ftrace_drop_until_all_cpus_valid()520   bool ftrace_drop_until_all_cpus_valid() const { return at<4>().as_bool(); }
has_parsing_mode()521   bool has_parsing_mode() const { return at<5>().valid(); }
parsing_mode()522   int32_t parsing_mode() const { return at<5>().as_int32(); }
523 };
524 
525 class ResetTraceProcessorArgs : public ::protozero::Message {
526  public:
527   using Decoder = ResetTraceProcessorArgs_Decoder;
528   enum : int32_t {
529     kDropTrackEventDataBeforeFieldNumber = 1,
530     kIngestFtraceInRawTableFieldNumber = 2,
531     kAnalyzeTraceProtoContentFieldNumber = 3,
532     kFtraceDropUntilAllCpusValidFieldNumber = 4,
533     kParsingModeFieldNumber = 5,
534   };
GetName()535   static constexpr const char* GetName() { return ".perfetto.protos.ResetTraceProcessorArgs"; }
536 
537 
538   using DropTrackEventDataBefore = ::perfetto::protos::pbzero::ResetTraceProcessorArgs_DropTrackEventDataBefore;
DropTrackEventDataBefore_Name(DropTrackEventDataBefore value)539   static inline const char* DropTrackEventDataBefore_Name(DropTrackEventDataBefore value) {
540     return ::perfetto::protos::pbzero::ResetTraceProcessorArgs_DropTrackEventDataBefore_Name(value);
541   }
542 
543   using ParsingMode = ::perfetto::protos::pbzero::ResetTraceProcessorArgs_ParsingMode;
ParsingMode_Name(ParsingMode value)544   static inline const char* ParsingMode_Name(ParsingMode value) {
545     return ::perfetto::protos::pbzero::ResetTraceProcessorArgs_ParsingMode_Name(value);
546   }
547   static inline const DropTrackEventDataBefore NO_DROP = DropTrackEventDataBefore::NO_DROP;
548   static inline const DropTrackEventDataBefore TRACK_EVENT_RANGE_OF_INTEREST = DropTrackEventDataBefore::TRACK_EVENT_RANGE_OF_INTEREST;
549   static inline const ParsingMode DEFAULT = ParsingMode::DEFAULT;
550   static inline const ParsingMode TOKENIZE_ONLY = ParsingMode::TOKENIZE_ONLY;
551   static inline const ParsingMode TOKENIZE_AND_SORT = ParsingMode::TOKENIZE_AND_SORT;
552 
553   using FieldMetadata_DropTrackEventDataBefore =
554     ::protozero::proto_utils::FieldMetadata<
555       1,
556       ::protozero::proto_utils::RepetitionType::kNotRepeated,
557       ::protozero::proto_utils::ProtoSchemaType::kEnum,
558       ResetTraceProcessorArgs_DropTrackEventDataBefore,
559       ResetTraceProcessorArgs>;
560 
561   static constexpr FieldMetadata_DropTrackEventDataBefore kDropTrackEventDataBefore{};
set_drop_track_event_data_before(ResetTraceProcessorArgs_DropTrackEventDataBefore value)562   void set_drop_track_event_data_before(ResetTraceProcessorArgs_DropTrackEventDataBefore value) {
563     static constexpr uint32_t field_id = FieldMetadata_DropTrackEventDataBefore::kFieldId;
564     // Call the appropriate protozero::Message::Append(field_id, ...)
565     // method based on the type of the field.
566     ::protozero::internal::FieldWriter<
567       ::protozero::proto_utils::ProtoSchemaType::kEnum>
568         ::Append(*this, field_id, value);
569   }
570 
571   using FieldMetadata_IngestFtraceInRawTable =
572     ::protozero::proto_utils::FieldMetadata<
573       2,
574       ::protozero::proto_utils::RepetitionType::kNotRepeated,
575       ::protozero::proto_utils::ProtoSchemaType::kBool,
576       bool,
577       ResetTraceProcessorArgs>;
578 
579   static constexpr FieldMetadata_IngestFtraceInRawTable kIngestFtraceInRawTable{};
set_ingest_ftrace_in_raw_table(bool value)580   void set_ingest_ftrace_in_raw_table(bool value) {
581     static constexpr uint32_t field_id = FieldMetadata_IngestFtraceInRawTable::kFieldId;
582     // Call the appropriate protozero::Message::Append(field_id, ...)
583     // method based on the type of the field.
584     ::protozero::internal::FieldWriter<
585       ::protozero::proto_utils::ProtoSchemaType::kBool>
586         ::Append(*this, field_id, value);
587   }
588 
589   using FieldMetadata_AnalyzeTraceProtoContent =
590     ::protozero::proto_utils::FieldMetadata<
591       3,
592       ::protozero::proto_utils::RepetitionType::kNotRepeated,
593       ::protozero::proto_utils::ProtoSchemaType::kBool,
594       bool,
595       ResetTraceProcessorArgs>;
596 
597   static constexpr FieldMetadata_AnalyzeTraceProtoContent kAnalyzeTraceProtoContent{};
set_analyze_trace_proto_content(bool value)598   void set_analyze_trace_proto_content(bool value) {
599     static constexpr uint32_t field_id = FieldMetadata_AnalyzeTraceProtoContent::kFieldId;
600     // Call the appropriate protozero::Message::Append(field_id, ...)
601     // method based on the type of the field.
602     ::protozero::internal::FieldWriter<
603       ::protozero::proto_utils::ProtoSchemaType::kBool>
604         ::Append(*this, field_id, value);
605   }
606 
607   using FieldMetadata_FtraceDropUntilAllCpusValid =
608     ::protozero::proto_utils::FieldMetadata<
609       4,
610       ::protozero::proto_utils::RepetitionType::kNotRepeated,
611       ::protozero::proto_utils::ProtoSchemaType::kBool,
612       bool,
613       ResetTraceProcessorArgs>;
614 
615   static constexpr FieldMetadata_FtraceDropUntilAllCpusValid kFtraceDropUntilAllCpusValid{};
set_ftrace_drop_until_all_cpus_valid(bool value)616   void set_ftrace_drop_until_all_cpus_valid(bool value) {
617     static constexpr uint32_t field_id = FieldMetadata_FtraceDropUntilAllCpusValid::kFieldId;
618     // Call the appropriate protozero::Message::Append(field_id, ...)
619     // method based on the type of the field.
620     ::protozero::internal::FieldWriter<
621       ::protozero::proto_utils::ProtoSchemaType::kBool>
622         ::Append(*this, field_id, value);
623   }
624 
625   using FieldMetadata_ParsingMode =
626     ::protozero::proto_utils::FieldMetadata<
627       5,
628       ::protozero::proto_utils::RepetitionType::kNotRepeated,
629       ::protozero::proto_utils::ProtoSchemaType::kEnum,
630       ResetTraceProcessorArgs_ParsingMode,
631       ResetTraceProcessorArgs>;
632 
633   static constexpr FieldMetadata_ParsingMode kParsingMode{};
set_parsing_mode(ResetTraceProcessorArgs_ParsingMode value)634   void set_parsing_mode(ResetTraceProcessorArgs_ParsingMode value) {
635     static constexpr uint32_t field_id = FieldMetadata_ParsingMode::kFieldId;
636     // Call the appropriate protozero::Message::Append(field_id, ...)
637     // method based on the type of the field.
638     ::protozero::internal::FieldWriter<
639       ::protozero::proto_utils::ProtoSchemaType::kEnum>
640         ::Append(*this, field_id, value);
641   }
642 };
643 
644 class DescriptorSet_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
645  public:
DescriptorSet_Decoder(const uint8_t * data,size_t len)646   DescriptorSet_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
DescriptorSet_Decoder(const std::string & raw)647   explicit DescriptorSet_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
DescriptorSet_Decoder(const::protozero::ConstBytes & raw)648   explicit DescriptorSet_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
has_descriptors()649   bool has_descriptors() const { return at<1>().valid(); }
descriptors()650   ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> descriptors() const { return GetRepeated<::protozero::ConstBytes>(1); }
651 };
652 
653 class DescriptorSet : public ::protozero::Message {
654  public:
655   using Decoder = DescriptorSet_Decoder;
656   enum : int32_t {
657     kDescriptorsFieldNumber = 1,
658   };
GetName()659   static constexpr const char* GetName() { return ".perfetto.protos.DescriptorSet"; }
660 
661 
662   using FieldMetadata_Descriptors =
663     ::protozero::proto_utils::FieldMetadata<
664       1,
665       ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
666       ::protozero::proto_utils::ProtoSchemaType::kMessage,
667       DescriptorProto,
668       DescriptorSet>;
669 
670   static constexpr FieldMetadata_Descriptors kDescriptors{};
add_descriptors()671   template <typename T = DescriptorProto> T* add_descriptors() {
672     return BeginNestedMessage<T>(1);
673   }
674 
675 };
676 
677 class DisableAndReadMetatraceResult_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
678  public:
DisableAndReadMetatraceResult_Decoder(const uint8_t * data,size_t len)679   DisableAndReadMetatraceResult_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
DisableAndReadMetatraceResult_Decoder(const std::string & raw)680   explicit DisableAndReadMetatraceResult_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
DisableAndReadMetatraceResult_Decoder(const::protozero::ConstBytes & raw)681   explicit DisableAndReadMetatraceResult_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
has_metatrace()682   bool has_metatrace() const { return at<1>().valid(); }
metatrace()683   ::protozero::ConstBytes metatrace() const { return at<1>().as_bytes(); }
has_error()684   bool has_error() const { return at<2>().valid(); }
error()685   ::protozero::ConstChars error() const { return at<2>().as_string(); }
686 };
687 
688 class DisableAndReadMetatraceResult : public ::protozero::Message {
689  public:
690   using Decoder = DisableAndReadMetatraceResult_Decoder;
691   enum : int32_t {
692     kMetatraceFieldNumber = 1,
693     kErrorFieldNumber = 2,
694   };
GetName()695   static constexpr const char* GetName() { return ".perfetto.protos.DisableAndReadMetatraceResult"; }
696 
697 
698   using FieldMetadata_Metatrace =
699     ::protozero::proto_utils::FieldMetadata<
700       1,
701       ::protozero::proto_utils::RepetitionType::kNotRepeated,
702       ::protozero::proto_utils::ProtoSchemaType::kBytes,
703       std::string,
704       DisableAndReadMetatraceResult>;
705 
706   static constexpr FieldMetadata_Metatrace kMetatrace{};
set_metatrace(const uint8_t * data,size_t size)707   void set_metatrace(const uint8_t* data, size_t size) {
708     AppendBytes(FieldMetadata_Metatrace::kFieldId, data, size);
709   }
set_metatrace(::protozero::ConstBytes bytes)710   void set_metatrace(::protozero::ConstBytes bytes) {
711     AppendBytes(FieldMetadata_Metatrace::kFieldId, bytes.data, bytes.size);
712   }
set_metatrace(std::string value)713   void set_metatrace(std::string value) {
714     static constexpr uint32_t field_id = FieldMetadata_Metatrace::kFieldId;
715     // Call the appropriate protozero::Message::Append(field_id, ...)
716     // method based on the type of the field.
717     ::protozero::internal::FieldWriter<
718       ::protozero::proto_utils::ProtoSchemaType::kBytes>
719         ::Append(*this, field_id, value);
720   }
721 
722   using FieldMetadata_Error =
723     ::protozero::proto_utils::FieldMetadata<
724       2,
725       ::protozero::proto_utils::RepetitionType::kNotRepeated,
726       ::protozero::proto_utils::ProtoSchemaType::kString,
727       std::string,
728       DisableAndReadMetatraceResult>;
729 
730   static constexpr FieldMetadata_Error kError{};
set_error(const char * data,size_t size)731   void set_error(const char* data, size_t size) {
732     AppendBytes(FieldMetadata_Error::kFieldId, data, size);
733   }
set_error(::protozero::ConstChars chars)734   void set_error(::protozero::ConstChars chars) {
735     AppendBytes(FieldMetadata_Error::kFieldId, chars.data, chars.size);
736   }
set_error(std::string value)737   void set_error(std::string value) {
738     static constexpr uint32_t field_id = FieldMetadata_Error::kFieldId;
739     // Call the appropriate protozero::Message::Append(field_id, ...)
740     // method based on the type of the field.
741     ::protozero::internal::FieldWriter<
742       ::protozero::proto_utils::ProtoSchemaType::kString>
743         ::Append(*this, field_id, value);
744   }
745 };
746 
747 class DisableAndReadMetatraceArgs_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/0, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
748  public:
DisableAndReadMetatraceArgs_Decoder(const uint8_t * data,size_t len)749   DisableAndReadMetatraceArgs_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
DisableAndReadMetatraceArgs_Decoder(const std::string & raw)750   explicit DisableAndReadMetatraceArgs_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
DisableAndReadMetatraceArgs_Decoder(const::protozero::ConstBytes & raw)751   explicit DisableAndReadMetatraceArgs_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
752 };
753 
754 class DisableAndReadMetatraceArgs : public ::protozero::Message {
755  public:
756   using Decoder = DisableAndReadMetatraceArgs_Decoder;
GetName()757   static constexpr const char* GetName() { return ".perfetto.protos.DisableAndReadMetatraceArgs"; }
758 
759 };
760 
761 class EnableMetatraceResult_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/0, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
762  public:
EnableMetatraceResult_Decoder(const uint8_t * data,size_t len)763   EnableMetatraceResult_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
EnableMetatraceResult_Decoder(const std::string & raw)764   explicit EnableMetatraceResult_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
EnableMetatraceResult_Decoder(const::protozero::ConstBytes & raw)765   explicit EnableMetatraceResult_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
766 };
767 
768 class EnableMetatraceResult : public ::protozero::Message {
769  public:
770   using Decoder = EnableMetatraceResult_Decoder;
GetName()771   static constexpr const char* GetName() { return ".perfetto.protos.EnableMetatraceResult"; }
772 
773 };
774 
775 class EnableMetatraceArgs_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
776  public:
EnableMetatraceArgs_Decoder(const uint8_t * data,size_t len)777   EnableMetatraceArgs_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
EnableMetatraceArgs_Decoder(const std::string & raw)778   explicit EnableMetatraceArgs_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
EnableMetatraceArgs_Decoder(const::protozero::ConstBytes & raw)779   explicit EnableMetatraceArgs_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
has_categories()780   bool has_categories() const { return at<1>().valid(); }
categories()781   int32_t categories() const { return at<1>().as_int32(); }
782 };
783 
784 class EnableMetatraceArgs : public ::protozero::Message {
785  public:
786   using Decoder = EnableMetatraceArgs_Decoder;
787   enum : int32_t {
788     kCategoriesFieldNumber = 1,
789   };
GetName()790   static constexpr const char* GetName() { return ".perfetto.protos.EnableMetatraceArgs"; }
791 
792 
793   using FieldMetadata_Categories =
794     ::protozero::proto_utils::FieldMetadata<
795       1,
796       ::protozero::proto_utils::RepetitionType::kNotRepeated,
797       ::protozero::proto_utils::ProtoSchemaType::kEnum,
798       MetatraceCategories,
799       EnableMetatraceArgs>;
800 
801   static constexpr FieldMetadata_Categories kCategories{};
set_categories(MetatraceCategories value)802   void set_categories(MetatraceCategories value) {
803     static constexpr uint32_t field_id = FieldMetadata_Categories::kFieldId;
804     // Call the appropriate protozero::Message::Append(field_id, ...)
805     // method based on the type of the field.
806     ::protozero::internal::FieldWriter<
807       ::protozero::proto_utils::ProtoSchemaType::kEnum>
808         ::Append(*this, field_id, value);
809   }
810 };
811 
812 class ComputeMetricResult_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
813  public:
ComputeMetricResult_Decoder(const uint8_t * data,size_t len)814   ComputeMetricResult_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
ComputeMetricResult_Decoder(const std::string & raw)815   explicit ComputeMetricResult_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
ComputeMetricResult_Decoder(const::protozero::ConstBytes & raw)816   explicit ComputeMetricResult_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
has_metrics()817   bool has_metrics() const { return at<1>().valid(); }
metrics()818   ::protozero::ConstBytes metrics() const { return at<1>().as_bytes(); }
has_metrics_as_prototext()819   bool has_metrics_as_prototext() const { return at<3>().valid(); }
metrics_as_prototext()820   ::protozero::ConstChars metrics_as_prototext() const { return at<3>().as_string(); }
has_metrics_as_json()821   bool has_metrics_as_json() const { return at<4>().valid(); }
metrics_as_json()822   ::protozero::ConstChars metrics_as_json() const { return at<4>().as_string(); }
has_error()823   bool has_error() const { return at<2>().valid(); }
error()824   ::protozero::ConstChars error() const { return at<2>().as_string(); }
825 };
826 
827 class ComputeMetricResult : public ::protozero::Message {
828  public:
829   using Decoder = ComputeMetricResult_Decoder;
830   enum : int32_t {
831     kMetricsFieldNumber = 1,
832     kMetricsAsPrototextFieldNumber = 3,
833     kMetricsAsJsonFieldNumber = 4,
834     kErrorFieldNumber = 2,
835   };
GetName()836   static constexpr const char* GetName() { return ".perfetto.protos.ComputeMetricResult"; }
837 
838 
839   using FieldMetadata_Metrics =
840     ::protozero::proto_utils::FieldMetadata<
841       1,
842       ::protozero::proto_utils::RepetitionType::kNotRepeated,
843       ::protozero::proto_utils::ProtoSchemaType::kBytes,
844       std::string,
845       ComputeMetricResult>;
846 
847   static constexpr FieldMetadata_Metrics kMetrics{};
set_metrics(const uint8_t * data,size_t size)848   void set_metrics(const uint8_t* data, size_t size) {
849     AppendBytes(FieldMetadata_Metrics::kFieldId, data, size);
850   }
set_metrics(::protozero::ConstBytes bytes)851   void set_metrics(::protozero::ConstBytes bytes) {
852     AppendBytes(FieldMetadata_Metrics::kFieldId, bytes.data, bytes.size);
853   }
set_metrics(std::string value)854   void set_metrics(std::string value) {
855     static constexpr uint32_t field_id = FieldMetadata_Metrics::kFieldId;
856     // Call the appropriate protozero::Message::Append(field_id, ...)
857     // method based on the type of the field.
858     ::protozero::internal::FieldWriter<
859       ::protozero::proto_utils::ProtoSchemaType::kBytes>
860         ::Append(*this, field_id, value);
861   }
862 
863   using FieldMetadata_MetricsAsPrototext =
864     ::protozero::proto_utils::FieldMetadata<
865       3,
866       ::protozero::proto_utils::RepetitionType::kNotRepeated,
867       ::protozero::proto_utils::ProtoSchemaType::kString,
868       std::string,
869       ComputeMetricResult>;
870 
871   static constexpr FieldMetadata_MetricsAsPrototext kMetricsAsPrototext{};
set_metrics_as_prototext(const char * data,size_t size)872   void set_metrics_as_prototext(const char* data, size_t size) {
873     AppendBytes(FieldMetadata_MetricsAsPrototext::kFieldId, data, size);
874   }
set_metrics_as_prototext(::protozero::ConstChars chars)875   void set_metrics_as_prototext(::protozero::ConstChars chars) {
876     AppendBytes(FieldMetadata_MetricsAsPrototext::kFieldId, chars.data, chars.size);
877   }
set_metrics_as_prototext(std::string value)878   void set_metrics_as_prototext(std::string value) {
879     static constexpr uint32_t field_id = FieldMetadata_MetricsAsPrototext::kFieldId;
880     // Call the appropriate protozero::Message::Append(field_id, ...)
881     // method based on the type of the field.
882     ::protozero::internal::FieldWriter<
883       ::protozero::proto_utils::ProtoSchemaType::kString>
884         ::Append(*this, field_id, value);
885   }
886 
887   using FieldMetadata_MetricsAsJson =
888     ::protozero::proto_utils::FieldMetadata<
889       4,
890       ::protozero::proto_utils::RepetitionType::kNotRepeated,
891       ::protozero::proto_utils::ProtoSchemaType::kString,
892       std::string,
893       ComputeMetricResult>;
894 
895   static constexpr FieldMetadata_MetricsAsJson kMetricsAsJson{};
set_metrics_as_json(const char * data,size_t size)896   void set_metrics_as_json(const char* data, size_t size) {
897     AppendBytes(FieldMetadata_MetricsAsJson::kFieldId, data, size);
898   }
set_metrics_as_json(::protozero::ConstChars chars)899   void set_metrics_as_json(::protozero::ConstChars chars) {
900     AppendBytes(FieldMetadata_MetricsAsJson::kFieldId, chars.data, chars.size);
901   }
set_metrics_as_json(std::string value)902   void set_metrics_as_json(std::string value) {
903     static constexpr uint32_t field_id = FieldMetadata_MetricsAsJson::kFieldId;
904     // Call the appropriate protozero::Message::Append(field_id, ...)
905     // method based on the type of the field.
906     ::protozero::internal::FieldWriter<
907       ::protozero::proto_utils::ProtoSchemaType::kString>
908         ::Append(*this, field_id, value);
909   }
910 
911   using FieldMetadata_Error =
912     ::protozero::proto_utils::FieldMetadata<
913       2,
914       ::protozero::proto_utils::RepetitionType::kNotRepeated,
915       ::protozero::proto_utils::ProtoSchemaType::kString,
916       std::string,
917       ComputeMetricResult>;
918 
919   static constexpr FieldMetadata_Error kError{};
set_error(const char * data,size_t size)920   void set_error(const char* data, size_t size) {
921     AppendBytes(FieldMetadata_Error::kFieldId, data, size);
922   }
set_error(::protozero::ConstChars chars)923   void set_error(::protozero::ConstChars chars) {
924     AppendBytes(FieldMetadata_Error::kFieldId, chars.data, chars.size);
925   }
set_error(std::string value)926   void set_error(std::string value) {
927     static constexpr uint32_t field_id = FieldMetadata_Error::kFieldId;
928     // Call the appropriate protozero::Message::Append(field_id, ...)
929     // method based on the type of the field.
930     ::protozero::internal::FieldWriter<
931       ::protozero::proto_utils::ProtoSchemaType::kString>
932         ::Append(*this, field_id, value);
933   }
934 };
935 
936 class ComputeMetricArgs_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
937  public:
ComputeMetricArgs_Decoder(const uint8_t * data,size_t len)938   ComputeMetricArgs_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
ComputeMetricArgs_Decoder(const std::string & raw)939   explicit ComputeMetricArgs_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
ComputeMetricArgs_Decoder(const::protozero::ConstBytes & raw)940   explicit ComputeMetricArgs_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
has_metric_names()941   bool has_metric_names() const { return at<1>().valid(); }
metric_names()942   ::protozero::RepeatedFieldIterator<::protozero::ConstChars> metric_names() const { return GetRepeated<::protozero::ConstChars>(1); }
has_format()943   bool has_format() const { return at<2>().valid(); }
format()944   int32_t format() const { return at<2>().as_int32(); }
945 };
946 
947 class ComputeMetricArgs : public ::protozero::Message {
948  public:
949   using Decoder = ComputeMetricArgs_Decoder;
950   enum : int32_t {
951     kMetricNamesFieldNumber = 1,
952     kFormatFieldNumber = 2,
953   };
GetName()954   static constexpr const char* GetName() { return ".perfetto.protos.ComputeMetricArgs"; }
955 
956 
957   using ResultFormat = ::perfetto::protos::pbzero::ComputeMetricArgs_ResultFormat;
ResultFormat_Name(ResultFormat value)958   static inline const char* ResultFormat_Name(ResultFormat value) {
959     return ::perfetto::protos::pbzero::ComputeMetricArgs_ResultFormat_Name(value);
960   }
961   static inline const ResultFormat BINARY_PROTOBUF = ResultFormat::BINARY_PROTOBUF;
962   static inline const ResultFormat TEXTPROTO = ResultFormat::TEXTPROTO;
963   static inline const ResultFormat JSON = ResultFormat::JSON;
964 
965   using FieldMetadata_MetricNames =
966     ::protozero::proto_utils::FieldMetadata<
967       1,
968       ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
969       ::protozero::proto_utils::ProtoSchemaType::kString,
970       std::string,
971       ComputeMetricArgs>;
972 
973   static constexpr FieldMetadata_MetricNames kMetricNames{};
add_metric_names(const char * data,size_t size)974   void add_metric_names(const char* data, size_t size) {
975     AppendBytes(FieldMetadata_MetricNames::kFieldId, data, size);
976   }
add_metric_names(::protozero::ConstChars chars)977   void add_metric_names(::protozero::ConstChars chars) {
978     AppendBytes(FieldMetadata_MetricNames::kFieldId, chars.data, chars.size);
979   }
add_metric_names(std::string value)980   void add_metric_names(std::string value) {
981     static constexpr uint32_t field_id = FieldMetadata_MetricNames::kFieldId;
982     // Call the appropriate protozero::Message::Append(field_id, ...)
983     // method based on the type of the field.
984     ::protozero::internal::FieldWriter<
985       ::protozero::proto_utils::ProtoSchemaType::kString>
986         ::Append(*this, field_id, value);
987   }
988 
989   using FieldMetadata_Format =
990     ::protozero::proto_utils::FieldMetadata<
991       2,
992       ::protozero::proto_utils::RepetitionType::kNotRepeated,
993       ::protozero::proto_utils::ProtoSchemaType::kEnum,
994       ComputeMetricArgs_ResultFormat,
995       ComputeMetricArgs>;
996 
997   static constexpr FieldMetadata_Format kFormat{};
set_format(ComputeMetricArgs_ResultFormat value)998   void set_format(ComputeMetricArgs_ResultFormat value) {
999     static constexpr uint32_t field_id = FieldMetadata_Format::kFieldId;
1000     // Call the appropriate protozero::Message::Append(field_id, ...)
1001     // method based on the type of the field.
1002     ::protozero::internal::FieldWriter<
1003       ::protozero::proto_utils::ProtoSchemaType::kEnum>
1004         ::Append(*this, field_id, value);
1005   }
1006 };
1007 
1008 class StatusResult_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
1009  public:
StatusResult_Decoder(const uint8_t * data,size_t len)1010   StatusResult_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
StatusResult_Decoder(const std::string & raw)1011   explicit StatusResult_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
StatusResult_Decoder(const::protozero::ConstBytes & raw)1012   explicit StatusResult_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
has_loaded_trace_name()1013   bool has_loaded_trace_name() const { return at<1>().valid(); }
loaded_trace_name()1014   ::protozero::ConstChars loaded_trace_name() const { return at<1>().as_string(); }
has_human_readable_version()1015   bool has_human_readable_version() const { return at<2>().valid(); }
human_readable_version()1016   ::protozero::ConstChars human_readable_version() const { return at<2>().as_string(); }
has_api_version()1017   bool has_api_version() const { return at<3>().valid(); }
api_version()1018   int32_t api_version() const { return at<3>().as_int32(); }
has_version_code()1019   bool has_version_code() const { return at<4>().valid(); }
version_code()1020   ::protozero::ConstChars version_code() const { return at<4>().as_string(); }
1021 };
1022 
1023 class StatusResult : public ::protozero::Message {
1024  public:
1025   using Decoder = StatusResult_Decoder;
1026   enum : int32_t {
1027     kLoadedTraceNameFieldNumber = 1,
1028     kHumanReadableVersionFieldNumber = 2,
1029     kApiVersionFieldNumber = 3,
1030     kVersionCodeFieldNumber = 4,
1031   };
GetName()1032   static constexpr const char* GetName() { return ".perfetto.protos.StatusResult"; }
1033 
1034 
1035   using FieldMetadata_LoadedTraceName =
1036     ::protozero::proto_utils::FieldMetadata<
1037       1,
1038       ::protozero::proto_utils::RepetitionType::kNotRepeated,
1039       ::protozero::proto_utils::ProtoSchemaType::kString,
1040       std::string,
1041       StatusResult>;
1042 
1043   static constexpr FieldMetadata_LoadedTraceName kLoadedTraceName{};
set_loaded_trace_name(const char * data,size_t size)1044   void set_loaded_trace_name(const char* data, size_t size) {
1045     AppendBytes(FieldMetadata_LoadedTraceName::kFieldId, data, size);
1046   }
set_loaded_trace_name(::protozero::ConstChars chars)1047   void set_loaded_trace_name(::protozero::ConstChars chars) {
1048     AppendBytes(FieldMetadata_LoadedTraceName::kFieldId, chars.data, chars.size);
1049   }
set_loaded_trace_name(std::string value)1050   void set_loaded_trace_name(std::string value) {
1051     static constexpr uint32_t field_id = FieldMetadata_LoadedTraceName::kFieldId;
1052     // Call the appropriate protozero::Message::Append(field_id, ...)
1053     // method based on the type of the field.
1054     ::protozero::internal::FieldWriter<
1055       ::protozero::proto_utils::ProtoSchemaType::kString>
1056         ::Append(*this, field_id, value);
1057   }
1058 
1059   using FieldMetadata_HumanReadableVersion =
1060     ::protozero::proto_utils::FieldMetadata<
1061       2,
1062       ::protozero::proto_utils::RepetitionType::kNotRepeated,
1063       ::protozero::proto_utils::ProtoSchemaType::kString,
1064       std::string,
1065       StatusResult>;
1066 
1067   static constexpr FieldMetadata_HumanReadableVersion kHumanReadableVersion{};
set_human_readable_version(const char * data,size_t size)1068   void set_human_readable_version(const char* data, size_t size) {
1069     AppendBytes(FieldMetadata_HumanReadableVersion::kFieldId, data, size);
1070   }
set_human_readable_version(::protozero::ConstChars chars)1071   void set_human_readable_version(::protozero::ConstChars chars) {
1072     AppendBytes(FieldMetadata_HumanReadableVersion::kFieldId, chars.data, chars.size);
1073   }
set_human_readable_version(std::string value)1074   void set_human_readable_version(std::string value) {
1075     static constexpr uint32_t field_id = FieldMetadata_HumanReadableVersion::kFieldId;
1076     // Call the appropriate protozero::Message::Append(field_id, ...)
1077     // method based on the type of the field.
1078     ::protozero::internal::FieldWriter<
1079       ::protozero::proto_utils::ProtoSchemaType::kString>
1080         ::Append(*this, field_id, value);
1081   }
1082 
1083   using FieldMetadata_ApiVersion =
1084     ::protozero::proto_utils::FieldMetadata<
1085       3,
1086       ::protozero::proto_utils::RepetitionType::kNotRepeated,
1087       ::protozero::proto_utils::ProtoSchemaType::kInt32,
1088       int32_t,
1089       StatusResult>;
1090 
1091   static constexpr FieldMetadata_ApiVersion kApiVersion{};
set_api_version(int32_t value)1092   void set_api_version(int32_t value) {
1093     static constexpr uint32_t field_id = FieldMetadata_ApiVersion::kFieldId;
1094     // Call the appropriate protozero::Message::Append(field_id, ...)
1095     // method based on the type of the field.
1096     ::protozero::internal::FieldWriter<
1097       ::protozero::proto_utils::ProtoSchemaType::kInt32>
1098         ::Append(*this, field_id, value);
1099   }
1100 
1101   using FieldMetadata_VersionCode =
1102     ::protozero::proto_utils::FieldMetadata<
1103       4,
1104       ::protozero::proto_utils::RepetitionType::kNotRepeated,
1105       ::protozero::proto_utils::ProtoSchemaType::kString,
1106       std::string,
1107       StatusResult>;
1108 
1109   static constexpr FieldMetadata_VersionCode kVersionCode{};
set_version_code(const char * data,size_t size)1110   void set_version_code(const char* data, size_t size) {
1111     AppendBytes(FieldMetadata_VersionCode::kFieldId, data, size);
1112   }
set_version_code(::protozero::ConstChars chars)1113   void set_version_code(::protozero::ConstChars chars) {
1114     AppendBytes(FieldMetadata_VersionCode::kFieldId, chars.data, chars.size);
1115   }
set_version_code(std::string value)1116   void set_version_code(std::string value) {
1117     static constexpr uint32_t field_id = FieldMetadata_VersionCode::kFieldId;
1118     // Call the appropriate protozero::Message::Append(field_id, ...)
1119     // method based on the type of the field.
1120     ::protozero::internal::FieldWriter<
1121       ::protozero::proto_utils::ProtoSchemaType::kString>
1122         ::Append(*this, field_id, value);
1123   }
1124 };
1125 
1126 class StatusArgs_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/0, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
1127  public:
StatusArgs_Decoder(const uint8_t * data,size_t len)1128   StatusArgs_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
StatusArgs_Decoder(const std::string & raw)1129   explicit StatusArgs_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
StatusArgs_Decoder(const::protozero::ConstBytes & raw)1130   explicit StatusArgs_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
1131 };
1132 
1133 class StatusArgs : public ::protozero::Message {
1134  public:
1135   using Decoder = StatusArgs_Decoder;
GetName()1136   static constexpr const char* GetName() { return ".perfetto.protos.StatusArgs"; }
1137 
1138 };
1139 
1140 class QueryResult_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
1141  public:
QueryResult_Decoder(const uint8_t * data,size_t len)1142   QueryResult_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
QueryResult_Decoder(const std::string & raw)1143   explicit QueryResult_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
QueryResult_Decoder(const::protozero::ConstBytes & raw)1144   explicit QueryResult_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
has_column_names()1145   bool has_column_names() const { return at<1>().valid(); }
column_names()1146   ::protozero::RepeatedFieldIterator<::protozero::ConstChars> column_names() const { return GetRepeated<::protozero::ConstChars>(1); }
has_error()1147   bool has_error() const { return at<2>().valid(); }
error()1148   ::protozero::ConstChars error() const { return at<2>().as_string(); }
has_batch()1149   bool has_batch() const { return at<3>().valid(); }
batch()1150   ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> batch() const { return GetRepeated<::protozero::ConstBytes>(3); }
has_statement_count()1151   bool has_statement_count() const { return at<4>().valid(); }
statement_count()1152   uint32_t statement_count() const { return at<4>().as_uint32(); }
has_statement_with_output_count()1153   bool has_statement_with_output_count() const { return at<5>().valid(); }
statement_with_output_count()1154   uint32_t statement_with_output_count() const { return at<5>().as_uint32(); }
has_last_statement_sql()1155   bool has_last_statement_sql() const { return at<6>().valid(); }
last_statement_sql()1156   ::protozero::ConstChars last_statement_sql() const { return at<6>().as_string(); }
1157 };
1158 
1159 class QueryResult : public ::protozero::Message {
1160  public:
1161   using Decoder = QueryResult_Decoder;
1162   enum : int32_t {
1163     kColumnNamesFieldNumber = 1,
1164     kErrorFieldNumber = 2,
1165     kBatchFieldNumber = 3,
1166     kStatementCountFieldNumber = 4,
1167     kStatementWithOutputCountFieldNumber = 5,
1168     kLastStatementSqlFieldNumber = 6,
1169   };
GetName()1170   static constexpr const char* GetName() { return ".perfetto.protos.QueryResult"; }
1171 
1172   using CellsBatch = ::perfetto::protos::pbzero::QueryResult_CellsBatch;
1173 
1174   using FieldMetadata_ColumnNames =
1175     ::protozero::proto_utils::FieldMetadata<
1176       1,
1177       ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
1178       ::protozero::proto_utils::ProtoSchemaType::kString,
1179       std::string,
1180       QueryResult>;
1181 
1182   static constexpr FieldMetadata_ColumnNames kColumnNames{};
add_column_names(const char * data,size_t size)1183   void add_column_names(const char* data, size_t size) {
1184     AppendBytes(FieldMetadata_ColumnNames::kFieldId, data, size);
1185   }
add_column_names(::protozero::ConstChars chars)1186   void add_column_names(::protozero::ConstChars chars) {
1187     AppendBytes(FieldMetadata_ColumnNames::kFieldId, chars.data, chars.size);
1188   }
add_column_names(std::string value)1189   void add_column_names(std::string value) {
1190     static constexpr uint32_t field_id = FieldMetadata_ColumnNames::kFieldId;
1191     // Call the appropriate protozero::Message::Append(field_id, ...)
1192     // method based on the type of the field.
1193     ::protozero::internal::FieldWriter<
1194       ::protozero::proto_utils::ProtoSchemaType::kString>
1195         ::Append(*this, field_id, value);
1196   }
1197 
1198   using FieldMetadata_Error =
1199     ::protozero::proto_utils::FieldMetadata<
1200       2,
1201       ::protozero::proto_utils::RepetitionType::kNotRepeated,
1202       ::protozero::proto_utils::ProtoSchemaType::kString,
1203       std::string,
1204       QueryResult>;
1205 
1206   static constexpr FieldMetadata_Error kError{};
set_error(const char * data,size_t size)1207   void set_error(const char* data, size_t size) {
1208     AppendBytes(FieldMetadata_Error::kFieldId, data, size);
1209   }
set_error(::protozero::ConstChars chars)1210   void set_error(::protozero::ConstChars chars) {
1211     AppendBytes(FieldMetadata_Error::kFieldId, chars.data, chars.size);
1212   }
set_error(std::string value)1213   void set_error(std::string value) {
1214     static constexpr uint32_t field_id = FieldMetadata_Error::kFieldId;
1215     // Call the appropriate protozero::Message::Append(field_id, ...)
1216     // method based on the type of the field.
1217     ::protozero::internal::FieldWriter<
1218       ::protozero::proto_utils::ProtoSchemaType::kString>
1219         ::Append(*this, field_id, value);
1220   }
1221 
1222   using FieldMetadata_Batch =
1223     ::protozero::proto_utils::FieldMetadata<
1224       3,
1225       ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
1226       ::protozero::proto_utils::ProtoSchemaType::kMessage,
1227       QueryResult_CellsBatch,
1228       QueryResult>;
1229 
1230   static constexpr FieldMetadata_Batch kBatch{};
add_batch()1231   template <typename T = QueryResult_CellsBatch> T* add_batch() {
1232     return BeginNestedMessage<T>(3);
1233   }
1234 
1235 
1236   using FieldMetadata_StatementCount =
1237     ::protozero::proto_utils::FieldMetadata<
1238       4,
1239       ::protozero::proto_utils::RepetitionType::kNotRepeated,
1240       ::protozero::proto_utils::ProtoSchemaType::kUint32,
1241       uint32_t,
1242       QueryResult>;
1243 
1244   static constexpr FieldMetadata_StatementCount kStatementCount{};
set_statement_count(uint32_t value)1245   void set_statement_count(uint32_t value) {
1246     static constexpr uint32_t field_id = FieldMetadata_StatementCount::kFieldId;
1247     // Call the appropriate protozero::Message::Append(field_id, ...)
1248     // method based on the type of the field.
1249     ::protozero::internal::FieldWriter<
1250       ::protozero::proto_utils::ProtoSchemaType::kUint32>
1251         ::Append(*this, field_id, value);
1252   }
1253 
1254   using FieldMetadata_StatementWithOutputCount =
1255     ::protozero::proto_utils::FieldMetadata<
1256       5,
1257       ::protozero::proto_utils::RepetitionType::kNotRepeated,
1258       ::protozero::proto_utils::ProtoSchemaType::kUint32,
1259       uint32_t,
1260       QueryResult>;
1261 
1262   static constexpr FieldMetadata_StatementWithOutputCount kStatementWithOutputCount{};
set_statement_with_output_count(uint32_t value)1263   void set_statement_with_output_count(uint32_t value) {
1264     static constexpr uint32_t field_id = FieldMetadata_StatementWithOutputCount::kFieldId;
1265     // Call the appropriate protozero::Message::Append(field_id, ...)
1266     // method based on the type of the field.
1267     ::protozero::internal::FieldWriter<
1268       ::protozero::proto_utils::ProtoSchemaType::kUint32>
1269         ::Append(*this, field_id, value);
1270   }
1271 
1272   using FieldMetadata_LastStatementSql =
1273     ::protozero::proto_utils::FieldMetadata<
1274       6,
1275       ::protozero::proto_utils::RepetitionType::kNotRepeated,
1276       ::protozero::proto_utils::ProtoSchemaType::kString,
1277       std::string,
1278       QueryResult>;
1279 
1280   static constexpr FieldMetadata_LastStatementSql kLastStatementSql{};
set_last_statement_sql(const char * data,size_t size)1281   void set_last_statement_sql(const char* data, size_t size) {
1282     AppendBytes(FieldMetadata_LastStatementSql::kFieldId, data, size);
1283   }
set_last_statement_sql(::protozero::ConstChars chars)1284   void set_last_statement_sql(::protozero::ConstChars chars) {
1285     AppendBytes(FieldMetadata_LastStatementSql::kFieldId, chars.data, chars.size);
1286   }
set_last_statement_sql(std::string value)1287   void set_last_statement_sql(std::string value) {
1288     static constexpr uint32_t field_id = FieldMetadata_LastStatementSql::kFieldId;
1289     // Call the appropriate protozero::Message::Append(field_id, ...)
1290     // method based on the type of the field.
1291     ::protozero::internal::FieldWriter<
1292       ::protozero::proto_utils::ProtoSchemaType::kString>
1293         ::Append(*this, field_id, value);
1294   }
1295 };
1296 
1297 class QueryResult_CellsBatch_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
1298  public:
QueryResult_CellsBatch_Decoder(const uint8_t * data,size_t len)1299   QueryResult_CellsBatch_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
QueryResult_CellsBatch_Decoder(const std::string & raw)1300   explicit QueryResult_CellsBatch_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
QueryResult_CellsBatch_Decoder(const::protozero::ConstBytes & raw)1301   explicit QueryResult_CellsBatch_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
has_cells()1302   bool has_cells() const { return at<1>().valid(); }
cells(bool * parse_error_ptr)1303   ::protozero::PackedRepeatedFieldIterator<::protozero::proto_utils::ProtoWireType::kVarInt, int32_t> cells(bool* parse_error_ptr) const { return GetPackedRepeated<::protozero::proto_utils::ProtoWireType::kVarInt, int32_t>(1, parse_error_ptr); }
has_varint_cells()1304   bool has_varint_cells() const { return at<2>().valid(); }
varint_cells(bool * parse_error_ptr)1305   ::protozero::PackedRepeatedFieldIterator<::protozero::proto_utils::ProtoWireType::kVarInt, int64_t> varint_cells(bool* parse_error_ptr) const { return GetPackedRepeated<::protozero::proto_utils::ProtoWireType::kVarInt, int64_t>(2, parse_error_ptr); }
has_float64_cells()1306   bool has_float64_cells() const { return at<3>().valid(); }
float64_cells(bool * parse_error_ptr)1307   ::protozero::PackedRepeatedFieldIterator<::protozero::proto_utils::ProtoWireType::kFixed64, double> float64_cells(bool* parse_error_ptr) const { return GetPackedRepeated<::protozero::proto_utils::ProtoWireType::kFixed64, double>(3, parse_error_ptr); }
has_blob_cells()1308   bool has_blob_cells() const { return at<4>().valid(); }
blob_cells()1309   ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> blob_cells() const { return GetRepeated<::protozero::ConstBytes>(4); }
has_string_cells()1310   bool has_string_cells() const { return at<5>().valid(); }
string_cells()1311   ::protozero::ConstChars string_cells() const { return at<5>().as_string(); }
has_is_last_batch()1312   bool has_is_last_batch() const { return at<6>().valid(); }
is_last_batch()1313   bool is_last_batch() const { return at<6>().as_bool(); }
1314 };
1315 
1316 class QueryResult_CellsBatch : public ::protozero::Message {
1317  public:
1318   using Decoder = QueryResult_CellsBatch_Decoder;
1319   enum : int32_t {
1320     kCellsFieldNumber = 1,
1321     kVarintCellsFieldNumber = 2,
1322     kFloat64CellsFieldNumber = 3,
1323     kBlobCellsFieldNumber = 4,
1324     kStringCellsFieldNumber = 5,
1325     kIsLastBatchFieldNumber = 6,
1326   };
GetName()1327   static constexpr const char* GetName() { return ".perfetto.protos.QueryResult.CellsBatch"; }
1328 
1329 
1330   using CellType = ::perfetto::protos::pbzero::QueryResult_CellsBatch_CellType;
CellType_Name(CellType value)1331   static inline const char* CellType_Name(CellType value) {
1332     return ::perfetto::protos::pbzero::QueryResult_CellsBatch_CellType_Name(value);
1333   }
1334   static inline const CellType CELL_INVALID = CellType::CELL_INVALID;
1335   static inline const CellType CELL_NULL = CellType::CELL_NULL;
1336   static inline const CellType CELL_VARINT = CellType::CELL_VARINT;
1337   static inline const CellType CELL_FLOAT64 = CellType::CELL_FLOAT64;
1338   static inline const CellType CELL_STRING = CellType::CELL_STRING;
1339   static inline const CellType CELL_BLOB = CellType::CELL_BLOB;
1340 
1341   using FieldMetadata_Cells =
1342     ::protozero::proto_utils::FieldMetadata<
1343       1,
1344       ::protozero::proto_utils::RepetitionType::kRepeatedPacked,
1345       ::protozero::proto_utils::ProtoSchemaType::kEnum,
1346       QueryResult_CellsBatch_CellType,
1347       QueryResult_CellsBatch>;
1348 
1349   static constexpr FieldMetadata_Cells kCells{};
set_cells(const::protozero::PackedVarInt & packed_buffer)1350   void set_cells(const ::protozero::PackedVarInt& packed_buffer) {
1351     AppendBytes(FieldMetadata_Cells::kFieldId, packed_buffer.data(),
1352                 packed_buffer.size());
1353   }
1354 
1355   using FieldMetadata_VarintCells =
1356     ::protozero::proto_utils::FieldMetadata<
1357       2,
1358       ::protozero::proto_utils::RepetitionType::kRepeatedPacked,
1359       ::protozero::proto_utils::ProtoSchemaType::kInt64,
1360       int64_t,
1361       QueryResult_CellsBatch>;
1362 
1363   static constexpr FieldMetadata_VarintCells kVarintCells{};
set_varint_cells(const::protozero::PackedVarInt & packed_buffer)1364   void set_varint_cells(const ::protozero::PackedVarInt& packed_buffer) {
1365     AppendBytes(FieldMetadata_VarintCells::kFieldId, packed_buffer.data(),
1366                 packed_buffer.size());
1367   }
1368 
1369   using FieldMetadata_Float64Cells =
1370     ::protozero::proto_utils::FieldMetadata<
1371       3,
1372       ::protozero::proto_utils::RepetitionType::kRepeatedPacked,
1373       ::protozero::proto_utils::ProtoSchemaType::kDouble,
1374       double,
1375       QueryResult_CellsBatch>;
1376 
1377   static constexpr FieldMetadata_Float64Cells kFloat64Cells{};
set_float64_cells(const::protozero::PackedFixedSizeInt<double> & packed_buffer)1378   void set_float64_cells(const ::protozero::PackedFixedSizeInt<double>& packed_buffer) {
1379     AppendBytes(FieldMetadata_Float64Cells::kFieldId, packed_buffer.data(),
1380                 packed_buffer.size());
1381   }
1382 
1383   using FieldMetadata_BlobCells =
1384     ::protozero::proto_utils::FieldMetadata<
1385       4,
1386       ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
1387       ::protozero::proto_utils::ProtoSchemaType::kBytes,
1388       std::string,
1389       QueryResult_CellsBatch>;
1390 
1391   static constexpr FieldMetadata_BlobCells kBlobCells{};
add_blob_cells(const uint8_t * data,size_t size)1392   void add_blob_cells(const uint8_t* data, size_t size) {
1393     AppendBytes(FieldMetadata_BlobCells::kFieldId, data, size);
1394   }
add_blob_cells(::protozero::ConstBytes bytes)1395   void add_blob_cells(::protozero::ConstBytes bytes) {
1396     AppendBytes(FieldMetadata_BlobCells::kFieldId, bytes.data, bytes.size);
1397   }
add_blob_cells(std::string value)1398   void add_blob_cells(std::string value) {
1399     static constexpr uint32_t field_id = FieldMetadata_BlobCells::kFieldId;
1400     // Call the appropriate protozero::Message::Append(field_id, ...)
1401     // method based on the type of the field.
1402     ::protozero::internal::FieldWriter<
1403       ::protozero::proto_utils::ProtoSchemaType::kBytes>
1404         ::Append(*this, field_id, value);
1405   }
1406 
1407   using FieldMetadata_StringCells =
1408     ::protozero::proto_utils::FieldMetadata<
1409       5,
1410       ::protozero::proto_utils::RepetitionType::kNotRepeated,
1411       ::protozero::proto_utils::ProtoSchemaType::kString,
1412       std::string,
1413       QueryResult_CellsBatch>;
1414 
1415   static constexpr FieldMetadata_StringCells kStringCells{};
set_string_cells(const char * data,size_t size)1416   void set_string_cells(const char* data, size_t size) {
1417     AppendBytes(FieldMetadata_StringCells::kFieldId, data, size);
1418   }
set_string_cells(::protozero::ConstChars chars)1419   void set_string_cells(::protozero::ConstChars chars) {
1420     AppendBytes(FieldMetadata_StringCells::kFieldId, chars.data, chars.size);
1421   }
set_string_cells(std::string value)1422   void set_string_cells(std::string value) {
1423     static constexpr uint32_t field_id = FieldMetadata_StringCells::kFieldId;
1424     // Call the appropriate protozero::Message::Append(field_id, ...)
1425     // method based on the type of the field.
1426     ::protozero::internal::FieldWriter<
1427       ::protozero::proto_utils::ProtoSchemaType::kString>
1428         ::Append(*this, field_id, value);
1429   }
1430 
1431   using FieldMetadata_IsLastBatch =
1432     ::protozero::proto_utils::FieldMetadata<
1433       6,
1434       ::protozero::proto_utils::RepetitionType::kNotRepeated,
1435       ::protozero::proto_utils::ProtoSchemaType::kBool,
1436       bool,
1437       QueryResult_CellsBatch>;
1438 
1439   static constexpr FieldMetadata_IsLastBatch kIsLastBatch{};
set_is_last_batch(bool value)1440   void set_is_last_batch(bool value) {
1441     static constexpr uint32_t field_id = FieldMetadata_IsLastBatch::kFieldId;
1442     // Call the appropriate protozero::Message::Append(field_id, ...)
1443     // method based on the type of the field.
1444     ::protozero::internal::FieldWriter<
1445       ::protozero::proto_utils::ProtoSchemaType::kBool>
1446         ::Append(*this, field_id, value);
1447   }
1448 };
1449 
1450 class QueryArgs_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
1451  public:
QueryArgs_Decoder(const uint8_t * data,size_t len)1452   QueryArgs_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
QueryArgs_Decoder(const std::string & raw)1453   explicit QueryArgs_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
QueryArgs_Decoder(const::protozero::ConstBytes & raw)1454   explicit QueryArgs_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
has_sql_query()1455   bool has_sql_query() const { return at<1>().valid(); }
sql_query()1456   ::protozero::ConstChars sql_query() const { return at<1>().as_string(); }
has_tag()1457   bool has_tag() const { return at<3>().valid(); }
tag()1458   ::protozero::ConstChars tag() const { return at<3>().as_string(); }
1459 };
1460 
1461 class QueryArgs : public ::protozero::Message {
1462  public:
1463   using Decoder = QueryArgs_Decoder;
1464   enum : int32_t {
1465     kSqlQueryFieldNumber = 1,
1466     kTagFieldNumber = 3,
1467   };
GetName()1468   static constexpr const char* GetName() { return ".perfetto.protos.QueryArgs"; }
1469 
1470 
1471   using FieldMetadata_SqlQuery =
1472     ::protozero::proto_utils::FieldMetadata<
1473       1,
1474       ::protozero::proto_utils::RepetitionType::kNotRepeated,
1475       ::protozero::proto_utils::ProtoSchemaType::kString,
1476       std::string,
1477       QueryArgs>;
1478 
1479   static constexpr FieldMetadata_SqlQuery kSqlQuery{};
set_sql_query(const char * data,size_t size)1480   void set_sql_query(const char* data, size_t size) {
1481     AppendBytes(FieldMetadata_SqlQuery::kFieldId, data, size);
1482   }
set_sql_query(::protozero::ConstChars chars)1483   void set_sql_query(::protozero::ConstChars chars) {
1484     AppendBytes(FieldMetadata_SqlQuery::kFieldId, chars.data, chars.size);
1485   }
set_sql_query(std::string value)1486   void set_sql_query(std::string value) {
1487     static constexpr uint32_t field_id = FieldMetadata_SqlQuery::kFieldId;
1488     // Call the appropriate protozero::Message::Append(field_id, ...)
1489     // method based on the type of the field.
1490     ::protozero::internal::FieldWriter<
1491       ::protozero::proto_utils::ProtoSchemaType::kString>
1492         ::Append(*this, field_id, value);
1493   }
1494 
1495   using FieldMetadata_Tag =
1496     ::protozero::proto_utils::FieldMetadata<
1497       3,
1498       ::protozero::proto_utils::RepetitionType::kNotRepeated,
1499       ::protozero::proto_utils::ProtoSchemaType::kString,
1500       std::string,
1501       QueryArgs>;
1502 
1503   static constexpr FieldMetadata_Tag kTag{};
set_tag(const char * data,size_t size)1504   void set_tag(const char* data, size_t size) {
1505     AppendBytes(FieldMetadata_Tag::kFieldId, data, size);
1506   }
set_tag(::protozero::ConstChars chars)1507   void set_tag(::protozero::ConstChars chars) {
1508     AppendBytes(FieldMetadata_Tag::kFieldId, chars.data, chars.size);
1509   }
set_tag(std::string value)1510   void set_tag(std::string value) {
1511     static constexpr uint32_t field_id = FieldMetadata_Tag::kFieldId;
1512     // Call the appropriate protozero::Message::Append(field_id, ...)
1513     // method based on the type of the field.
1514     ::protozero::internal::FieldWriter<
1515       ::protozero::proto_utils::ProtoSchemaType::kString>
1516         ::Append(*this, field_id, value);
1517   }
1518 };
1519 
1520 class AppendTraceDataResult_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
1521  public:
AppendTraceDataResult_Decoder(const uint8_t * data,size_t len)1522   AppendTraceDataResult_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
AppendTraceDataResult_Decoder(const std::string & raw)1523   explicit AppendTraceDataResult_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
AppendTraceDataResult_Decoder(const::protozero::ConstBytes & raw)1524   explicit AppendTraceDataResult_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
has_total_bytes_parsed()1525   bool has_total_bytes_parsed() const { return at<1>().valid(); }
total_bytes_parsed()1526   int64_t total_bytes_parsed() const { return at<1>().as_int64(); }
has_error()1527   bool has_error() const { return at<2>().valid(); }
error()1528   ::protozero::ConstChars error() const { return at<2>().as_string(); }
1529 };
1530 
1531 class AppendTraceDataResult : public ::protozero::Message {
1532  public:
1533   using Decoder = AppendTraceDataResult_Decoder;
1534   enum : int32_t {
1535     kTotalBytesParsedFieldNumber = 1,
1536     kErrorFieldNumber = 2,
1537   };
GetName()1538   static constexpr const char* GetName() { return ".perfetto.protos.AppendTraceDataResult"; }
1539 
1540 
1541   using FieldMetadata_TotalBytesParsed =
1542     ::protozero::proto_utils::FieldMetadata<
1543       1,
1544       ::protozero::proto_utils::RepetitionType::kNotRepeated,
1545       ::protozero::proto_utils::ProtoSchemaType::kInt64,
1546       int64_t,
1547       AppendTraceDataResult>;
1548 
1549   static constexpr FieldMetadata_TotalBytesParsed kTotalBytesParsed{};
set_total_bytes_parsed(int64_t value)1550   void set_total_bytes_parsed(int64_t value) {
1551     static constexpr uint32_t field_id = FieldMetadata_TotalBytesParsed::kFieldId;
1552     // Call the appropriate protozero::Message::Append(field_id, ...)
1553     // method based on the type of the field.
1554     ::protozero::internal::FieldWriter<
1555       ::protozero::proto_utils::ProtoSchemaType::kInt64>
1556         ::Append(*this, field_id, value);
1557   }
1558 
1559   using FieldMetadata_Error =
1560     ::protozero::proto_utils::FieldMetadata<
1561       2,
1562       ::protozero::proto_utils::RepetitionType::kNotRepeated,
1563       ::protozero::proto_utils::ProtoSchemaType::kString,
1564       std::string,
1565       AppendTraceDataResult>;
1566 
1567   static constexpr FieldMetadata_Error kError{};
set_error(const char * data,size_t size)1568   void set_error(const char* data, size_t size) {
1569     AppendBytes(FieldMetadata_Error::kFieldId, data, size);
1570   }
set_error(::protozero::ConstChars chars)1571   void set_error(::protozero::ConstChars chars) {
1572     AppendBytes(FieldMetadata_Error::kFieldId, chars.data, chars.size);
1573   }
set_error(std::string value)1574   void set_error(std::string value) {
1575     static constexpr uint32_t field_id = FieldMetadata_Error::kFieldId;
1576     // Call the appropriate protozero::Message::Append(field_id, ...)
1577     // method based on the type of the field.
1578     ::protozero::internal::FieldWriter<
1579       ::protozero::proto_utils::ProtoSchemaType::kString>
1580         ::Append(*this, field_id, value);
1581   }
1582 };
1583 
1584 class TraceProcessorRpc_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/212, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
1585  public:
TraceProcessorRpc_Decoder(const uint8_t * data,size_t len)1586   TraceProcessorRpc_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
TraceProcessorRpc_Decoder(const std::string & raw)1587   explicit TraceProcessorRpc_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
TraceProcessorRpc_Decoder(const::protozero::ConstBytes & raw)1588   explicit TraceProcessorRpc_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
has_seq()1589   bool has_seq() const { return at<1>().valid(); }
seq()1590   int64_t seq() const { return at<1>().as_int64(); }
has_fatal_error()1591   bool has_fatal_error() const { return at<5>().valid(); }
fatal_error()1592   ::protozero::ConstChars fatal_error() const { return at<5>().as_string(); }
has_request()1593   bool has_request() const { return at<2>().valid(); }
request()1594   int32_t request() const { return at<2>().as_int32(); }
has_response()1595   bool has_response() const { return at<3>().valid(); }
response()1596   int32_t response() const { return at<3>().as_int32(); }
has_invalid_request()1597   bool has_invalid_request() const { return at<4>().valid(); }
invalid_request()1598   int32_t invalid_request() const { return at<4>().as_int32(); }
has_append_trace_data()1599   bool has_append_trace_data() const { return at<101>().valid(); }
append_trace_data()1600   ::protozero::ConstBytes append_trace_data() const { return at<101>().as_bytes(); }
has_query_args()1601   bool has_query_args() const { return at<103>().valid(); }
query_args()1602   ::protozero::ConstBytes query_args() const { return at<103>().as_bytes(); }
has_compute_metric_args()1603   bool has_compute_metric_args() const { return at<105>().valid(); }
compute_metric_args()1604   ::protozero::ConstBytes compute_metric_args() const { return at<105>().as_bytes(); }
has_enable_metatrace_args()1605   bool has_enable_metatrace_args() const { return at<106>().valid(); }
enable_metatrace_args()1606   ::protozero::ConstBytes enable_metatrace_args() const { return at<106>().as_bytes(); }
has_reset_trace_processor_args()1607   bool has_reset_trace_processor_args() const { return at<107>().valid(); }
reset_trace_processor_args()1608   ::protozero::ConstBytes reset_trace_processor_args() const { return at<107>().as_bytes(); }
has_register_sql_package_args()1609   bool has_register_sql_package_args() const { return at<108>().valid(); }
register_sql_package_args()1610   ::protozero::ConstBytes register_sql_package_args() const { return at<108>().as_bytes(); }
has_append_result()1611   bool has_append_result() const { return at<201>().valid(); }
append_result()1612   ::protozero::ConstBytes append_result() const { return at<201>().as_bytes(); }
has_query_result()1613   bool has_query_result() const { return at<203>().valid(); }
query_result()1614   ::protozero::ConstBytes query_result() const { return at<203>().as_bytes(); }
has_metric_result()1615   bool has_metric_result() const { return at<205>().valid(); }
metric_result()1616   ::protozero::ConstBytes metric_result() const { return at<205>().as_bytes(); }
has_metric_descriptors()1617   bool has_metric_descriptors() const { return at<206>().valid(); }
metric_descriptors()1618   ::protozero::ConstBytes metric_descriptors() const { return at<206>().as_bytes(); }
has_metatrace()1619   bool has_metatrace() const { return at<209>().valid(); }
metatrace()1620   ::protozero::ConstBytes metatrace() const { return at<209>().as_bytes(); }
has_status()1621   bool has_status() const { return at<210>().valid(); }
status()1622   ::protozero::ConstBytes status() const { return at<210>().as_bytes(); }
has_register_sql_package_result()1623   bool has_register_sql_package_result() const { return at<211>().valid(); }
register_sql_package_result()1624   ::protozero::ConstBytes register_sql_package_result() const { return at<211>().as_bytes(); }
has_finalize_data_result()1625   bool has_finalize_data_result() const { return at<212>().valid(); }
finalize_data_result()1626   ::protozero::ConstBytes finalize_data_result() const { return at<212>().as_bytes(); }
1627 };
1628 
1629 class TraceProcessorRpc : public ::protozero::Message {
1630  public:
1631   using Decoder = TraceProcessorRpc_Decoder;
1632   enum : int32_t {
1633     kSeqFieldNumber = 1,
1634     kFatalErrorFieldNumber = 5,
1635     kRequestFieldNumber = 2,
1636     kResponseFieldNumber = 3,
1637     kInvalidRequestFieldNumber = 4,
1638     kAppendTraceDataFieldNumber = 101,
1639     kQueryArgsFieldNumber = 103,
1640     kComputeMetricArgsFieldNumber = 105,
1641     kEnableMetatraceArgsFieldNumber = 106,
1642     kResetTraceProcessorArgsFieldNumber = 107,
1643     kRegisterSqlPackageArgsFieldNumber = 108,
1644     kAppendResultFieldNumber = 201,
1645     kQueryResultFieldNumber = 203,
1646     kMetricResultFieldNumber = 205,
1647     kMetricDescriptorsFieldNumber = 206,
1648     kMetatraceFieldNumber = 209,
1649     kStatusFieldNumber = 210,
1650     kRegisterSqlPackageResultFieldNumber = 211,
1651     kFinalizeDataResultFieldNumber = 212,
1652   };
GetName()1653   static constexpr const char* GetName() { return ".perfetto.protos.TraceProcessorRpc"; }
1654 
1655 
1656   using TraceProcessorMethod = ::perfetto::protos::pbzero::TraceProcessorRpc_TraceProcessorMethod;
TraceProcessorMethod_Name(TraceProcessorMethod value)1657   static inline const char* TraceProcessorMethod_Name(TraceProcessorMethod value) {
1658     return ::perfetto::protos::pbzero::TraceProcessorRpc_TraceProcessorMethod_Name(value);
1659   }
1660   static inline const TraceProcessorMethod TPM_UNSPECIFIED = TraceProcessorMethod::TPM_UNSPECIFIED;
1661   static inline const TraceProcessorMethod TPM_APPEND_TRACE_DATA = TraceProcessorMethod::TPM_APPEND_TRACE_DATA;
1662   static inline const TraceProcessorMethod TPM_FINALIZE_TRACE_DATA = TraceProcessorMethod::TPM_FINALIZE_TRACE_DATA;
1663   static inline const TraceProcessorMethod TPM_QUERY_STREAMING = TraceProcessorMethod::TPM_QUERY_STREAMING;
1664   static inline const TraceProcessorMethod TPM_COMPUTE_METRIC = TraceProcessorMethod::TPM_COMPUTE_METRIC;
1665   static inline const TraceProcessorMethod TPM_GET_METRIC_DESCRIPTORS = TraceProcessorMethod::TPM_GET_METRIC_DESCRIPTORS;
1666   static inline const TraceProcessorMethod TPM_RESTORE_INITIAL_TABLES = TraceProcessorMethod::TPM_RESTORE_INITIAL_TABLES;
1667   static inline const TraceProcessorMethod TPM_ENABLE_METATRACE = TraceProcessorMethod::TPM_ENABLE_METATRACE;
1668   static inline const TraceProcessorMethod TPM_DISABLE_AND_READ_METATRACE = TraceProcessorMethod::TPM_DISABLE_AND_READ_METATRACE;
1669   static inline const TraceProcessorMethod TPM_GET_STATUS = TraceProcessorMethod::TPM_GET_STATUS;
1670   static inline const TraceProcessorMethod TPM_RESET_TRACE_PROCESSOR = TraceProcessorMethod::TPM_RESET_TRACE_PROCESSOR;
1671   static inline const TraceProcessorMethod TPM_REGISTER_SQL_PACKAGE = TraceProcessorMethod::TPM_REGISTER_SQL_PACKAGE;
1672 
1673   using FieldMetadata_Seq =
1674     ::protozero::proto_utils::FieldMetadata<
1675       1,
1676       ::protozero::proto_utils::RepetitionType::kNotRepeated,
1677       ::protozero::proto_utils::ProtoSchemaType::kInt64,
1678       int64_t,
1679       TraceProcessorRpc>;
1680 
1681   static constexpr FieldMetadata_Seq kSeq{};
set_seq(int64_t value)1682   void set_seq(int64_t value) {
1683     static constexpr uint32_t field_id = FieldMetadata_Seq::kFieldId;
1684     // Call the appropriate protozero::Message::Append(field_id, ...)
1685     // method based on the type of the field.
1686     ::protozero::internal::FieldWriter<
1687       ::protozero::proto_utils::ProtoSchemaType::kInt64>
1688         ::Append(*this, field_id, value);
1689   }
1690 
1691   using FieldMetadata_FatalError =
1692     ::protozero::proto_utils::FieldMetadata<
1693       5,
1694       ::protozero::proto_utils::RepetitionType::kNotRepeated,
1695       ::protozero::proto_utils::ProtoSchemaType::kString,
1696       std::string,
1697       TraceProcessorRpc>;
1698 
1699   static constexpr FieldMetadata_FatalError kFatalError{};
set_fatal_error(const char * data,size_t size)1700   void set_fatal_error(const char* data, size_t size) {
1701     AppendBytes(FieldMetadata_FatalError::kFieldId, data, size);
1702   }
set_fatal_error(::protozero::ConstChars chars)1703   void set_fatal_error(::protozero::ConstChars chars) {
1704     AppendBytes(FieldMetadata_FatalError::kFieldId, chars.data, chars.size);
1705   }
set_fatal_error(std::string value)1706   void set_fatal_error(std::string value) {
1707     static constexpr uint32_t field_id = FieldMetadata_FatalError::kFieldId;
1708     // Call the appropriate protozero::Message::Append(field_id, ...)
1709     // method based on the type of the field.
1710     ::protozero::internal::FieldWriter<
1711       ::protozero::proto_utils::ProtoSchemaType::kString>
1712         ::Append(*this, field_id, value);
1713   }
1714 
1715   using FieldMetadata_Request =
1716     ::protozero::proto_utils::FieldMetadata<
1717       2,
1718       ::protozero::proto_utils::RepetitionType::kNotRepeated,
1719       ::protozero::proto_utils::ProtoSchemaType::kEnum,
1720       TraceProcessorRpc_TraceProcessorMethod,
1721       TraceProcessorRpc>;
1722 
1723   static constexpr FieldMetadata_Request kRequest{};
set_request(TraceProcessorRpc_TraceProcessorMethod value)1724   void set_request(TraceProcessorRpc_TraceProcessorMethod value) {
1725     static constexpr uint32_t field_id = FieldMetadata_Request::kFieldId;
1726     // Call the appropriate protozero::Message::Append(field_id, ...)
1727     // method based on the type of the field.
1728     ::protozero::internal::FieldWriter<
1729       ::protozero::proto_utils::ProtoSchemaType::kEnum>
1730         ::Append(*this, field_id, value);
1731   }
1732 
1733   using FieldMetadata_Response =
1734     ::protozero::proto_utils::FieldMetadata<
1735       3,
1736       ::protozero::proto_utils::RepetitionType::kNotRepeated,
1737       ::protozero::proto_utils::ProtoSchemaType::kEnum,
1738       TraceProcessorRpc_TraceProcessorMethod,
1739       TraceProcessorRpc>;
1740 
1741   static constexpr FieldMetadata_Response kResponse{};
set_response(TraceProcessorRpc_TraceProcessorMethod value)1742   void set_response(TraceProcessorRpc_TraceProcessorMethod value) {
1743     static constexpr uint32_t field_id = FieldMetadata_Response::kFieldId;
1744     // Call the appropriate protozero::Message::Append(field_id, ...)
1745     // method based on the type of the field.
1746     ::protozero::internal::FieldWriter<
1747       ::protozero::proto_utils::ProtoSchemaType::kEnum>
1748         ::Append(*this, field_id, value);
1749   }
1750 
1751   using FieldMetadata_InvalidRequest =
1752     ::protozero::proto_utils::FieldMetadata<
1753       4,
1754       ::protozero::proto_utils::RepetitionType::kNotRepeated,
1755       ::protozero::proto_utils::ProtoSchemaType::kEnum,
1756       TraceProcessorRpc_TraceProcessorMethod,
1757       TraceProcessorRpc>;
1758 
1759   static constexpr FieldMetadata_InvalidRequest kInvalidRequest{};
set_invalid_request(TraceProcessorRpc_TraceProcessorMethod value)1760   void set_invalid_request(TraceProcessorRpc_TraceProcessorMethod value) {
1761     static constexpr uint32_t field_id = FieldMetadata_InvalidRequest::kFieldId;
1762     // Call the appropriate protozero::Message::Append(field_id, ...)
1763     // method based on the type of the field.
1764     ::protozero::internal::FieldWriter<
1765       ::protozero::proto_utils::ProtoSchemaType::kEnum>
1766         ::Append(*this, field_id, value);
1767   }
1768 
1769   using FieldMetadata_AppendTraceData =
1770     ::protozero::proto_utils::FieldMetadata<
1771       101,
1772       ::protozero::proto_utils::RepetitionType::kNotRepeated,
1773       ::protozero::proto_utils::ProtoSchemaType::kBytes,
1774       std::string,
1775       TraceProcessorRpc>;
1776 
1777   static constexpr FieldMetadata_AppendTraceData kAppendTraceData{};
set_append_trace_data(const uint8_t * data,size_t size)1778   void set_append_trace_data(const uint8_t* data, size_t size) {
1779     AppendBytes(FieldMetadata_AppendTraceData::kFieldId, data, size);
1780   }
set_append_trace_data(::protozero::ConstBytes bytes)1781   void set_append_trace_data(::protozero::ConstBytes bytes) {
1782     AppendBytes(FieldMetadata_AppendTraceData::kFieldId, bytes.data, bytes.size);
1783   }
set_append_trace_data(std::string value)1784   void set_append_trace_data(std::string value) {
1785     static constexpr uint32_t field_id = FieldMetadata_AppendTraceData::kFieldId;
1786     // Call the appropriate protozero::Message::Append(field_id, ...)
1787     // method based on the type of the field.
1788     ::protozero::internal::FieldWriter<
1789       ::protozero::proto_utils::ProtoSchemaType::kBytes>
1790         ::Append(*this, field_id, value);
1791   }
1792 
1793   using FieldMetadata_QueryArgs =
1794     ::protozero::proto_utils::FieldMetadata<
1795       103,
1796       ::protozero::proto_utils::RepetitionType::kNotRepeated,
1797       ::protozero::proto_utils::ProtoSchemaType::kMessage,
1798       QueryArgs,
1799       TraceProcessorRpc>;
1800 
1801   static constexpr FieldMetadata_QueryArgs kQueryArgs{};
set_query_args()1802   template <typename T = QueryArgs> T* set_query_args() {
1803     return BeginNestedMessage<T>(103);
1804   }
1805 
1806 
1807   using FieldMetadata_ComputeMetricArgs =
1808     ::protozero::proto_utils::FieldMetadata<
1809       105,
1810       ::protozero::proto_utils::RepetitionType::kNotRepeated,
1811       ::protozero::proto_utils::ProtoSchemaType::kMessage,
1812       ComputeMetricArgs,
1813       TraceProcessorRpc>;
1814 
1815   static constexpr FieldMetadata_ComputeMetricArgs kComputeMetricArgs{};
set_compute_metric_args()1816   template <typename T = ComputeMetricArgs> T* set_compute_metric_args() {
1817     return BeginNestedMessage<T>(105);
1818   }
1819 
1820 
1821   using FieldMetadata_EnableMetatraceArgs =
1822     ::protozero::proto_utils::FieldMetadata<
1823       106,
1824       ::protozero::proto_utils::RepetitionType::kNotRepeated,
1825       ::protozero::proto_utils::ProtoSchemaType::kMessage,
1826       EnableMetatraceArgs,
1827       TraceProcessorRpc>;
1828 
1829   static constexpr FieldMetadata_EnableMetatraceArgs kEnableMetatraceArgs{};
set_enable_metatrace_args()1830   template <typename T = EnableMetatraceArgs> T* set_enable_metatrace_args() {
1831     return BeginNestedMessage<T>(106);
1832   }
1833 
1834 
1835   using FieldMetadata_ResetTraceProcessorArgs =
1836     ::protozero::proto_utils::FieldMetadata<
1837       107,
1838       ::protozero::proto_utils::RepetitionType::kNotRepeated,
1839       ::protozero::proto_utils::ProtoSchemaType::kMessage,
1840       ResetTraceProcessorArgs,
1841       TraceProcessorRpc>;
1842 
1843   static constexpr FieldMetadata_ResetTraceProcessorArgs kResetTraceProcessorArgs{};
set_reset_trace_processor_args()1844   template <typename T = ResetTraceProcessorArgs> T* set_reset_trace_processor_args() {
1845     return BeginNestedMessage<T>(107);
1846   }
1847 
1848 
1849   using FieldMetadata_RegisterSqlPackageArgs =
1850     ::protozero::proto_utils::FieldMetadata<
1851       108,
1852       ::protozero::proto_utils::RepetitionType::kNotRepeated,
1853       ::protozero::proto_utils::ProtoSchemaType::kMessage,
1854       RegisterSqlPackageArgs,
1855       TraceProcessorRpc>;
1856 
1857   static constexpr FieldMetadata_RegisterSqlPackageArgs kRegisterSqlPackageArgs{};
set_register_sql_package_args()1858   template <typename T = RegisterSqlPackageArgs> T* set_register_sql_package_args() {
1859     return BeginNestedMessage<T>(108);
1860   }
1861 
1862 
1863   using FieldMetadata_AppendResult =
1864     ::protozero::proto_utils::FieldMetadata<
1865       201,
1866       ::protozero::proto_utils::RepetitionType::kNotRepeated,
1867       ::protozero::proto_utils::ProtoSchemaType::kMessage,
1868       AppendTraceDataResult,
1869       TraceProcessorRpc>;
1870 
1871   static constexpr FieldMetadata_AppendResult kAppendResult{};
set_append_result()1872   template <typename T = AppendTraceDataResult> T* set_append_result() {
1873     return BeginNestedMessage<T>(201);
1874   }
1875 
1876 
1877   using FieldMetadata_QueryResult =
1878     ::protozero::proto_utils::FieldMetadata<
1879       203,
1880       ::protozero::proto_utils::RepetitionType::kNotRepeated,
1881       ::protozero::proto_utils::ProtoSchemaType::kMessage,
1882       QueryResult,
1883       TraceProcessorRpc>;
1884 
1885   static constexpr FieldMetadata_QueryResult kQueryResult{};
set_query_result()1886   template <typename T = QueryResult> T* set_query_result() {
1887     return BeginNestedMessage<T>(203);
1888   }
1889 
1890 
1891   using FieldMetadata_MetricResult =
1892     ::protozero::proto_utils::FieldMetadata<
1893       205,
1894       ::protozero::proto_utils::RepetitionType::kNotRepeated,
1895       ::protozero::proto_utils::ProtoSchemaType::kMessage,
1896       ComputeMetricResult,
1897       TraceProcessorRpc>;
1898 
1899   static constexpr FieldMetadata_MetricResult kMetricResult{};
set_metric_result()1900   template <typename T = ComputeMetricResult> T* set_metric_result() {
1901     return BeginNestedMessage<T>(205);
1902   }
1903 
1904 
1905   using FieldMetadata_MetricDescriptors =
1906     ::protozero::proto_utils::FieldMetadata<
1907       206,
1908       ::protozero::proto_utils::RepetitionType::kNotRepeated,
1909       ::protozero::proto_utils::ProtoSchemaType::kMessage,
1910       DescriptorSet,
1911       TraceProcessorRpc>;
1912 
1913   static constexpr FieldMetadata_MetricDescriptors kMetricDescriptors{};
set_metric_descriptors()1914   template <typename T = DescriptorSet> T* set_metric_descriptors() {
1915     return BeginNestedMessage<T>(206);
1916   }
1917 
1918 
1919   using FieldMetadata_Metatrace =
1920     ::protozero::proto_utils::FieldMetadata<
1921       209,
1922       ::protozero::proto_utils::RepetitionType::kNotRepeated,
1923       ::protozero::proto_utils::ProtoSchemaType::kMessage,
1924       DisableAndReadMetatraceResult,
1925       TraceProcessorRpc>;
1926 
1927   static constexpr FieldMetadata_Metatrace kMetatrace{};
set_metatrace()1928   template <typename T = DisableAndReadMetatraceResult> T* set_metatrace() {
1929     return BeginNestedMessage<T>(209);
1930   }
1931 
1932 
1933   using FieldMetadata_Status =
1934     ::protozero::proto_utils::FieldMetadata<
1935       210,
1936       ::protozero::proto_utils::RepetitionType::kNotRepeated,
1937       ::protozero::proto_utils::ProtoSchemaType::kMessage,
1938       StatusResult,
1939       TraceProcessorRpc>;
1940 
1941   static constexpr FieldMetadata_Status kStatus{};
set_status()1942   template <typename T = StatusResult> T* set_status() {
1943     return BeginNestedMessage<T>(210);
1944   }
1945 
1946 
1947   using FieldMetadata_RegisterSqlPackageResult =
1948     ::protozero::proto_utils::FieldMetadata<
1949       211,
1950       ::protozero::proto_utils::RepetitionType::kNotRepeated,
1951       ::protozero::proto_utils::ProtoSchemaType::kMessage,
1952       RegisterSqlPackageResult,
1953       TraceProcessorRpc>;
1954 
1955   static constexpr FieldMetadata_RegisterSqlPackageResult kRegisterSqlPackageResult{};
set_register_sql_package_result()1956   template <typename T = RegisterSqlPackageResult> T* set_register_sql_package_result() {
1957     return BeginNestedMessage<T>(211);
1958   }
1959 
1960 
1961   using FieldMetadata_FinalizeDataResult =
1962     ::protozero::proto_utils::FieldMetadata<
1963       212,
1964       ::protozero::proto_utils::RepetitionType::kNotRepeated,
1965       ::protozero::proto_utils::ProtoSchemaType::kMessage,
1966       FinalizeDataResult,
1967       TraceProcessorRpc>;
1968 
1969   static constexpr FieldMetadata_FinalizeDataResult kFinalizeDataResult{};
set_finalize_data_result()1970   template <typename T = FinalizeDataResult> T* set_finalize_data_result() {
1971     return BeginNestedMessage<T>(212);
1972   }
1973 
1974 };
1975 
1976 class TraceProcessorRpcStream_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/1, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
1977  public:
TraceProcessorRpcStream_Decoder(const uint8_t * data,size_t len)1978   TraceProcessorRpcStream_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
TraceProcessorRpcStream_Decoder(const std::string & raw)1979   explicit TraceProcessorRpcStream_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
TraceProcessorRpcStream_Decoder(const::protozero::ConstBytes & raw)1980   explicit TraceProcessorRpcStream_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
has_msg()1981   bool has_msg() const { return at<1>().valid(); }
msg()1982   ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> msg() const { return GetRepeated<::protozero::ConstBytes>(1); }
1983 };
1984 
1985 class TraceProcessorRpcStream : public ::protozero::Message {
1986  public:
1987   using Decoder = TraceProcessorRpcStream_Decoder;
1988   enum : int32_t {
1989     kMsgFieldNumber = 1,
1990   };
GetName()1991   static constexpr const char* GetName() { return ".perfetto.protos.TraceProcessorRpcStream"; }
1992 
1993 
1994   using FieldMetadata_Msg =
1995     ::protozero::proto_utils::FieldMetadata<
1996       1,
1997       ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
1998       ::protozero::proto_utils::ProtoSchemaType::kMessage,
1999       TraceProcessorRpc,
2000       TraceProcessorRpcStream>;
2001 
2002   static constexpr FieldMetadata_Msg kMsg{};
add_msg()2003   template <typename T = TraceProcessorRpc> T* add_msg() {
2004     return BeginNestedMessage<T>(1);
2005   }
2006 
2007 };
2008 
2009 } // Namespace.
2010 } // Namespace.
2011 } // Namespace.
2012 #endif  // Include guard.
2013