From 8259d18368c686a64ce55fd9d31d980f877bbb69 Mon Sep 17 00:00:00 2001 From: Jade Lovelace Date: Wed, 8 May 2024 14:56:13 -0700 Subject: [PATCH 1/4] wip tracing --- src/libtracing/main.cc | 43 + .../perfetto/trace/perfetto_trace.pbzero.cc | 1 + .../perfetto/trace/perfetto_trace.pbzero.h | 123429 +++++++++++++++ src/libtracing/meson.build | 47 + src/libtracing/trace-writer.cc | 190 + src/libtracing/trace-writer.hh | 67 + src/meson.build | 2 + 7 files changed, 123779 insertions(+) create mode 100644 src/libtracing/main.cc create mode 100644 src/libtracing/meow/protos/perfetto/trace/perfetto_trace.pbzero.cc create mode 100644 src/libtracing/meow/protos/perfetto/trace/perfetto_trace.pbzero.h create mode 100644 src/libtracing/meson.build create mode 100644 src/libtracing/trace-writer.cc create mode 100644 src/libtracing/trace-writer.hh diff --git a/src/libtracing/main.cc b/src/libtracing/main.cc new file mode 100644 index 000000000..d2e59fd64 --- /dev/null +++ b/src/libtracing/main.cc @@ -0,0 +1,43 @@ +#include "trace-writer.hh" +#include +#include + +using namespace nix::tracing; +class MyInternedRetriever : public InternedRetriever +{ + virtual auto getName(InternedName idx) const -> std::string override + { + return "meow"; + } + + virtual auto getPos(InternedPos idx, std::string funcName) const -> TracePos override + { + return TracePos{ + .fileName = "file.nix", + .functionName = "fun", + .lineNumber = 12, + }; + } + +public: + + virtual ~MyInternedRetriever() = default; +}; + +int main(int argc, char **argv) +{ + if (argc < 1) { + std::cerr << "provide filename pls\n"; + return 1; + } + nix::tracing::TraceWriter tw{std::make_unique()}; + + tw.begin(InternedPos{1}, InternedName{3}, Timestamp{250}); + tw.end(Timestamp{1235}); + + std::ofstream ofs(argv[1]); + auto buf = tw.splat(); + ofs.write(reinterpret_cast(buf.data()), buf.size()); + + return 0; +} diff --git a/src/libtracing/meow/protos/perfetto/trace/perfetto_trace.pbzero.cc b/src/libtracing/meow/protos/perfetto/trace/perfetto_trace.pbzero.cc new file mode 100644 index 000000000..4b4f59d78 --- /dev/null +++ b/src/libtracing/meow/protos/perfetto/trace/perfetto_trace.pbzero.cc @@ -0,0 +1 @@ +// Intentionally empty (crbug.com/998165) diff --git a/src/libtracing/meow/protos/perfetto/trace/perfetto_trace.pbzero.h b/src/libtracing/meow/protos/perfetto/trace/perfetto_trace.pbzero.h new file mode 100644 index 000000000..5df124819 --- /dev/null +++ b/src/libtracing/meow/protos/perfetto/trace/perfetto_trace.pbzero.h @@ -0,0 +1,123429 @@ +// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT. + +#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_PERFETTO_TRACE_PROTO_H_ +#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_PERFETTO_TRACE_PROTO_H_ + +#include +#include + +#include "perfetto/protozero/field_writer.h" +#include "perfetto/protozero/message.h" +#include "perfetto/protozero/packed_repeated_fields.h" +#include "perfetto/protozero/proto_decoder.h" +#include "perfetto/protozero/proto_utils.h" + +namespace perfetto { +namespace protos { +namespace pbzero { +class ActiveBufferProto; +class AddressSymbols; +class AllocPagesIommuEndFtraceEvent; +class AllocPagesIommuFailFtraceEvent; +class AllocPagesIommuStartFtraceEvent; +class AllocPagesSysEndFtraceEvent; +class AllocPagesSysFailFtraceEvent; +class AllocPagesSysStartFtraceEvent; +class AndroidCameraFrameEvent; +class AndroidCameraFrameEvent_CameraNodeProcessingDetails; +class AndroidCameraSessionStats; +class AndroidCameraSessionStats_CameraGraph; +class AndroidCameraSessionStats_CameraGraph_CameraEdge; +class AndroidCameraSessionStats_CameraGraph_CameraNode; +class AndroidEnergyConsumer; +class AndroidEnergyConsumerDescriptor; +class AndroidEnergyEstimationBreakdown; +class AndroidEnergyEstimationBreakdown_EnergyUidBreakdown; +class AndroidFsDatareadEndFtraceEvent; +class AndroidFsDatareadStartFtraceEvent; +class AndroidFsDatawriteEndFtraceEvent; +class AndroidFsDatawriteStartFtraceEvent; +class AndroidFsFsyncEndFtraceEvent; +class AndroidFsFsyncStartFtraceEvent; +class AndroidGameInterventionList; +class AndroidGameInterventionList_GameModeInfo; +class AndroidGameInterventionList_GamePackageInfo; +class AndroidGameInterventionListConfig; +class AndroidInputEvent; +class AndroidInputEventConfig; +class AndroidInputEventConfig_TraceRule; +class AndroidKeyEvent; +class AndroidLogConfig; +class AndroidLogPacket; +class AndroidLogPacket_LogEvent; +class AndroidLogPacket_LogEvent_Arg; +class AndroidLogPacket_Stats; +class AndroidMotionEvent; +class AndroidMotionEvent_Pointer; +class AndroidMotionEvent_Pointer_AxisValue; +class AndroidPolledStateConfig; +class AndroidPowerConfig; +class AndroidSdkSyspropGuardConfig; +class AndroidSystemProperty; +class AndroidSystemProperty_PropertyValue; +class AndroidSystemPropertyConfig; +class AndroidWindowInputDispatchEvent; +class AndroidWindowInputDispatchEvent_DispatchedPointer; +class Atom; +class BackgroundTracingMetadata; +class BackgroundTracingMetadata_TriggerRule; +class BackgroundTracingMetadata_TriggerRule_HistogramRule; +class BackgroundTracingMetadata_TriggerRule_NamedRule; +class BarrierLayerProto; +class BatteryCounters; +class BeginFrameArgs; +class BeginFrameObserverState; +class BeginFrameSourceState; +class BeginImplFrameArgs; +class BeginImplFrameArgs_TimestampsInUs; +class BinderCommandFtraceEvent; +class BinderLockFtraceEvent; +class BinderLockedFtraceEvent; +class BinderReturnFtraceEvent; +class BinderSetPriorityFtraceEvent; +class BinderTransactionAllocBufFtraceEvent; +class BinderTransactionFtraceEvent; +class BinderTransactionReceivedFtraceEvent; +class BinderUnlockFtraceEvent; +class BlockBioBackmergeFtraceEvent; +class BlockBioBounceFtraceEvent; +class BlockBioCompleteFtraceEvent; +class BlockBioFrontmergeFtraceEvent; +class BlockBioQueueFtraceEvent; +class BlockBioRemapFtraceEvent; +class BlockDirtyBufferFtraceEvent; +class BlockGetrqFtraceEvent; +class BlockPlugFtraceEvent; +class BlockRqAbortFtraceEvent; +class BlockRqCompleteFtraceEvent; +class BlockRqInsertFtraceEvent; +class BlockRqIssueFtraceEvent; +class BlockRqRemapFtraceEvent; +class BlockRqRequeueFtraceEvent; +class BlockSleeprqFtraceEvent; +class BlockSplitFtraceEvent; +class BlockTouchBufferFtraceEvent; +class BlockUnplugFtraceEvent; +class BlurRegion; +class CSwitchEtwEvent; +class Callstack; +class CdevUpdateFtraceEvent; +class CgroupAttachTaskFtraceEvent; +class CgroupDestroyRootFtraceEvent; +class CgroupMkdirFtraceEvent; +class CgroupReleaseFtraceEvent; +class CgroupRemountFtraceEvent; +class CgroupRenameFtraceEvent; +class CgroupRmdirFtraceEvent; +class CgroupSetupRootFtraceEvent; +class CgroupTransferTasksFtraceEvent; +class ChromeActiveProcesses; +class ChromeApplicationStateInfo; +class ChromeBenchmarkMetadata; +class ChromeCompositorSchedulerState; +class ChromeCompositorStateMachine; +class ChromeCompositorStateMachine_MajorState; +class ChromeCompositorStateMachine_MinorState; +class ChromeConfig; +class ChromeContentSettingsEventInfo; +class ChromeEventBundle; +class ChromeFrameReporter; +class ChromeHistogramSample; +class ChromeHistorgramTranslationTable; +class ChromeHistorgramTranslationTable_HashToNameEntry; +class ChromeKeyedService; +class ChromeLatencyInfo; +class ChromeLatencyInfo_ComponentInfo; +class ChromeLegacyIpc; +class ChromeLegacyJsonTrace; +class ChromeMessagePump; +class ChromeMetadata; +class ChromeMetadataPacket; +class ChromeMetadataPacket_FinchHash; +class ChromeMojoEventInfo; +class ChromePerformanceMarkTranslationTable; +class ChromePerformanceMarkTranslationTable_MarkHashToNameEntry; +class ChromePerformanceMarkTranslationTable_SiteHashToNameEntry; +class ChromeProcessDescriptor; +class ChromeRendererSchedulerState; +class ChromeStringTableEntry; +class ChromeThreadDescriptor; +class ChromeTraceEvent; +class ChromeTraceEvent_Arg; +class ChromeTracedValue; +class ChromeTrigger; +class ChromeUserEvent; +class ChromeUserEventTranslationTable; +class ChromeUserEventTranslationTable_ActionHashToNameEntry; +class ChromeWindowHandleEventInfo; +class ClkDisableFtraceEvent; +class ClkEnableFtraceEvent; +class ClkSetRateFtraceEvent; +class ClockDisableFtraceEvent; +class ClockEnableFtraceEvent; +class ClockSetRateFtraceEvent; +class ClockSnapshot; +class ClockSnapshot_Clock; +class CmaAllocInfoFtraceEvent; +class CmaAllocStartFtraceEvent; +class ColorProto; +class ColorTransformProto; +class CompositorTimingHistory; +class ConsoleConfig; +class ConsoleFtraceEvent; +class CounterDescriptor; +class CpuFrequencyFtraceEvent; +class CpuFrequencyLimitsFtraceEvent; +class CpuIdleFtraceEvent; +class CpuInfo; +class CpuInfo_Cpu; +class CpuhpEnterFtraceEvent; +class CpuhpExitFtraceEvent; +class CpuhpLatencyFtraceEvent; +class CpuhpMultiEnterFtraceEvent; +class CpuhpPauseFtraceEvent; +class CrosEcSensorhubDataFtraceEvent; +class DataSourceConfig; +class DataSourceDescriptor; +class DebugAnnotation; +class DebugAnnotation_NestedValue; +class DebugAnnotationName; +class DebugAnnotationValueTypeName; +class DeobfuscationMapping; +class DescriptorProto; +class DescriptorProto_ReservedRange; +class DisplayInfo; +class DisplayProto; +class DisplayState; +class DmaAllocContiguousRetryFtraceEvent; +class DmaFenceEmitFtraceEvent; +class DmaFenceInitFtraceEvent; +class DmaFenceSignaledFtraceEvent; +class DmaFenceWaitEndFtraceEvent; +class DmaFenceWaitStartFtraceEvent; +class DmaHeapStatFtraceEvent; +class DpuDsiCmdFifoStatusFtraceEvent; +class DpuDsiRxFtraceEvent; +class DpuDsiTxFtraceEvent; +class DpuTracingMarkWriteFtraceEvent; +class DrmRunJobFtraceEvent; +class DrmSchedJobFtraceEvent; +class DrmSchedProcessJobFtraceEvent; +class DrmVblankEventDeliveredFtraceEvent; +class DrmVblankEventFtraceEvent; +class DsiCmdFifoStatusFtraceEvent; +class DsiRxFtraceEvent; +class DsiTxFtraceEvent; +class EntityStateResidency; +class EntityStateResidency_PowerEntityState; +class EntityStateResidency_StateResidency; +class EnumDescriptorProto; +class EnumValueDescriptorProto; +class EtwConfig; +class EtwTraceEvent; +class EtwTraceEventBundle; +class EventCategory; +class EventName; +class Ext4AllocDaBlocksFtraceEvent; +class Ext4AllocateBlocksFtraceEvent; +class Ext4AllocateInodeFtraceEvent; +class Ext4BeginOrderedTruncateFtraceEvent; +class Ext4CollapseRangeFtraceEvent; +class Ext4DaReleaseSpaceFtraceEvent; +class Ext4DaReserveSpaceFtraceEvent; +class Ext4DaUpdateReserveSpaceFtraceEvent; +class Ext4DaWriteBeginFtraceEvent; +class Ext4DaWriteEndFtraceEvent; +class Ext4DaWritePagesExtentFtraceEvent; +class Ext4DaWritePagesFtraceEvent; +class Ext4DirectIOEnterFtraceEvent; +class Ext4DirectIOExitFtraceEvent; +class Ext4DiscardBlocksFtraceEvent; +class Ext4DiscardPreallocationsFtraceEvent; +class Ext4DropInodeFtraceEvent; +class Ext4EsCacheExtentFtraceEvent; +class Ext4EsFindDelayedExtentRangeEnterFtraceEvent; +class Ext4EsFindDelayedExtentRangeExitFtraceEvent; +class Ext4EsInsertExtentFtraceEvent; +class Ext4EsLookupExtentEnterFtraceEvent; +class Ext4EsLookupExtentExitFtraceEvent; +class Ext4EsRemoveExtentFtraceEvent; +class Ext4EsShrinkCountFtraceEvent; +class Ext4EsShrinkFtraceEvent; +class Ext4EsShrinkScanEnterFtraceEvent; +class Ext4EsShrinkScanExitFtraceEvent; +class Ext4EvictInodeFtraceEvent; +class Ext4ExtConvertToInitializedEnterFtraceEvent; +class Ext4ExtConvertToInitializedFastpathFtraceEvent; +class Ext4ExtHandleUnwrittenExtentsFtraceEvent; +class Ext4ExtInCacheFtraceEvent; +class Ext4ExtLoadExtentFtraceEvent; +class Ext4ExtMapBlocksEnterFtraceEvent; +class Ext4ExtMapBlocksExitFtraceEvent; +class Ext4ExtPutInCacheFtraceEvent; +class Ext4ExtRemoveSpaceDoneFtraceEvent; +class Ext4ExtRemoveSpaceFtraceEvent; +class Ext4ExtRmIdxFtraceEvent; +class Ext4ExtRmLeafFtraceEvent; +class Ext4ExtShowExtentFtraceEvent; +class Ext4FallocateEnterFtraceEvent; +class Ext4FallocateExitFtraceEvent; +class Ext4FindDelallocRangeFtraceEvent; +class Ext4ForgetFtraceEvent; +class Ext4FreeBlocksFtraceEvent; +class Ext4FreeInodeFtraceEvent; +class Ext4GetImpliedClusterAllocExitFtraceEvent; +class Ext4GetReservedClusterAllocFtraceEvent; +class Ext4IndMapBlocksEnterFtraceEvent; +class Ext4IndMapBlocksExitFtraceEvent; +class Ext4InsertRangeFtraceEvent; +class Ext4InvalidatepageFtraceEvent; +class Ext4JournalStartFtraceEvent; +class Ext4JournalStartReservedFtraceEvent; +class Ext4JournalledInvalidatepageFtraceEvent; +class Ext4JournalledWriteEndFtraceEvent; +class Ext4LoadInodeBitmapFtraceEvent; +class Ext4LoadInodeFtraceEvent; +class Ext4MarkInodeDirtyFtraceEvent; +class Ext4MbBitmapLoadFtraceEvent; +class Ext4MbBuddyBitmapLoadFtraceEvent; +class Ext4MbDiscardPreallocationsFtraceEvent; +class Ext4MbNewGroupPaFtraceEvent; +class Ext4MbNewInodePaFtraceEvent; +class Ext4MbReleaseGroupPaFtraceEvent; +class Ext4MbReleaseInodePaFtraceEvent; +class Ext4MballocAllocFtraceEvent; +class Ext4MballocDiscardFtraceEvent; +class Ext4MballocFreeFtraceEvent; +class Ext4MballocPreallocFtraceEvent; +class Ext4OtherInodeUpdateTimeFtraceEvent; +class Ext4PunchHoleFtraceEvent; +class Ext4ReadBlockBitmapLoadFtraceEvent; +class Ext4ReadpageFtraceEvent; +class Ext4ReleasepageFtraceEvent; +class Ext4RemoveBlocksFtraceEvent; +class Ext4RequestBlocksFtraceEvent; +class Ext4RequestInodeFtraceEvent; +class Ext4SyncFileEnterFtraceEvent; +class Ext4SyncFileExitFtraceEvent; +class Ext4SyncFsFtraceEvent; +class Ext4TrimAllFreeFtraceEvent; +class Ext4TrimExtentFtraceEvent; +class Ext4TruncateEnterFtraceEvent; +class Ext4TruncateExitFtraceEvent; +class Ext4UnlinkEnterFtraceEvent; +class Ext4UnlinkExitFtraceEvent; +class Ext4WriteBeginFtraceEvent; +class Ext4WriteEndFtraceEvent; +class Ext4WritepageFtraceEvent; +class Ext4WritepagesFtraceEvent; +class Ext4WritepagesResultFtraceEvent; +class Ext4ZeroRangeFtraceEvent; +class ExtensionDescriptor; +class F2fsBackgroundGcFtraceEvent; +class F2fsDoSubmitBioFtraceEvent; +class F2fsEvictInodeFtraceEvent; +class F2fsFallocateFtraceEvent; +class F2fsGcBeginFtraceEvent; +class F2fsGcEndFtraceEvent; +class F2fsGetDataBlockFtraceEvent; +class F2fsGetVictimFtraceEvent; +class F2fsIgetExitFtraceEvent; +class F2fsIgetFtraceEvent; +class F2fsIostatFtraceEvent; +class F2fsIostatLatencyFtraceEvent; +class F2fsNewInodeFtraceEvent; +class F2fsReadpageFtraceEvent; +class F2fsReserveNewBlockFtraceEvent; +class F2fsSetPageDirtyFtraceEvent; +class F2fsSubmitWritePageFtraceEvent; +class F2fsSyncFileEnterFtraceEvent; +class F2fsSyncFileExitFtraceEvent; +class F2fsSyncFsFtraceEvent; +class F2fsTruncateBlocksEnterFtraceEvent; +class F2fsTruncateBlocksExitFtraceEvent; +class F2fsTruncateDataBlocksRangeFtraceEvent; +class F2fsTruncateFtraceEvent; +class F2fsTruncateInodeBlocksEnterFtraceEvent; +class F2fsTruncateInodeBlocksExitFtraceEvent; +class F2fsTruncateNodeFtraceEvent; +class F2fsTruncateNodesEnterFtraceEvent; +class F2fsTruncateNodesExitFtraceEvent; +class F2fsTruncatePartialNodesFtraceEvent; +class F2fsUnlinkEnterFtraceEvent; +class F2fsUnlinkExitFtraceEvent; +class F2fsVmPageMkwriteFtraceEvent; +class F2fsWriteBeginFtraceEvent; +class F2fsWriteCheckpointFtraceEvent; +class F2fsWriteEndFtraceEvent; +class FastrpcDmaAllocFtraceEvent; +class FastrpcDmaFreeFtraceEvent; +class FastrpcDmaMapFtraceEvent; +class FastrpcDmaStatFtraceEvent; +class FastrpcDmaUnmapFtraceEvent; +class FenceDestroyFtraceEvent; +class FenceEnableSignalFtraceEvent; +class FenceInitFtraceEvent; +class FenceSignaledFtraceEvent; +class FieldDescriptorProto; +class FieldOptions; +class FileDescriptorProto; +class FileDescriptorSet; +class FloatRectProto; +class Frame; +class FrameTimelineEvent; +class FrameTimelineEvent_ActualDisplayFrameStart; +class FrameTimelineEvent_ActualSurfaceFrameStart; +class FrameTimelineEvent_ExpectedDisplayFrameStart; +class FrameTimelineEvent_ExpectedSurfaceFrameStart; +class FrameTimelineEvent_FrameEnd; +class FtraceConfig; +class FtraceConfig_CompactSchedConfig; +class FtraceConfig_PrintFilter; +class FtraceConfig_PrintFilter_Rule; +class FtraceConfig_PrintFilter_Rule_AtraceMessage; +class FtraceCpuStats; +class FtraceDescriptor; +class FtraceDescriptor_AtraceCategory; +class FtraceEvent; +class FtraceEventBundle; +class FtraceEventBundle_CompactSched; +class FtraceEventBundle_FtraceError; +class FtraceStats; +class FuncgraphEntryFtraceEvent; +class FuncgraphExitFtraceEvent; +class G2dTracingMarkWriteFtraceEvent; +class GenericFtraceEvent; +class GenericFtraceEvent_Field; +class GpuCounterConfig; +class GpuCounterEvent; +class GpuCounterEvent_GpuCounter; +class GpuFrequencyFtraceEvent; +class GpuLog; +class GpuMemTotalEvent; +class GpuMemTotalFtraceEvent; +class GpuRenderStageEvent; +class GpuRenderStageEvent_ExtraData; +class GpuRenderStageEvent_Specifications; +class GpuRenderStageEvent_Specifications_ContextSpec; +class GpuRenderStageEvent_Specifications_Description; +class GpuWorkPeriodFtraceEvent; +class GraphicsFrameEvent; +class GraphicsFrameEvent_BufferEvent; +class HeapGraph; +class HeapGraphObject; +class HeapGraphRoot; +class HeapGraphType; +class HeapprofdConfig; +class HeapprofdConfig_ContinuousDumpConfig; +class HistogramName; +class HostHcallFtraceEvent; +class HostMemAbortFtraceEvent; +class HostSmcFtraceEvent; +class HypEnterFtraceEvent; +class HypExitFtraceEvent; +class I2cReadFtraceEvent; +class I2cReplyFtraceEvent; +class I2cResultFtraceEvent; +class I2cWriteFtraceEvent; +class InetSockSetStateFtraceEvent; +class InitialDisplayState; +class InodeFileConfig; +class InodeFileConfig_MountPointMappingEntry; +class InodeFileMap; +class InodeFileMap_Entry; +class InputWindowInfoProto; +class InterceptorConfig; +class InternedData; +class InternedGpuRenderStageSpecification; +class InternedGraphicsContext; +class InternedString; +class InternedV8Isolate; +class InternedV8Isolate_CodeRange; +class InternedV8JsFunction; +class InternedV8JsScript; +class InternedV8String; +class InternedV8WasmScript; +class IommuMapRangeFtraceEvent; +class IommuSecPtblMapRangeEndFtraceEvent; +class IommuSecPtblMapRangeStartFtraceEvent; +class IonAllocBufferEndFtraceEvent; +class IonAllocBufferFailFtraceEvent; +class IonAllocBufferFallbackFtraceEvent; +class IonAllocBufferStartFtraceEvent; +class IonBufferCreateFtraceEvent; +class IonBufferDestroyFtraceEvent; +class IonCpAllocRetryFtraceEvent; +class IonCpSecureBufferEndFtraceEvent; +class IonCpSecureBufferStartFtraceEvent; +class IonHeapGrowFtraceEvent; +class IonHeapShrinkFtraceEvent; +class IonPrefetchingFtraceEvent; +class IonSecureCmaAddToPoolEndFtraceEvent; +class IonSecureCmaAddToPoolStartFtraceEvent; +class IonSecureCmaAllocateEndFtraceEvent; +class IonSecureCmaAllocateStartFtraceEvent; +class IonSecureCmaShrinkPoolEndFtraceEvent; +class IonSecureCmaShrinkPoolStartFtraceEvent; +class IonStatFtraceEvent; +class IpiEntryFtraceEvent; +class IpiExitFtraceEvent; +class IpiRaiseFtraceEvent; +class IrqHandlerEntryFtraceEvent; +class IrqHandlerExitFtraceEvent; +class JavaHprofConfig; +class JavaHprofConfig_ContinuousDumpConfig; +class KfreeFtraceEvent; +class KfreeSkbFtraceEvent; +class KmallocFtraceEvent; +class KmallocNodeFtraceEvent; +class KmemCacheAllocFtraceEvent; +class KmemCacheAllocNodeFtraceEvent; +class KmemCacheFreeFtraceEvent; +class KvmAccessFaultFtraceEvent; +class KvmAckIrqFtraceEvent; +class KvmAgeHvaFtraceEvent; +class KvmAgePageFtraceEvent; +class KvmArmClearDebugFtraceEvent; +class KvmArmSetDreg32FtraceEvent; +class KvmArmSetRegsetFtraceEvent; +class KvmArmSetupDebugFtraceEvent; +class KvmEntryFtraceEvent; +class KvmExitFtraceEvent; +class KvmFpuFtraceEvent; +class KvmGetTimerMapFtraceEvent; +class KvmGuestFaultFtraceEvent; +class KvmHandleSysRegFtraceEvent; +class KvmHvcArm64FtraceEvent; +class KvmIrqLineFtraceEvent; +class KvmMmioEmulateFtraceEvent; +class KvmMmioFtraceEvent; +class KvmSetGuestDebugFtraceEvent; +class KvmSetIrqFtraceEvent; +class KvmSetSpteHvaFtraceEvent; +class KvmSetWayFlushFtraceEvent; +class KvmSysAccessFtraceEvent; +class KvmTestAgeHvaFtraceEvent; +class KvmTimerEmulateFtraceEvent; +class KvmTimerHrtimerExpireFtraceEvent; +class KvmTimerRestoreStateFtraceEvent; +class KvmTimerSaveStateFtraceEvent; +class KvmTimerUpdateIrqFtraceEvent; +class KvmToggleCacheFtraceEvent; +class KvmUnmapHvaRangeFtraceEvent; +class KvmUserspaceExitFtraceEvent; +class KvmVcpuWakeupFtraceEvent; +class KvmWfxArm64FtraceEvent; +class LayerCreationArgs; +class LayerProto; +class LayerProto_MetadataEntry; +class LayerState; +class LayerState_BufferData; +class LayerState_Color3; +class LayerState_Matrix22; +class LayerState_WindowInfo; +class LayersProto; +class LayersSnapshotProto; +class Line; +class LogMessage; +class LogMessageBody; +class LowmemoryKillFtraceEvent; +class LwisTracingMarkWriteFtraceEvent; +class MaliMaliCSFINTERRUPTENDFtraceEvent; +class MaliMaliCSFINTERRUPTSTARTFtraceEvent; +class MaliMaliKCPUCQSSETFtraceEvent; +class MaliMaliKCPUCQSWAITENDFtraceEvent; +class MaliMaliKCPUCQSWAITSTARTFtraceEvent; +class MaliMaliKCPUFENCESIGNALFtraceEvent; +class MaliMaliKCPUFENCEWAITENDFtraceEvent; +class MaliMaliKCPUFENCEWAITSTARTFtraceEvent; +class MaliTracingMarkWriteFtraceEvent; +class Mapping; +class MarkVictimFtraceEvent; +class MdpCmdKickoffFtraceEvent; +class MdpCmdPingpongDoneFtraceEvent; +class MdpCmdReadptrDoneFtraceEvent; +class MdpCmdReleaseBwFtraceEvent; +class MdpCmdWaitPingpongFtraceEvent; +class MdpCommitFtraceEvent; +class MdpCompareBwFtraceEvent; +class MdpMisrCrcFtraceEvent; +class MdpMixerUpdateFtraceEvent; +class MdpPerfPrefillCalcFtraceEvent; +class MdpPerfSetOtFtraceEvent; +class MdpPerfSetPanicLutsFtraceEvent; +class MdpPerfSetQosLutsFtraceEvent; +class MdpPerfSetWmLevelsFtraceEvent; +class MdpPerfUpdateBusFtraceEvent; +class MdpSsppChangeFtraceEvent; +class MdpSsppSetFtraceEvent; +class MdpTraceCounterFtraceEvent; +class MdpVideoUnderrunDoneFtraceEvent; +class MemoryTrackerSnapshot; +class MemoryTrackerSnapshot_ProcessSnapshot; +class MemoryTrackerSnapshot_ProcessSnapshot_MemoryEdge; +class MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode; +class MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry; +class MigratePagesEndFtraceEvent; +class MigratePagesStartFtraceEvent; +class MigrateRetryFtraceEvent; +class MmCompactionBeginFtraceEvent; +class MmCompactionDeferCompactionFtraceEvent; +class MmCompactionDeferResetFtraceEvent; +class MmCompactionDeferredFtraceEvent; +class MmCompactionEndFtraceEvent; +class MmCompactionFinishedFtraceEvent; +class MmCompactionIsolateFreepagesFtraceEvent; +class MmCompactionIsolateMigratepagesFtraceEvent; +class MmCompactionKcompactdSleepFtraceEvent; +class MmCompactionKcompactdWakeFtraceEvent; +class MmCompactionMigratepagesFtraceEvent; +class MmCompactionSuitableFtraceEvent; +class MmCompactionTryToCompactPagesFtraceEvent; +class MmCompactionWakeupKcompactdFtraceEvent; +class MmEventRecordFtraceEvent; +class MmFilemapAddToPageCacheFtraceEvent; +class MmFilemapDeleteFromPageCacheFtraceEvent; +class MmPageAllocExtfragFtraceEvent; +class MmPageAllocFtraceEvent; +class MmPageAllocZoneLockedFtraceEvent; +class MmPageFreeBatchedFtraceEvent; +class MmPageFreeFtraceEvent; +class MmPagePcpuDrainFtraceEvent; +class MmShrinkSlabEndFtraceEvent; +class MmShrinkSlabStartFtraceEvent; +class MmVmscanDirectReclaimBeginFtraceEvent; +class MmVmscanDirectReclaimEndFtraceEvent; +class MmVmscanKswapdSleepFtraceEvent; +class MmVmscanKswapdWakeFtraceEvent; +class ModuleSymbols; +class NapiGroReceiveEntryFtraceEvent; +class NapiGroReceiveExitFtraceEvent; +class NetDevXmitFtraceEvent; +class NetifReceiveSkbFtraceEvent; +class NetworkPacketBundle; +class NetworkPacketContext; +class NetworkPacketEvent; +class NetworkPacketTraceConfig; +class ObfuscatedClass; +class ObfuscatedMember; +class OneofDescriptorProto; +class OneofOptions; +class OomScoreAdjUpdateFtraceEvent; +class PackagesList; +class PackagesList_PackageInfo; +class PackagesListConfig; +class PanelWriteGenericFtraceEvent; +class PerfEventConfig; +class PerfEventConfig_CallstackSampling; +class PerfEventConfig_Scope; +class PerfEvents_RawEvent; +class PerfEvents_Timebase; +class PerfEvents_Tracepoint; +class PerfSample; +class PerfSample_ProducerEvent; +class PerfSampleDefaults; +class PerfettoMetatrace; +class PerfettoMetatrace_Arg; +class PerfettoMetatrace_InternedString; +class PixelModemEventInsight; +class PositionProto; +class PowerRails; +class PowerRails_EnergyData; +class PowerRails_RailDescriptor; +class PrintFtraceEvent; +class ProcessDescriptor; +class ProcessStats; +class ProcessStats_FDInfo; +class ProcessStats_Process; +class ProcessStats_Thread; +class ProcessStatsConfig; +class ProcessTree; +class ProcessTree_Process; +class ProcessTree_Thread; +class ProfilePacket; +class ProfilePacket_HeapSample; +class ProfilePacket_Histogram; +class ProfilePacket_Histogram_Bucket; +class ProfilePacket_ProcessHeapSamples; +class ProfilePacket_ProcessStats; +class ProfiledFrameSymbols; +class ProtoLogConfig; +class ProtoLogGroup; +class ProtoLogMessage; +class ProtoLogViewerConfig; +class ProtoLogViewerConfig_Group; +class ProtoLogViewerConfig_MessageData; +class ReadyThreadEtwEvent; +class RectProto; +class RegionProto; +class RegulatorDisableCompleteFtraceEvent; +class RegulatorDisableFtraceEvent; +class RegulatorEnableCompleteFtraceEvent; +class RegulatorEnableDelayFtraceEvent; +class RegulatorEnableFtraceEvent; +class RegulatorSetVoltageCompleteFtraceEvent; +class RegulatorSetVoltageFtraceEvent; +class RemoteClockSync; +class RemoteClockSync_SyncedClocks; +class RotatorBwAoAsContextFtraceEvent; +class RpmStatusFtraceEvent; +class RssStatFtraceEvent; +class RssStatThrottledFtraceEvent; +class SamsungTracingMarkWriteFtraceEvent; +class SchedBlockedReasonFtraceEvent; +class SchedCpuHotplugFtraceEvent; +class SchedCpuUtilCfsFtraceEvent; +class SchedMigrateTaskFtraceEvent; +class SchedPiSetprioFtraceEvent; +class SchedProcessExecFtraceEvent; +class SchedProcessExitFtraceEvent; +class SchedProcessForkFtraceEvent; +class SchedProcessFreeFtraceEvent; +class SchedProcessHangFtraceEvent; +class SchedProcessWaitFtraceEvent; +class SchedSwitchFtraceEvent; +class SchedSwitchWithCtrsFtraceEvent; +class SchedWakeupFtraceEvent; +class SchedWakeupNewFtraceEvent; +class SchedWakingFtraceEvent; +class ScmCallEndFtraceEvent; +class ScmCallStartFtraceEvent; +class Screenshot; +class SdeSdeEvtlogFtraceEvent; +class SdeSdePerfCalcCrtcFtraceEvent; +class SdeSdePerfCrtcUpdateFtraceEvent; +class SdeSdePerfSetQosLutsFtraceEvent; +class SdeSdePerfUpdateBusFtraceEvent; +class SdeTracingMarkWriteFtraceEvent; +class ShellHandlerMapping; +class ShellHandlerMappings; +class ShellTransition; +class ShellTransition_Target; +class SignalDeliverFtraceEvent; +class SignalGenerateFtraceEvent; +class SizeProto; +class SliceNameTranslationTable; +class SliceNameTranslationTable_RawToDeobfuscatedNameEntry; +class SmapsEntry; +class SmapsPacket; +class SmbusReadFtraceEvent; +class SmbusReplyFtraceEvent; +class SmbusResultFtraceEvent; +class SmbusWriteFtraceEvent; +class SoftirqEntryFtraceEvent; +class SoftirqExitFtraceEvent; +class SoftirqRaiseFtraceEvent; +class SourceLocation; +class StatsdAtom; +class StatsdPullAtomConfig; +class StatsdTracingConfig; +class StreamingAllocation; +class StreamingFree; +class StreamingProfilePacket; +class SurfaceFlingerLayersConfig; +class SurfaceFlingerTransactionsConfig; +class SuspendResumeFtraceEvent; +class SuspendResumeMinimalFtraceEvent; +class SyncPtFtraceEvent; +class SyncTimelineFtraceEvent; +class SyncWaitFtraceEvent; +class SysEnterFtraceEvent; +class SysExitFtraceEvent; +class SysStats; +class SysStats_BuddyInfo; +class SysStats_CpuTimes; +class SysStats_DevfreqValue; +class SysStats_DiskStat; +class SysStats_InterruptCount; +class SysStats_MeminfoValue; +class SysStats_PsiSample; +class SysStats_VmstatValue; +class SysStatsConfig; +class SystemInfo; +class SystemInfoConfig; +class TaskExecution; +class TaskNewtaskFtraceEvent; +class TaskRenameFtraceEvent; +class TcpRetransmitSkbFtraceEvent; +class TestConfig; +class TestConfig_DummyFields; +class TestEvent; +class TestEvent_TestPayload; +class ThermalTemperatureFtraceEvent; +class ThreadDescriptor; +class TraceConfig; +class TraceConfig_AndroidReportConfig; +class TraceConfig_BufferConfig; +class TraceConfig_BuiltinDataSource; +class TraceConfig_CmdTraceStartDelay; +class TraceConfig_DataSource; +class TraceConfig_GuardrailOverrides; +class TraceConfig_IncidentReportConfig; +class TraceConfig_IncrementalStateConfig; +class TraceConfig_ProducerConfig; +class TraceConfig_StatsdMetadata; +class TraceConfig_TraceFilter; +class TraceConfig_TraceFilter_StringFilterChain; +class TraceConfig_TraceFilter_StringFilterRule; +class TraceConfig_TriggerConfig; +class TraceConfig_TriggerConfig_Trigger; +class TracePacket; +class TracePacketDefaults; +class TraceStats; +class TraceStats_BufferStats; +class TraceStats_FilterStats; +class TraceStats_WriterStats; +class TraceUuid; +class TracingMarkWriteFtraceEvent; +class TracingServiceEvent; +class TracingServiceState_DataSource; +class TracingServiceState_Producer; +class TracingServiceState_TracingSession; +class TrackDescriptor; +class TrackEvent; +class TrackEvent_LegacyEvent; +class TrackEventCategory; +class TrackEventConfig; +class TrackEventDefaults; +class TrackEventDescriptor; +class TrackEventRangeOfInterest; +class TransactionState; +class TransactionTraceEntry; +class Transform; +class TransformProto; +class TranslationTable; +class TrapRegFtraceEvent; +class Trigger; +class TrustyEnqueueNopFtraceEvent; +class TrustyIpcConnectEndFtraceEvent; +class TrustyIpcConnectFtraceEvent; +class TrustyIpcHandleEventFtraceEvent; +class TrustyIpcPollFtraceEvent; +class TrustyIpcReadEndFtraceEvent; +class TrustyIpcReadFtraceEvent; +class TrustyIpcRxFtraceEvent; +class TrustyIpcWriteFtraceEvent; +class TrustyIrqFtraceEvent; +class TrustyReclaimMemoryDoneFtraceEvent; +class TrustyReclaimMemoryFtraceEvent; +class TrustyShareMemoryDoneFtraceEvent; +class TrustyShareMemoryFtraceEvent; +class TrustySmcDoneFtraceEvent; +class TrustySmcFtraceEvent; +class TrustyStdCall32DoneFtraceEvent; +class TrustyStdCall32FtraceEvent; +class UfshcdClkGatingFtraceEvent; +class UfshcdCommandFtraceEvent; +class UiState; +class UiState_HighlightProcess; +class UninterpretedOption; +class UninterpretedOption_NamePart; +class UnsymbolizedSourceLocation; +class Utsname; +class V4l2DqbufFtraceEvent; +class V4l2QbufFtraceEvent; +class V8CodeDefaults; +class V8CodeMove; +class V8Config; +class V8InternalCode; +class V8JsCode; +class V8RegExpCode; +class V8String; +class V8WasmCode; +class Vb2V4l2BufDoneFtraceEvent; +class Vb2V4l2BufQueueFtraceEvent; +class Vb2V4l2DqbufFtraceEvent; +class Vb2V4l2QbufFtraceEvent; +class VgicUpdateIrqPendingFtraceEvent; +class VirtioGpuCmdQueueFtraceEvent; +class VirtioGpuCmdResponseFtraceEvent; +class VirtioVideoCmdDoneFtraceEvent; +class VirtioVideoCmdFtraceEvent; +class VirtioVideoResourceQueueDoneFtraceEvent; +class VirtioVideoResourceQueueFtraceEvent; +class VulkanApiEvent; +class VulkanApiEvent_VkDebugUtilsObjectName; +class VulkanApiEvent_VkQueueSubmit; +class VulkanMemoryConfig; +class VulkanMemoryEvent; +class VulkanMemoryEventAnnotation; +class WakeupSourceActivateFtraceEvent; +class WakeupSourceDeactivateFtraceEvent; +class WorkqueueActivateWorkFtraceEvent; +class WorkqueueExecuteEndFtraceEvent; +class WorkqueueExecuteStartFtraceEvent; +class WorkqueueQueueWorkFtraceEvent; +class ZeroFtraceEvent; +namespace perfetto_pbzero_enum_AndroidCameraFrameEvent { +enum CaptureResultStatus : int32_t; +} // namespace perfetto_pbzero_enum_AndroidCameraFrameEvent +using AndroidCameraFrameEvent_CaptureResultStatus = perfetto_pbzero_enum_AndroidCameraFrameEvent::CaptureResultStatus; +namespace perfetto_pbzero_enum_AndroidInputEventConfig { +enum TraceLevel : int32_t; +} // namespace perfetto_pbzero_enum_AndroidInputEventConfig +using AndroidInputEventConfig_TraceLevel = perfetto_pbzero_enum_AndroidInputEventConfig::TraceLevel; +namespace perfetto_pbzero_enum_AndroidInputEventConfig { +enum TraceMode : int32_t; +} // namespace perfetto_pbzero_enum_AndroidInputEventConfig +using AndroidInputEventConfig_TraceMode = perfetto_pbzero_enum_AndroidInputEventConfig::TraceMode; +enum AndroidLogId : int32_t; +enum AndroidLogPriority : int32_t; +namespace perfetto_pbzero_enum_AndroidPowerConfig { +enum BatteryCounters : int32_t; +} // namespace perfetto_pbzero_enum_AndroidPowerConfig +using AndroidPowerConfig_BatteryCounters = perfetto_pbzero_enum_AndroidPowerConfig::BatteryCounters; +enum AtomId : int32_t; +namespace perfetto_pbzero_enum_BackgroundTracingMetadata_TriggerRule_NamedRule { +enum EventType : int32_t; +} // namespace perfetto_pbzero_enum_BackgroundTracingMetadata_TriggerRule_NamedRule +using BackgroundTracingMetadata_TriggerRule_NamedRule_EventType = perfetto_pbzero_enum_BackgroundTracingMetadata_TriggerRule_NamedRule::EventType; +namespace perfetto_pbzero_enum_BackgroundTracingMetadata_TriggerRule { +enum TriggerType : int32_t; +} // namespace perfetto_pbzero_enum_BackgroundTracingMetadata_TriggerRule +using BackgroundTracingMetadata_TriggerRule_TriggerType = perfetto_pbzero_enum_BackgroundTracingMetadata_TriggerRule::TriggerType; +namespace perfetto_pbzero_enum_BeginFrameArgs { +enum BeginFrameArgsType : int32_t; +} // namespace perfetto_pbzero_enum_BeginFrameArgs +using BeginFrameArgs_BeginFrameArgsType = perfetto_pbzero_enum_BeginFrameArgs::BeginFrameArgsType; +namespace perfetto_pbzero_enum_BeginImplFrameArgs { +enum State : int32_t; +} // namespace perfetto_pbzero_enum_BeginImplFrameArgs +using BeginImplFrameArgs_State = perfetto_pbzero_enum_BeginImplFrameArgs::State; +enum BuiltinClock : int32_t; +namespace perfetto_pbzero_enum_CSwitchEtwEvent { +enum OldThreadState : int32_t; +} // namespace perfetto_pbzero_enum_CSwitchEtwEvent +using CSwitchEtwEvent_OldThreadState = perfetto_pbzero_enum_CSwitchEtwEvent::OldThreadState; +namespace perfetto_pbzero_enum_CSwitchEtwEvent { +enum OldThreadWaitMode : int32_t; +} // namespace perfetto_pbzero_enum_CSwitchEtwEvent +using CSwitchEtwEvent_OldThreadWaitMode = perfetto_pbzero_enum_CSwitchEtwEvent::OldThreadWaitMode; +namespace perfetto_pbzero_enum_CSwitchEtwEvent { +enum OldThreadWaitReason : int32_t; +} // namespace perfetto_pbzero_enum_CSwitchEtwEvent +using CSwitchEtwEvent_OldThreadWaitReason = perfetto_pbzero_enum_CSwitchEtwEvent::OldThreadWaitReason; +namespace perfetto_pbzero_enum_ChromeApplicationStateInfo { +enum ChromeApplicationState : int32_t; +} // namespace perfetto_pbzero_enum_ChromeApplicationStateInfo +using ChromeApplicationStateInfo_ChromeApplicationState = perfetto_pbzero_enum_ChromeApplicationStateInfo::ChromeApplicationState; +enum ChromeCompositorSchedulerAction : int32_t; +namespace perfetto_pbzero_enum_ChromeCompositorSchedulerState { +enum BeginImplFrameDeadlineMode : int32_t; +} // namespace perfetto_pbzero_enum_ChromeCompositorSchedulerState +using ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode = perfetto_pbzero_enum_ChromeCompositorSchedulerState::BeginImplFrameDeadlineMode; +namespace perfetto_pbzero_enum_ChromeCompositorStateMachine_MajorState { +enum BeginImplFrameState : int32_t; +} // namespace perfetto_pbzero_enum_ChromeCompositorStateMachine_MajorState +using ChromeCompositorStateMachine_MajorState_BeginImplFrameState = perfetto_pbzero_enum_ChromeCompositorStateMachine_MajorState::BeginImplFrameState; +namespace perfetto_pbzero_enum_ChromeCompositorStateMachine_MajorState { +enum BeginMainFrameState : int32_t; +} // namespace perfetto_pbzero_enum_ChromeCompositorStateMachine_MajorState +using ChromeCompositorStateMachine_MajorState_BeginMainFrameState = perfetto_pbzero_enum_ChromeCompositorStateMachine_MajorState::BeginMainFrameState; +namespace perfetto_pbzero_enum_ChromeCompositorStateMachine_MajorState { +enum ForcedRedrawOnTimeoutState : int32_t; +} // namespace perfetto_pbzero_enum_ChromeCompositorStateMachine_MajorState +using ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState = perfetto_pbzero_enum_ChromeCompositorStateMachine_MajorState::ForcedRedrawOnTimeoutState; +namespace perfetto_pbzero_enum_ChromeCompositorStateMachine_MajorState { +enum LayerTreeFrameSinkState : int32_t; +} // namespace perfetto_pbzero_enum_ChromeCompositorStateMachine_MajorState +using ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState = perfetto_pbzero_enum_ChromeCompositorStateMachine_MajorState::LayerTreeFrameSinkState; +namespace perfetto_pbzero_enum_ChromeCompositorStateMachine_MinorState { +enum ScrollHandlerState : int32_t; +} // namespace perfetto_pbzero_enum_ChromeCompositorStateMachine_MinorState +using ChromeCompositorStateMachine_MinorState_ScrollHandlerState = perfetto_pbzero_enum_ChromeCompositorStateMachine_MinorState::ScrollHandlerState; +namespace perfetto_pbzero_enum_ChromeCompositorStateMachine_MinorState { +enum TreePriority : int32_t; +} // namespace perfetto_pbzero_enum_ChromeCompositorStateMachine_MinorState +using ChromeCompositorStateMachine_MinorState_TreePriority = perfetto_pbzero_enum_ChromeCompositorStateMachine_MinorState::TreePriority; +namespace perfetto_pbzero_enum_ChromeConfig { +enum ClientPriority : int32_t; +} // namespace perfetto_pbzero_enum_ChromeConfig +using ChromeConfig_ClientPriority = perfetto_pbzero_enum_ChromeConfig::ClientPriority; +namespace perfetto_pbzero_enum_ChromeFrameReporter { +enum FrameDropReason : int32_t; +} // namespace perfetto_pbzero_enum_ChromeFrameReporter +using ChromeFrameReporter_FrameDropReason = perfetto_pbzero_enum_ChromeFrameReporter::FrameDropReason; +namespace perfetto_pbzero_enum_ChromeFrameReporter { +enum FrameType : int32_t; +} // namespace perfetto_pbzero_enum_ChromeFrameReporter +using ChromeFrameReporter_FrameType = perfetto_pbzero_enum_ChromeFrameReporter::FrameType; +namespace perfetto_pbzero_enum_ChromeFrameReporter { +enum ScrollState : int32_t; +} // namespace perfetto_pbzero_enum_ChromeFrameReporter +using ChromeFrameReporter_ScrollState = perfetto_pbzero_enum_ChromeFrameReporter::ScrollState; +namespace perfetto_pbzero_enum_ChromeFrameReporter { +enum State : int32_t; +} // namespace perfetto_pbzero_enum_ChromeFrameReporter +using ChromeFrameReporter_State = perfetto_pbzero_enum_ChromeFrameReporter::State; +namespace perfetto_pbzero_enum_ChromeLatencyInfo { +enum LatencyComponentType : int32_t; +} // namespace perfetto_pbzero_enum_ChromeLatencyInfo +using ChromeLatencyInfo_LatencyComponentType = perfetto_pbzero_enum_ChromeLatencyInfo::LatencyComponentType; +namespace perfetto_pbzero_enum_ChromeLatencyInfo { +enum Step : int32_t; +} // namespace perfetto_pbzero_enum_ChromeLatencyInfo +using ChromeLatencyInfo_Step = perfetto_pbzero_enum_ChromeLatencyInfo::Step; +namespace perfetto_pbzero_enum_ChromeLegacyIpc { +enum MessageClass : int32_t; +} // namespace perfetto_pbzero_enum_ChromeLegacyIpc +using ChromeLegacyIpc_MessageClass = perfetto_pbzero_enum_ChromeLegacyIpc::MessageClass; +namespace perfetto_pbzero_enum_ChromeLegacyJsonTrace { +enum TraceType : int32_t; +} // namespace perfetto_pbzero_enum_ChromeLegacyJsonTrace +using ChromeLegacyJsonTrace_TraceType = perfetto_pbzero_enum_ChromeLegacyJsonTrace::TraceType; +namespace perfetto_pbzero_enum_ChromeProcessDescriptor { +enum ProcessType : int32_t; +} // namespace perfetto_pbzero_enum_ChromeProcessDescriptor +using ChromeProcessDescriptor_ProcessType = perfetto_pbzero_enum_ChromeProcessDescriptor::ProcessType; +enum ChromeRAILMode : int32_t; +namespace perfetto_pbzero_enum_ChromeThreadDescriptor { +enum ThreadType : int32_t; +} // namespace perfetto_pbzero_enum_ChromeThreadDescriptor +using ChromeThreadDescriptor_ThreadType = perfetto_pbzero_enum_ChromeThreadDescriptor::ThreadType; +namespace perfetto_pbzero_enum_ChromeTracedValue { +enum NestedType : int32_t; +} // namespace perfetto_pbzero_enum_ChromeTracedValue +using ChromeTracedValue_NestedType = perfetto_pbzero_enum_ChromeTracedValue::NestedType; +namespace perfetto_pbzero_enum_ConsoleConfig { +enum Output : int32_t; +} // namespace perfetto_pbzero_enum_ConsoleConfig +using ConsoleConfig_Output = perfetto_pbzero_enum_ConsoleConfig::Output; +namespace perfetto_pbzero_enum_CounterDescriptor { +enum BuiltinCounterType : int32_t; +} // namespace perfetto_pbzero_enum_CounterDescriptor +using CounterDescriptor_BuiltinCounterType = perfetto_pbzero_enum_CounterDescriptor::BuiltinCounterType; +namespace perfetto_pbzero_enum_CounterDescriptor { +enum Unit : int32_t; +} // namespace perfetto_pbzero_enum_CounterDescriptor +using CounterDescriptor_Unit = perfetto_pbzero_enum_CounterDescriptor::Unit; +namespace perfetto_pbzero_enum_DataSourceConfig { +enum SessionInitiator : int32_t; +} // namespace perfetto_pbzero_enum_DataSourceConfig +using DataSourceConfig_SessionInitiator = perfetto_pbzero_enum_DataSourceConfig::SessionInitiator; +namespace perfetto_pbzero_enum_DebugAnnotation_NestedValue { +enum NestedType : int32_t; +} // namespace perfetto_pbzero_enum_DebugAnnotation_NestedValue +using DebugAnnotation_NestedValue_NestedType = perfetto_pbzero_enum_DebugAnnotation_NestedValue::NestedType; +namespace perfetto_pbzero_enum_EtwConfig { +enum KernelFlag : int32_t; +} // namespace perfetto_pbzero_enum_EtwConfig +using EtwConfig_KernelFlag = perfetto_pbzero_enum_EtwConfig::KernelFlag; +namespace perfetto_pbzero_enum_FieldDescriptorProto { +enum Label : int32_t; +} // namespace perfetto_pbzero_enum_FieldDescriptorProto +using FieldDescriptorProto_Label = perfetto_pbzero_enum_FieldDescriptorProto::Label; +namespace perfetto_pbzero_enum_FieldDescriptorProto { +enum Type : int32_t; +} // namespace perfetto_pbzero_enum_FieldDescriptorProto +using FieldDescriptorProto_Type = perfetto_pbzero_enum_FieldDescriptorProto::Type; +namespace perfetto_pbzero_enum_FrameTimelineEvent { +enum JankSeverityType : int32_t; +} // namespace perfetto_pbzero_enum_FrameTimelineEvent +using FrameTimelineEvent_JankSeverityType = perfetto_pbzero_enum_FrameTimelineEvent::JankSeverityType; +namespace perfetto_pbzero_enum_FrameTimelineEvent { +enum PredictionType : int32_t; +} // namespace perfetto_pbzero_enum_FrameTimelineEvent +using FrameTimelineEvent_PredictionType = perfetto_pbzero_enum_FrameTimelineEvent::PredictionType; +namespace perfetto_pbzero_enum_FrameTimelineEvent { +enum PresentType : int32_t; +} // namespace perfetto_pbzero_enum_FrameTimelineEvent +using FrameTimelineEvent_PresentType = perfetto_pbzero_enum_FrameTimelineEvent::PresentType; +enum FtraceClock : int32_t; +namespace perfetto_pbzero_enum_FtraceConfig { +enum KsymsMemPolicy : int32_t; +} // namespace perfetto_pbzero_enum_FtraceConfig +using FtraceConfig_KsymsMemPolicy = perfetto_pbzero_enum_FtraceConfig::KsymsMemPolicy; +enum FtraceParseStatus : int32_t; +namespace perfetto_pbzero_enum_FtraceStats { +enum Phase : int32_t; +} // namespace perfetto_pbzero_enum_FtraceStats +using FtraceStats_Phase = perfetto_pbzero_enum_FtraceStats::Phase; +namespace perfetto_pbzero_enum_GpuLog { +enum Severity : int32_t; +} // namespace perfetto_pbzero_enum_GpuLog +using GpuLog_Severity = perfetto_pbzero_enum_GpuLog::Severity; +namespace perfetto_pbzero_enum_GraphicsFrameEvent { +enum BufferEventType : int32_t; +} // namespace perfetto_pbzero_enum_GraphicsFrameEvent +using GraphicsFrameEvent_BufferEventType = perfetto_pbzero_enum_GraphicsFrameEvent::BufferEventType; +namespace perfetto_pbzero_enum_HeapGraphRoot { +enum Type : int32_t; +} // namespace perfetto_pbzero_enum_HeapGraphRoot +using HeapGraphRoot_Type = perfetto_pbzero_enum_HeapGraphRoot::Type; +namespace perfetto_pbzero_enum_HeapGraphType { +enum Kind : int32_t; +} // namespace perfetto_pbzero_enum_HeapGraphType +using HeapGraphType_Kind = perfetto_pbzero_enum_HeapGraphType::Kind; +enum HwcCompositionType : int32_t; +namespace perfetto_pbzero_enum_InodeFileMap_Entry { +enum Type : int32_t; +} // namespace perfetto_pbzero_enum_InodeFileMap_Entry +using InodeFileMap_Entry_Type = perfetto_pbzero_enum_InodeFileMap_Entry::Type; +namespace perfetto_pbzero_enum_InternedGpuRenderStageSpecification { +enum RenderStageCategory : int32_t; +} // namespace perfetto_pbzero_enum_InternedGpuRenderStageSpecification +using InternedGpuRenderStageSpecification_RenderStageCategory = perfetto_pbzero_enum_InternedGpuRenderStageSpecification::RenderStageCategory; +namespace perfetto_pbzero_enum_InternedGraphicsContext { +enum Api : int32_t; +} // namespace perfetto_pbzero_enum_InternedGraphicsContext +using InternedGraphicsContext_Api = perfetto_pbzero_enum_InternedGraphicsContext::Api; +namespace perfetto_pbzero_enum_InternedV8JsFunction { +enum Kind : int32_t; +} // namespace perfetto_pbzero_enum_InternedV8JsFunction +using InternedV8JsFunction_Kind = perfetto_pbzero_enum_InternedV8JsFunction::Kind; +namespace perfetto_pbzero_enum_InternedV8JsScript { +enum Type : int32_t; +} // namespace perfetto_pbzero_enum_InternedV8JsScript +using InternedV8JsScript_Type = perfetto_pbzero_enum_InternedV8JsScript::Type; +namespace perfetto_pbzero_enum_LayerState_BufferData { +enum PixelFormat : int32_t; +} // namespace perfetto_pbzero_enum_LayerState_BufferData +using LayerState_BufferData_PixelFormat = perfetto_pbzero_enum_LayerState_BufferData::PixelFormat; +namespace perfetto_pbzero_enum_LayerState { +enum DropInputMode : int32_t; +} // namespace perfetto_pbzero_enum_LayerState +using LayerState_DropInputMode = perfetto_pbzero_enum_LayerState::DropInputMode; +namespace perfetto_pbzero_enum_LogMessage { +enum Priority : int32_t; +} // namespace perfetto_pbzero_enum_LogMessage +using LogMessage_Priority = perfetto_pbzero_enum_LogMessage::Priority; +enum MeminfoCounters : int32_t; +namespace perfetto_pbzero_enum_MemoryTrackerSnapshot { +enum LevelOfDetail : int32_t; +} // namespace perfetto_pbzero_enum_MemoryTrackerSnapshot +using MemoryTrackerSnapshot_LevelOfDetail = perfetto_pbzero_enum_MemoryTrackerSnapshot::LevelOfDetail; +namespace perfetto_pbzero_enum_MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry { +enum Units : int32_t; +} // namespace perfetto_pbzero_enum_MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry +using MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry_Units = perfetto_pbzero_enum_MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry::Units; +namespace perfetto_pbzero_enum_PerfEventConfig { +enum UnwindMode : int32_t; +} // namespace perfetto_pbzero_enum_PerfEventConfig +using PerfEventConfig_UnwindMode = perfetto_pbzero_enum_PerfEventConfig::UnwindMode; +namespace perfetto_pbzero_enum_PerfEvents { +enum Counter : int32_t; +} // namespace perfetto_pbzero_enum_PerfEvents +using PerfEvents_Counter = perfetto_pbzero_enum_PerfEvents::Counter; +namespace perfetto_pbzero_enum_PerfEvents { +enum PerfClock : int32_t; +} // namespace perfetto_pbzero_enum_PerfEvents +using PerfEvents_PerfClock = perfetto_pbzero_enum_PerfEvents::PerfClock; +namespace perfetto_pbzero_enum_PerfSample_ProducerEvent { +enum DataSourceStopReason : int32_t; +} // namespace perfetto_pbzero_enum_PerfSample_ProducerEvent +using PerfSample_ProducerEvent_DataSourceStopReason = perfetto_pbzero_enum_PerfSample_ProducerEvent::DataSourceStopReason; +namespace perfetto_pbzero_enum_PerfSample { +enum SampleSkipReason : int32_t; +} // namespace perfetto_pbzero_enum_PerfSample +using PerfSample_SampleSkipReason = perfetto_pbzero_enum_PerfSample::SampleSkipReason; +namespace perfetto_pbzero_enum_ProcessDescriptor { +enum ChromeProcessType : int32_t; +} // namespace perfetto_pbzero_enum_ProcessDescriptor +using ProcessDescriptor_ChromeProcessType = perfetto_pbzero_enum_ProcessDescriptor::ChromeProcessType; +namespace perfetto_pbzero_enum_ProcessStatsConfig { +enum Quirks : int32_t; +} // namespace perfetto_pbzero_enum_ProcessStatsConfig +using ProcessStatsConfig_Quirks = perfetto_pbzero_enum_ProcessStatsConfig::Quirks; +namespace perfetto_pbzero_enum_ProfilePacket_ProcessHeapSamples { +enum ClientError : int32_t; +} // namespace perfetto_pbzero_enum_ProfilePacket_ProcessHeapSamples +using ProfilePacket_ProcessHeapSamples_ClientError = perfetto_pbzero_enum_ProfilePacket_ProcessHeapSamples::ClientError; +namespace perfetto_pbzero_enum_Profiling { +enum CpuMode : int32_t; +} // namespace perfetto_pbzero_enum_Profiling +using Profiling_CpuMode = perfetto_pbzero_enum_Profiling::CpuMode; +namespace perfetto_pbzero_enum_Profiling { +enum StackUnwindError : int32_t; +} // namespace perfetto_pbzero_enum_Profiling +using Profiling_StackUnwindError = perfetto_pbzero_enum_Profiling::StackUnwindError; +namespace perfetto_pbzero_enum_ProtoLogConfig { +enum TracingMode : int32_t; +} // namespace perfetto_pbzero_enum_ProtoLogConfig +using ProtoLogConfig_TracingMode = perfetto_pbzero_enum_ProtoLogConfig::TracingMode; +enum ProtoLogLevel : int32_t; +namespace perfetto_pbzero_enum_ReadyThreadEtwEvent { +enum AdjustReason : int32_t; +} // namespace perfetto_pbzero_enum_ReadyThreadEtwEvent +using ReadyThreadEtwEvent_AdjustReason = perfetto_pbzero_enum_ReadyThreadEtwEvent::AdjustReason; +namespace perfetto_pbzero_enum_ReadyThreadEtwEvent { +enum TraceFlag : int32_t; +} // namespace perfetto_pbzero_enum_ReadyThreadEtwEvent +using ReadyThreadEtwEvent_TraceFlag = perfetto_pbzero_enum_ReadyThreadEtwEvent::TraceFlag; +namespace perfetto_pbzero_enum_SurfaceFlingerLayersConfig { +enum Mode : int32_t; +} // namespace perfetto_pbzero_enum_SurfaceFlingerLayersConfig +using SurfaceFlingerLayersConfig_Mode = perfetto_pbzero_enum_SurfaceFlingerLayersConfig::Mode; +namespace perfetto_pbzero_enum_SurfaceFlingerLayersConfig { +enum TraceFlag : int32_t; +} // namespace perfetto_pbzero_enum_SurfaceFlingerLayersConfig +using SurfaceFlingerLayersConfig_TraceFlag = perfetto_pbzero_enum_SurfaceFlingerLayersConfig::TraceFlag; +namespace perfetto_pbzero_enum_SurfaceFlingerTransactionsConfig { +enum Mode : int32_t; +} // namespace perfetto_pbzero_enum_SurfaceFlingerTransactionsConfig +using SurfaceFlingerTransactionsConfig_Mode = perfetto_pbzero_enum_SurfaceFlingerTransactionsConfig::Mode; +namespace perfetto_pbzero_enum_SysStats_PsiSample { +enum PsiResource : int32_t; +} // namespace perfetto_pbzero_enum_SysStats_PsiSample +using SysStats_PsiSample_PsiResource = perfetto_pbzero_enum_SysStats_PsiSample::PsiResource; +namespace perfetto_pbzero_enum_SysStatsConfig { +enum StatCounters : int32_t; +} // namespace perfetto_pbzero_enum_SysStatsConfig +using SysStatsConfig_StatCounters = perfetto_pbzero_enum_SysStatsConfig::StatCounters; +namespace perfetto_pbzero_enum_ThreadDescriptor { +enum ChromeThreadType : int32_t; +} // namespace perfetto_pbzero_enum_ThreadDescriptor +using ThreadDescriptor_ChromeThreadType = perfetto_pbzero_enum_ThreadDescriptor::ChromeThreadType; +namespace perfetto_pbzero_enum_TraceConfig_BufferConfig { +enum FillPolicy : int32_t; +} // namespace perfetto_pbzero_enum_TraceConfig_BufferConfig +using TraceConfig_BufferConfig_FillPolicy = perfetto_pbzero_enum_TraceConfig_BufferConfig::FillPolicy; +namespace perfetto_pbzero_enum_TraceConfig { +enum CompressionType : int32_t; +} // namespace perfetto_pbzero_enum_TraceConfig +using TraceConfig_CompressionType = perfetto_pbzero_enum_TraceConfig::CompressionType; +namespace perfetto_pbzero_enum_TraceConfig { +enum LockdownModeOperation : int32_t; +} // namespace perfetto_pbzero_enum_TraceConfig +using TraceConfig_LockdownModeOperation = perfetto_pbzero_enum_TraceConfig::LockdownModeOperation; +namespace perfetto_pbzero_enum_TraceConfig { +enum StatsdLogging : int32_t; +} // namespace perfetto_pbzero_enum_TraceConfig +using TraceConfig_StatsdLogging = perfetto_pbzero_enum_TraceConfig::StatsdLogging; +namespace perfetto_pbzero_enum_TraceConfig_TraceFilter { +enum StringFilterPolicy : int32_t; +} // namespace perfetto_pbzero_enum_TraceConfig_TraceFilter +using TraceConfig_TraceFilter_StringFilterPolicy = perfetto_pbzero_enum_TraceConfig_TraceFilter::StringFilterPolicy; +namespace perfetto_pbzero_enum_TraceConfig_TriggerConfig { +enum TriggerMode : int32_t; +} // namespace perfetto_pbzero_enum_TraceConfig_TriggerConfig +using TraceConfig_TriggerConfig_TriggerMode = perfetto_pbzero_enum_TraceConfig_TriggerConfig::TriggerMode; +namespace perfetto_pbzero_enum_TraceStats { +enum FinalFlushOutcome : int32_t; +} // namespace perfetto_pbzero_enum_TraceStats +using TraceStats_FinalFlushOutcome = perfetto_pbzero_enum_TraceStats::FinalFlushOutcome; +namespace perfetto_pbzero_enum_TrackEvent_LegacyEvent { +enum FlowDirection : int32_t; +} // namespace perfetto_pbzero_enum_TrackEvent_LegacyEvent +using TrackEvent_LegacyEvent_FlowDirection = perfetto_pbzero_enum_TrackEvent_LegacyEvent::FlowDirection; +namespace perfetto_pbzero_enum_TrackEvent_LegacyEvent { +enum InstantEventScope : int32_t; +} // namespace perfetto_pbzero_enum_TrackEvent_LegacyEvent +using TrackEvent_LegacyEvent_InstantEventScope = perfetto_pbzero_enum_TrackEvent_LegacyEvent::InstantEventScope; +namespace perfetto_pbzero_enum_TrackEvent { +enum Type : int32_t; +} // namespace perfetto_pbzero_enum_TrackEvent +using TrackEvent_Type = perfetto_pbzero_enum_TrackEvent::Type; +enum TrafficDirection : int32_t; +namespace perfetto_pbzero_enum_V8InternalCode { +enum Type : int32_t; +} // namespace perfetto_pbzero_enum_V8InternalCode +using V8InternalCode_Type = perfetto_pbzero_enum_V8InternalCode::Type; +namespace perfetto_pbzero_enum_V8JsCode { +enum Tier : int32_t; +} // namespace perfetto_pbzero_enum_V8JsCode +using V8JsCode_Tier = perfetto_pbzero_enum_V8JsCode::Tier; +namespace perfetto_pbzero_enum_V8WasmCode { +enum Tier : int32_t; +} // namespace perfetto_pbzero_enum_V8WasmCode +using V8WasmCode_Tier = perfetto_pbzero_enum_V8WasmCode::Tier; +enum VmstatCounters : int32_t; +namespace perfetto_pbzero_enum_VulkanMemoryEvent { +enum AllocationScope : int32_t; +} // namespace perfetto_pbzero_enum_VulkanMemoryEvent +using VulkanMemoryEvent_AllocationScope = perfetto_pbzero_enum_VulkanMemoryEvent::AllocationScope; +namespace perfetto_pbzero_enum_VulkanMemoryEvent { +enum Operation : int32_t; +} // namespace perfetto_pbzero_enum_VulkanMemoryEvent +using VulkanMemoryEvent_Operation = perfetto_pbzero_enum_VulkanMemoryEvent::Operation; +namespace perfetto_pbzero_enum_VulkanMemoryEvent { +enum Source : int32_t; +} // namespace perfetto_pbzero_enum_VulkanMemoryEvent +using VulkanMemoryEvent_Source = perfetto_pbzero_enum_VulkanMemoryEvent::Source; +} // Namespace pbzero. +} // Namespace protos. +} // Namespace perfetto. + +namespace perfetto { +namespace protos { +namespace pbzero { + +enum BuiltinClock : int32_t { + BUILTIN_CLOCK_UNKNOWN = 0, + BUILTIN_CLOCK_REALTIME = 1, + BUILTIN_CLOCK_REALTIME_COARSE = 2, + BUILTIN_CLOCK_MONOTONIC = 3, + BUILTIN_CLOCK_MONOTONIC_COARSE = 4, + BUILTIN_CLOCK_MONOTONIC_RAW = 5, + BUILTIN_CLOCK_BOOTTIME = 6, + BUILTIN_CLOCK_TSC = 9, + BUILTIN_CLOCK_MAX_ID = 63, +}; + +constexpr BuiltinClock BuiltinClock_MIN = BuiltinClock::BUILTIN_CLOCK_UNKNOWN; +constexpr BuiltinClock BuiltinClock_MAX = BuiltinClock::BUILTIN_CLOCK_MAX_ID; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* BuiltinClock_Name(::perfetto::protos::pbzero::BuiltinClock value) { + switch (value) { + case ::perfetto::protos::pbzero::BuiltinClock::BUILTIN_CLOCK_UNKNOWN: + return "BUILTIN_CLOCK_UNKNOWN"; + + case ::perfetto::protos::pbzero::BuiltinClock::BUILTIN_CLOCK_REALTIME: + return "BUILTIN_CLOCK_REALTIME"; + + case ::perfetto::protos::pbzero::BuiltinClock::BUILTIN_CLOCK_REALTIME_COARSE: + return "BUILTIN_CLOCK_REALTIME_COARSE"; + + case ::perfetto::protos::pbzero::BuiltinClock::BUILTIN_CLOCK_MONOTONIC: + return "BUILTIN_CLOCK_MONOTONIC"; + + case ::perfetto::protos::pbzero::BuiltinClock::BUILTIN_CLOCK_MONOTONIC_COARSE: + return "BUILTIN_CLOCK_MONOTONIC_COARSE"; + + case ::perfetto::protos::pbzero::BuiltinClock::BUILTIN_CLOCK_MONOTONIC_RAW: + return "BUILTIN_CLOCK_MONOTONIC_RAW"; + + case ::perfetto::protos::pbzero::BuiltinClock::BUILTIN_CLOCK_BOOTTIME: + return "BUILTIN_CLOCK_BOOTTIME"; + + case ::perfetto::protos::pbzero::BuiltinClock::BUILTIN_CLOCK_TSC: + return "BUILTIN_CLOCK_TSC"; + + case ::perfetto::protos::pbzero::BuiltinClock::BUILTIN_CLOCK_MAX_ID: + return "BUILTIN_CLOCK_MAX_ID"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +enum AndroidLogId : int32_t { + LID_DEFAULT = 0, + LID_RADIO = 1, + LID_EVENTS = 2, + LID_SYSTEM = 3, + LID_CRASH = 4, + LID_STATS = 5, + LID_SECURITY = 6, + LID_KERNEL = 7, +}; + +constexpr AndroidLogId AndroidLogId_MIN = AndroidLogId::LID_DEFAULT; +constexpr AndroidLogId AndroidLogId_MAX = AndroidLogId::LID_KERNEL; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* AndroidLogId_Name(::perfetto::protos::pbzero::AndroidLogId value) { + switch (value) { + case ::perfetto::protos::pbzero::AndroidLogId::LID_DEFAULT: + return "LID_DEFAULT"; + + case ::perfetto::protos::pbzero::AndroidLogId::LID_RADIO: + return "LID_RADIO"; + + case ::perfetto::protos::pbzero::AndroidLogId::LID_EVENTS: + return "LID_EVENTS"; + + case ::perfetto::protos::pbzero::AndroidLogId::LID_SYSTEM: + return "LID_SYSTEM"; + + case ::perfetto::protos::pbzero::AndroidLogId::LID_CRASH: + return "LID_CRASH"; + + case ::perfetto::protos::pbzero::AndroidLogId::LID_STATS: + return "LID_STATS"; + + case ::perfetto::protos::pbzero::AndroidLogId::LID_SECURITY: + return "LID_SECURITY"; + + case ::perfetto::protos::pbzero::AndroidLogId::LID_KERNEL: + return "LID_KERNEL"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +enum AndroidLogPriority : int32_t { + PRIO_UNSPECIFIED = 0, + PRIO_UNUSED = 1, + PRIO_VERBOSE = 2, + PRIO_DEBUG = 3, + PRIO_INFO = 4, + PRIO_WARN = 5, + PRIO_ERROR = 6, + PRIO_FATAL = 7, +}; + +constexpr AndroidLogPriority AndroidLogPriority_MIN = AndroidLogPriority::PRIO_UNSPECIFIED; +constexpr AndroidLogPriority AndroidLogPriority_MAX = AndroidLogPriority::PRIO_FATAL; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* AndroidLogPriority_Name(::perfetto::protos::pbzero::AndroidLogPriority value) { + switch (value) { + case ::perfetto::protos::pbzero::AndroidLogPriority::PRIO_UNSPECIFIED: + return "PRIO_UNSPECIFIED"; + + case ::perfetto::protos::pbzero::AndroidLogPriority::PRIO_UNUSED: + return "PRIO_UNUSED"; + + case ::perfetto::protos::pbzero::AndroidLogPriority::PRIO_VERBOSE: + return "PRIO_VERBOSE"; + + case ::perfetto::protos::pbzero::AndroidLogPriority::PRIO_DEBUG: + return "PRIO_DEBUG"; + + case ::perfetto::protos::pbzero::AndroidLogPriority::PRIO_INFO: + return "PRIO_INFO"; + + case ::perfetto::protos::pbzero::AndroidLogPriority::PRIO_WARN: + return "PRIO_WARN"; + + case ::perfetto::protos::pbzero::AndroidLogPriority::PRIO_ERROR: + return "PRIO_ERROR"; + + case ::perfetto::protos::pbzero::AndroidLogPriority::PRIO_FATAL: + return "PRIO_FATAL"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +enum ProtoLogLevel : int32_t { + PROTOLOG_LEVEL_UNDEFINED = 0, + PROTOLOG_LEVEL_DEBUG = 1, + PROTOLOG_LEVEL_VERBOSE = 2, + PROTOLOG_LEVEL_INFO = 3, + PROTOLOG_LEVEL_WARN = 4, + PROTOLOG_LEVEL_ERROR = 5, + PROTOLOG_LEVEL_WTF = 6, +}; + +constexpr ProtoLogLevel ProtoLogLevel_MIN = ProtoLogLevel::PROTOLOG_LEVEL_UNDEFINED; +constexpr ProtoLogLevel ProtoLogLevel_MAX = ProtoLogLevel::PROTOLOG_LEVEL_WTF; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* ProtoLogLevel_Name(::perfetto::protos::pbzero::ProtoLogLevel value) { + switch (value) { + case ::perfetto::protos::pbzero::ProtoLogLevel::PROTOLOG_LEVEL_UNDEFINED: + return "PROTOLOG_LEVEL_UNDEFINED"; + + case ::perfetto::protos::pbzero::ProtoLogLevel::PROTOLOG_LEVEL_DEBUG: + return "PROTOLOG_LEVEL_DEBUG"; + + case ::perfetto::protos::pbzero::ProtoLogLevel::PROTOLOG_LEVEL_VERBOSE: + return "PROTOLOG_LEVEL_VERBOSE"; + + case ::perfetto::protos::pbzero::ProtoLogLevel::PROTOLOG_LEVEL_INFO: + return "PROTOLOG_LEVEL_INFO"; + + case ::perfetto::protos::pbzero::ProtoLogLevel::PROTOLOG_LEVEL_WARN: + return "PROTOLOG_LEVEL_WARN"; + + case ::perfetto::protos::pbzero::ProtoLogLevel::PROTOLOG_LEVEL_ERROR: + return "PROTOLOG_LEVEL_ERROR"; + + case ::perfetto::protos::pbzero::ProtoLogLevel::PROTOLOG_LEVEL_WTF: + return "PROTOLOG_LEVEL_WTF"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +enum AtomId : int32_t { + ATOM_UNSPECIFIED = 0, + ATOM_BLE_SCAN_STATE_CHANGED = 2, + ATOM_PROCESS_STATE_CHANGED = 3, + ATOM_BLE_SCAN_RESULT_RECEIVED = 4, + ATOM_SENSOR_STATE_CHANGED = 5, + ATOM_GPS_SCAN_STATE_CHANGED = 6, + ATOM_SYNC_STATE_CHANGED = 7, + ATOM_SCHEDULED_JOB_STATE_CHANGED = 8, + ATOM_SCREEN_BRIGHTNESS_CHANGED = 9, + ATOM_WAKELOCK_STATE_CHANGED = 10, + ATOM_LONG_PARTIAL_WAKELOCK_STATE_CHANGED = 11, + ATOM_MOBILE_RADIO_POWER_STATE_CHANGED = 12, + ATOM_WIFI_RADIO_POWER_STATE_CHANGED = 13, + ATOM_ACTIVITY_MANAGER_SLEEP_STATE_CHANGED = 14, + ATOM_MEMORY_FACTOR_STATE_CHANGED = 15, + ATOM_EXCESSIVE_CPU_USAGE_REPORTED = 16, + ATOM_CACHED_KILL_REPORTED = 17, + ATOM_PROCESS_MEMORY_STAT_REPORTED = 18, + ATOM_LAUNCHER_EVENT = 19, + ATOM_BATTERY_SAVER_MODE_STATE_CHANGED = 20, + ATOM_DEVICE_IDLE_MODE_STATE_CHANGED = 21, + ATOM_DEVICE_IDLING_MODE_STATE_CHANGED = 22, + ATOM_AUDIO_STATE_CHANGED = 23, + ATOM_MEDIA_CODEC_STATE_CHANGED = 24, + ATOM_CAMERA_STATE_CHANGED = 25, + ATOM_FLASHLIGHT_STATE_CHANGED = 26, + ATOM_UID_PROCESS_STATE_CHANGED = 27, + ATOM_PROCESS_LIFE_CYCLE_STATE_CHANGED = 28, + ATOM_SCREEN_STATE_CHANGED = 29, + ATOM_BATTERY_LEVEL_CHANGED = 30, + ATOM_CHARGING_STATE_CHANGED = 31, + ATOM_PLUGGED_STATE_CHANGED = 32, + ATOM_INTERACTIVE_STATE_CHANGED = 33, + ATOM_TOUCH_EVENT_REPORTED = 34, + ATOM_WAKEUP_ALARM_OCCURRED = 35, + ATOM_KERNEL_WAKEUP_REPORTED = 36, + ATOM_WIFI_LOCK_STATE_CHANGED = 37, + ATOM_WIFI_SIGNAL_STRENGTH_CHANGED = 38, + ATOM_WIFI_SCAN_STATE_CHANGED = 39, + ATOM_PHONE_SIGNAL_STRENGTH_CHANGED = 40, + ATOM_SETTING_CHANGED = 41, + ATOM_ACTIVITY_FOREGROUND_STATE_CHANGED = 42, + ATOM_ISOLATED_UID_CHANGED = 43, + ATOM_PACKET_WAKEUP_OCCURRED = 44, + ATOM_WALL_CLOCK_TIME_SHIFTED = 45, + ATOM_ANOMALY_DETECTED = 46, + ATOM_APP_BREADCRUMB_REPORTED = 47, + ATOM_APP_START_OCCURRED = 48, + ATOM_APP_START_CANCELED = 49, + ATOM_APP_START_FULLY_DRAWN = 50, + ATOM_LMK_KILL_OCCURRED = 51, + ATOM_PICTURE_IN_PICTURE_STATE_CHANGED = 52, + ATOM_WIFI_MULTICAST_LOCK_STATE_CHANGED = 53, + ATOM_LMK_STATE_CHANGED = 54, + ATOM_APP_START_MEMORY_STATE_CAPTURED = 55, + ATOM_SHUTDOWN_SEQUENCE_REPORTED = 56, + ATOM_BOOT_SEQUENCE_REPORTED = 57, + ATOM_DAVEY_OCCURRED = 58, + ATOM_OVERLAY_STATE_CHANGED = 59, + ATOM_FOREGROUND_SERVICE_STATE_CHANGED = 60, + ATOM_CALL_STATE_CHANGED = 61, + ATOM_KEYGUARD_STATE_CHANGED = 62, + ATOM_KEYGUARD_BOUNCER_STATE_CHANGED = 63, + ATOM_KEYGUARD_BOUNCER_PASSWORD_ENTERED = 64, + ATOM_APP_DIED = 65, + ATOM_RESOURCE_CONFIGURATION_CHANGED = 66, + ATOM_BLUETOOTH_ENABLED_STATE_CHANGED = 67, + ATOM_BLUETOOTH_CONNECTION_STATE_CHANGED = 68, + ATOM_GPS_SIGNAL_QUALITY_CHANGED = 69, + ATOM_USB_CONNECTOR_STATE_CHANGED = 70, + ATOM_SPEAKER_IMPEDANCE_REPORTED = 71, + ATOM_HARDWARE_FAILED = 72, + ATOM_PHYSICAL_DROP_DETECTED = 73, + ATOM_CHARGE_CYCLES_REPORTED = 74, + ATOM_MOBILE_CONNECTION_STATE_CHANGED = 75, + ATOM_MOBILE_RADIO_TECHNOLOGY_CHANGED = 76, + ATOM_USB_DEVICE_ATTACHED = 77, + ATOM_APP_CRASH_OCCURRED = 78, + ATOM_ANR_OCCURRED = 79, + ATOM_WTF_OCCURRED = 80, + ATOM_LOW_MEM_REPORTED = 81, + ATOM_GENERIC_ATOM = 82, + ATOM_VIBRATOR_STATE_CHANGED = 84, + ATOM_DEFERRED_JOB_STATS_REPORTED = 85, + ATOM_THERMAL_THROTTLING = 86, + ATOM_BIOMETRIC_ACQUIRED = 87, + ATOM_BIOMETRIC_AUTHENTICATED = 88, + ATOM_BIOMETRIC_ERROR_OCCURRED = 89, + ATOM_UI_EVENT_REPORTED = 90, + ATOM_BATTERY_HEALTH_SNAPSHOT = 91, + ATOM_SLOW_IO = 92, + ATOM_BATTERY_CAUSED_SHUTDOWN = 93, + ATOM_PHONE_SERVICE_STATE_CHANGED = 94, + ATOM_PHONE_STATE_CHANGED = 95, + ATOM_USER_RESTRICTION_CHANGED = 96, + ATOM_SETTINGS_UI_CHANGED = 97, + ATOM_CONNECTIVITY_STATE_CHANGED = 98, + ATOM_SERVICE_STATE_CHANGED = 99, + ATOM_SERVICE_LAUNCH_REPORTED = 100, + ATOM_FLAG_FLIP_UPDATE_OCCURRED = 101, + ATOM_BINARY_PUSH_STATE_CHANGED = 102, + ATOM_DEVICE_POLICY_EVENT = 103, + ATOM_DOCS_UI_FILE_OP_CANCELED = 104, + ATOM_DOCS_UI_FILE_OP_COPY_MOVE_MODE_REPORTED = 105, + ATOM_DOCS_UI_FILE_OP_FAILURE = 106, + ATOM_DOCS_UI_PROVIDER_FILE_OP = 107, + ATOM_DOCS_UI_INVALID_SCOPED_ACCESS_REQUEST = 108, + ATOM_DOCS_UI_LAUNCH_REPORTED = 109, + ATOM_DOCS_UI_ROOT_VISITED = 110, + ATOM_DOCS_UI_STARTUP_MS = 111, + ATOM_DOCS_UI_USER_ACTION_REPORTED = 112, + ATOM_WIFI_ENABLED_STATE_CHANGED = 113, + ATOM_WIFI_RUNNING_STATE_CHANGED = 114, + ATOM_APP_COMPACTED = 115, + ATOM_NETWORK_DNS_EVENT_REPORTED = 116, + ATOM_DOCS_UI_PICKER_LAUNCHED_FROM_REPORTED = 117, + ATOM_DOCS_UI_PICK_RESULT_REPORTED = 118, + ATOM_DOCS_UI_SEARCH_MODE_REPORTED = 119, + ATOM_DOCS_UI_SEARCH_TYPE_REPORTED = 120, + ATOM_DATA_STALL_EVENT = 121, + ATOM_RESCUE_PARTY_RESET_REPORTED = 122, + ATOM_SIGNED_CONFIG_REPORTED = 123, + ATOM_GNSS_NI_EVENT_REPORTED = 124, + ATOM_BLUETOOTH_LINK_LAYER_CONNECTION_EVENT = 125, + ATOM_BLUETOOTH_ACL_CONNECTION_STATE_CHANGED = 126, + ATOM_BLUETOOTH_SCO_CONNECTION_STATE_CHANGED = 127, + ATOM_APP_DOWNGRADED = 128, + ATOM_APP_OPTIMIZED_AFTER_DOWNGRADED = 129, + ATOM_LOW_STORAGE_STATE_CHANGED = 130, + ATOM_GNSS_NFW_NOTIFICATION_REPORTED = 131, + ATOM_GNSS_CONFIGURATION_REPORTED = 132, + ATOM_USB_PORT_OVERHEAT_EVENT_REPORTED = 133, + ATOM_NFC_ERROR_OCCURRED = 134, + ATOM_NFC_STATE_CHANGED = 135, + ATOM_NFC_BEAM_OCCURRED = 136, + ATOM_NFC_CARDEMULATION_OCCURRED = 137, + ATOM_NFC_TAG_OCCURRED = 138, + ATOM_NFC_HCE_TRANSACTION_OCCURRED = 139, + ATOM_SE_STATE_CHANGED = 140, + ATOM_SE_OMAPI_REPORTED = 141, + ATOM_BROADCAST_DISPATCH_LATENCY_REPORTED = 142, + ATOM_ATTENTION_MANAGER_SERVICE_RESULT_REPORTED = 143, + ATOM_ADB_CONNECTION_CHANGED = 144, + ATOM_SPEECH_DSP_STAT_REPORTED = 145, + ATOM_USB_CONTAMINANT_REPORTED = 146, + ATOM_WATCHDOG_ROLLBACK_OCCURRED = 147, + ATOM_BIOMETRIC_SYSTEM_HEALTH_ISSUE_DETECTED = 148, + ATOM_BUBBLE_UI_CHANGED = 149, + ATOM_SCHEDULED_JOB_CONSTRAINT_CHANGED = 150, + ATOM_BLUETOOTH_ACTIVE_DEVICE_CHANGED = 151, + ATOM_BLUETOOTH_A2DP_PLAYBACK_STATE_CHANGED = 152, + ATOM_BLUETOOTH_A2DP_CODEC_CONFIG_CHANGED = 153, + ATOM_BLUETOOTH_A2DP_CODEC_CAPABILITY_CHANGED = 154, + ATOM_BLUETOOTH_A2DP_AUDIO_UNDERRUN_REPORTED = 155, + ATOM_BLUETOOTH_A2DP_AUDIO_OVERRUN_REPORTED = 156, + ATOM_BLUETOOTH_DEVICE_RSSI_REPORTED = 157, + ATOM_BLUETOOTH_DEVICE_FAILED_CONTACT_COUNTER_REPORTED = 158, + ATOM_BLUETOOTH_DEVICE_TX_POWER_LEVEL_REPORTED = 159, + ATOM_BLUETOOTH_HCI_TIMEOUT_REPORTED = 160, + ATOM_BLUETOOTH_QUALITY_REPORT_REPORTED = 161, + ATOM_BLUETOOTH_DEVICE_INFO_REPORTED = 162, + ATOM_BLUETOOTH_REMOTE_VERSION_INFO_REPORTED = 163, + ATOM_BLUETOOTH_SDP_ATTRIBUTE_REPORTED = 164, + ATOM_BLUETOOTH_BOND_STATE_CHANGED = 165, + ATOM_BLUETOOTH_CLASSIC_PAIRING_EVENT_REPORTED = 166, + ATOM_BLUETOOTH_SMP_PAIRING_EVENT_REPORTED = 167, + ATOM_SCREEN_TIMEOUT_EXTENSION_REPORTED = 168, + ATOM_PROCESS_START_TIME = 169, + ATOM_PERMISSION_GRANT_REQUEST_RESULT_REPORTED = 170, + ATOM_BLUETOOTH_SOCKET_CONNECTION_STATE_CHANGED = 171, + ATOM_DEVICE_IDENTIFIER_ACCESS_DENIED = 172, + ATOM_BUBBLE_DEVELOPER_ERROR_REPORTED = 173, + ATOM_ASSIST_GESTURE_STAGE_REPORTED = 174, + ATOM_ASSIST_GESTURE_FEEDBACK_REPORTED = 175, + ATOM_ASSIST_GESTURE_PROGRESS_REPORTED = 176, + ATOM_TOUCH_GESTURE_CLASSIFIED = 177, + ATOM_HIDDEN_API_USED = 178, + ATOM_STYLE_UI_CHANGED = 179, + ATOM_PRIVACY_INDICATORS_INTERACTED = 180, + ATOM_APP_INSTALL_ON_EXTERNAL_STORAGE_REPORTED = 181, + ATOM_NETWORK_STACK_REPORTED = 182, + ATOM_APP_MOVED_STORAGE_REPORTED = 183, + ATOM_BIOMETRIC_ENROLLED = 184, + ATOM_SYSTEM_SERVER_WATCHDOG_OCCURRED = 185, + ATOM_TOMB_STONE_OCCURRED = 186, + ATOM_BLUETOOTH_CLASS_OF_DEVICE_REPORTED = 187, + ATOM_INTELLIGENCE_EVENT_REPORTED = 188, + ATOM_THERMAL_THROTTLING_SEVERITY_STATE_CHANGED = 189, + ATOM_ROLE_REQUEST_RESULT_REPORTED = 190, + ATOM_MEDIAMETRICS_AUDIOPOLICY_REPORTED = 191, + ATOM_MEDIAMETRICS_AUDIORECORD_REPORTED = 192, + ATOM_MEDIAMETRICS_AUDIOTHREAD_REPORTED = 193, + ATOM_MEDIAMETRICS_AUDIOTRACK_REPORTED = 194, + ATOM_MEDIAMETRICS_CODEC_REPORTED = 195, + ATOM_MEDIAMETRICS_DRM_WIDEVINE_REPORTED = 196, + ATOM_MEDIAMETRICS_EXTRACTOR_REPORTED = 197, + ATOM_MEDIAMETRICS_MEDIADRM_REPORTED = 198, + ATOM_MEDIAMETRICS_NUPLAYER_REPORTED = 199, + ATOM_MEDIAMETRICS_RECORDER_REPORTED = 200, + ATOM_MEDIAMETRICS_DRMMANAGER_REPORTED = 201, + ATOM_CAR_POWER_STATE_CHANGED = 203, + ATOM_GARAGE_MODE_INFO = 204, + ATOM_TEST_ATOM_REPORTED = 205, + ATOM_CONTENT_CAPTURE_CALLER_MISMATCH_REPORTED = 206, + ATOM_CONTENT_CAPTURE_SERVICE_EVENTS = 207, + ATOM_CONTENT_CAPTURE_SESSION_EVENTS = 208, + ATOM_CONTENT_CAPTURE_FLUSHED = 209, + ATOM_LOCATION_MANAGER_API_USAGE_REPORTED = 210, + ATOM_REVIEW_PERMISSIONS_FRAGMENT_RESULT_REPORTED = 211, + ATOM_RUNTIME_PERMISSIONS_UPGRADE_RESULT = 212, + ATOM_GRANT_PERMISSIONS_ACTIVITY_BUTTON_ACTIONS = 213, + ATOM_LOCATION_ACCESS_CHECK_NOTIFICATION_ACTION = 214, + ATOM_APP_PERMISSION_FRAGMENT_ACTION_REPORTED = 215, + ATOM_APP_PERMISSION_FRAGMENT_VIEWED = 216, + ATOM_APP_PERMISSIONS_FRAGMENT_VIEWED = 217, + ATOM_PERMISSION_APPS_FRAGMENT_VIEWED = 218, + ATOM_TEXT_SELECTION_EVENT = 219, + ATOM_TEXT_LINKIFY_EVENT = 220, + ATOM_CONVERSATION_ACTIONS_EVENT = 221, + ATOM_LANGUAGE_DETECTION_EVENT = 222, + ATOM_EXCLUSION_RECT_STATE_CHANGED = 223, + ATOM_BACK_GESTURE_REPORTED_REPORTED = 224, + ATOM_UPDATE_ENGINE_UPDATE_ATTEMPT_REPORTED = 225, + ATOM_UPDATE_ENGINE_SUCCESSFUL_UPDATE_REPORTED = 226, + ATOM_CAMERA_ACTION_EVENT = 227, + ATOM_APP_COMPATIBILITY_CHANGE_REPORTED = 228, + ATOM_PERFETTO_UPLOADED = 229, + ATOM_VMS_CLIENT_CONNECTION_STATE_CHANGED = 230, + ATOM_MEDIA_PROVIDER_SCAN_OCCURRED = 233, + ATOM_MEDIA_CONTENT_DELETED = 234, + ATOM_MEDIA_PROVIDER_PERMISSION_REQUESTED = 235, + ATOM_MEDIA_PROVIDER_SCHEMA_CHANGED = 236, + ATOM_MEDIA_PROVIDER_IDLE_MAINTENANCE_FINISHED = 237, + ATOM_REBOOT_ESCROW_RECOVERY_REPORTED = 238, + ATOM_BOOT_TIME_EVENT_DURATION_REPORTED = 239, + ATOM_BOOT_TIME_EVENT_ELAPSED_TIME_REPORTED = 240, + ATOM_BOOT_TIME_EVENT_UTC_TIME_REPORTED = 241, + ATOM_BOOT_TIME_EVENT_ERROR_CODE_REPORTED = 242, + ATOM_USERSPACE_REBOOT_REPORTED = 243, + ATOM_NOTIFICATION_REPORTED = 244, + ATOM_NOTIFICATION_PANEL_REPORTED = 245, + ATOM_NOTIFICATION_CHANNEL_MODIFIED = 246, + ATOM_INTEGRITY_CHECK_RESULT_REPORTED = 247, + ATOM_INTEGRITY_RULES_PUSHED = 248, + ATOM_CB_MESSAGE_REPORTED = 249, + ATOM_CB_MESSAGE_ERROR = 250, + ATOM_WIFI_HEALTH_STAT_REPORTED = 251, + ATOM_WIFI_FAILURE_STAT_REPORTED = 252, + ATOM_WIFI_CONNECTION_RESULT_REPORTED = 253, + ATOM_APP_FREEZE_CHANGED = 254, + ATOM_SNAPSHOT_MERGE_REPORTED = 255, + ATOM_FOREGROUND_SERVICE_APP_OP_SESSION_ENDED = 256, + ATOM_DISPLAY_JANK_REPORTED = 257, + ATOM_APP_STANDBY_BUCKET_CHANGED = 258, + ATOM_SHARESHEET_STARTED = 259, + ATOM_RANKING_SELECTED = 260, + ATOM_TVSETTINGS_UI_INTERACTED = 261, + ATOM_LAUNCHER_SNAPSHOT = 262, + ATOM_PACKAGE_INSTALLER_V2_REPORTED = 263, + ATOM_USER_LIFECYCLE_JOURNEY_REPORTED = 264, + ATOM_USER_LIFECYCLE_EVENT_OCCURRED = 265, + ATOM_ACCESSIBILITY_SHORTCUT_REPORTED = 266, + ATOM_ACCESSIBILITY_SERVICE_REPORTED = 267, + ATOM_DOCS_UI_DRAG_AND_DROP_REPORTED = 268, + ATOM_APP_USAGE_EVENT_OCCURRED = 269, + ATOM_AUTO_REVOKE_NOTIFICATION_CLICKED = 270, + ATOM_AUTO_REVOKE_FRAGMENT_APP_VIEWED = 271, + ATOM_AUTO_REVOKED_APP_INTERACTION = 272, + ATOM_APP_PERMISSION_GROUPS_FRAGMENT_AUTO_REVOKE_ACTION = 273, + ATOM_EVS_USAGE_STATS_REPORTED = 274, + ATOM_AUDIO_POWER_USAGE_DATA_REPORTED = 275, + ATOM_TV_TUNER_STATE_CHANGED = 276, + ATOM_MEDIAOUTPUT_OP_SWITCH_REPORTED = 277, + ATOM_CB_MESSAGE_FILTERED = 278, + ATOM_TV_TUNER_DVR_STATUS = 279, + ATOM_TV_CAS_SESSION_OPEN_STATUS = 280, + ATOM_ASSISTANT_INVOCATION_REPORTED = 281, + ATOM_DISPLAY_WAKE_REPORTED = 282, + ATOM_CAR_USER_HAL_MODIFY_USER_REQUEST_REPORTED = 283, + ATOM_CAR_USER_HAL_MODIFY_USER_RESPONSE_REPORTED = 284, + ATOM_CAR_USER_HAL_POST_SWITCH_RESPONSE_REPORTED = 285, + ATOM_CAR_USER_HAL_INITIAL_USER_INFO_REQUEST_REPORTED = 286, + ATOM_CAR_USER_HAL_INITIAL_USER_INFO_RESPONSE_REPORTED = 287, + ATOM_CAR_USER_HAL_USER_ASSOCIATION_REQUEST_REPORTED = 288, + ATOM_CAR_USER_HAL_SET_USER_ASSOCIATION_RESPONSE_REPORTED = 289, + ATOM_NETWORK_IP_PROVISIONING_REPORTED = 290, + ATOM_NETWORK_DHCP_RENEW_REPORTED = 291, + ATOM_NETWORK_VALIDATION_REPORTED = 292, + ATOM_NETWORK_STACK_QUIRK_REPORTED = 293, + ATOM_MEDIAMETRICS_AUDIORECORDDEVICEUSAGE_REPORTED = 294, + ATOM_MEDIAMETRICS_AUDIOTHREADDEVICEUSAGE_REPORTED = 295, + ATOM_MEDIAMETRICS_AUDIOTRACKDEVICEUSAGE_REPORTED = 296, + ATOM_MEDIAMETRICS_AUDIODEVICECONNECTION_REPORTED = 297, + ATOM_BLOB_COMMITTED = 298, + ATOM_BLOB_LEASED = 299, + ATOM_BLOB_OPENED = 300, + ATOM_CONTACTS_PROVIDER_STATUS_REPORTED = 301, + ATOM_KEYSTORE_KEY_EVENT_REPORTED = 302, + ATOM_NETWORK_TETHERING_REPORTED = 303, + ATOM_IME_TOUCH_REPORTED = 304, + ATOM_UI_INTERACTION_FRAME_INFO_REPORTED = 305, + ATOM_UI_ACTION_LATENCY_REPORTED = 306, + ATOM_WIFI_DISCONNECT_REPORTED = 307, + ATOM_WIFI_CONNECTION_STATE_CHANGED = 308, + ATOM_HDMI_CEC_ACTIVE_SOURCE_CHANGED = 309, + ATOM_HDMI_CEC_MESSAGE_REPORTED = 310, + ATOM_AIRPLANE_MODE = 311, + ATOM_MODEM_RESTART = 312, + ATOM_CARRIER_ID_MISMATCH_REPORTED = 313, + ATOM_CARRIER_ID_TABLE_UPDATED = 314, + ATOM_DATA_STALL_RECOVERY_REPORTED = 315, + ATOM_MEDIAMETRICS_MEDIAPARSER_REPORTED = 316, + ATOM_TLS_HANDSHAKE_REPORTED = 317, + ATOM_TEXT_CLASSIFIER_API_USAGE_REPORTED = 318, + ATOM_CAR_WATCHDOG_KILL_STATS_REPORTED = 319, + ATOM_MEDIAMETRICS_PLAYBACK_REPORTED = 320, + ATOM_MEDIA_NETWORK_INFO_CHANGED = 321, + ATOM_MEDIA_PLAYBACK_STATE_CHANGED = 322, + ATOM_MEDIA_PLAYBACK_ERROR_REPORTED = 323, + ATOM_MEDIA_PLAYBACK_TRACK_CHANGED = 324, + ATOM_WIFI_SCAN_REPORTED = 325, + ATOM_WIFI_PNO_SCAN_REPORTED = 326, + ATOM_TIF_TUNE_CHANGED = 327, + ATOM_AUTO_ROTATE_REPORTED = 328, + ATOM_PERFETTO_TRIGGER = 329, + ATOM_TRANSCODING_DATA = 330, + ATOM_IMS_SERVICE_ENTITLEMENT_UPDATED = 331, + ATOM_DEVICE_ROTATED = 333, + ATOM_SIM_SPECIFIC_SETTINGS_RESTORED = 334, + ATOM_TEXT_CLASSIFIER_DOWNLOAD_REPORTED = 335, + ATOM_PIN_STORAGE_EVENT = 336, + ATOM_FACE_DOWN_REPORTED = 337, + ATOM_BLUETOOTH_HAL_CRASH_REASON_REPORTED = 338, + ATOM_REBOOT_ESCROW_PREPARATION_REPORTED = 339, + ATOM_REBOOT_ESCROW_LSKF_CAPTURE_REPORTED = 340, + ATOM_REBOOT_ESCROW_REBOOT_REPORTED = 341, + ATOM_BINDER_LATENCY_REPORTED = 342, + ATOM_MEDIAMETRICS_AAUDIOSTREAM_REPORTED = 343, + ATOM_MEDIA_TRANSCODING_SESSION_ENDED = 344, + ATOM_MAGNIFICATION_USAGE_REPORTED = 345, + ATOM_MAGNIFICATION_MODE_WITH_IME_ON_REPORTED = 346, + ATOM_APP_SEARCH_CALL_STATS_REPORTED = 347, + ATOM_APP_SEARCH_PUT_DOCUMENT_STATS_REPORTED = 348, + ATOM_DEVICE_CONTROL_CHANGED = 349, + ATOM_DEVICE_STATE_CHANGED = 350, + ATOM_INPUTDEVICE_REGISTERED = 351, + ATOM_SMARTSPACE_CARD_REPORTED = 352, + ATOM_AUTH_PROMPT_AUTHENTICATE_INVOKED = 353, + ATOM_AUTH_MANAGER_CAN_AUTHENTICATE_INVOKED = 354, + ATOM_AUTH_ENROLL_ACTION_INVOKED = 355, + ATOM_AUTH_DEPRECATED_API_USED = 356, + ATOM_UNATTENDED_REBOOT_OCCURRED = 357, + ATOM_LONG_REBOOT_BLOCKING_REPORTED = 358, + ATOM_LOCATION_TIME_ZONE_PROVIDER_STATE_CHANGED = 359, + ATOM_FDTRACK_EVENT_OCCURRED = 364, + ATOM_TIMEOUT_AUTO_EXTENDED_REPORTED = 365, + ATOM_ALARM_BATCH_DELIVERED = 367, + ATOM_ALARM_SCHEDULED = 368, + ATOM_CAR_WATCHDOG_IO_OVERUSE_STATS_REPORTED = 369, + ATOM_USER_LEVEL_HIBERNATION_STATE_CHANGED = 370, + ATOM_APP_SEARCH_INITIALIZE_STATS_REPORTED = 371, + ATOM_APP_SEARCH_QUERY_STATS_REPORTED = 372, + ATOM_APP_PROCESS_DIED = 373, + ATOM_NETWORK_IP_REACHABILITY_MONITOR_REPORTED = 374, + ATOM_SLOW_INPUT_EVENT_REPORTED = 375, + ATOM_ANR_OCCURRED_PROCESSING_STARTED = 376, + ATOM_APP_SEARCH_REMOVE_STATS_REPORTED = 377, + ATOM_MEDIA_CODEC_REPORTED = 378, + ATOM_PERMISSION_USAGE_FRAGMENT_INTERACTION = 379, + ATOM_PERMISSION_DETAILS_INTERACTION = 380, + ATOM_PRIVACY_SENSOR_TOGGLE_INTERACTION = 381, + ATOM_PRIVACY_TOGGLE_DIALOG_INTERACTION = 382, + ATOM_APP_SEARCH_OPTIMIZE_STATS_REPORTED = 383, + ATOM_NON_A11Y_TOOL_SERVICE_WARNING_REPORT = 384, + ATOM_APP_SEARCH_SET_SCHEMA_STATS_REPORTED = 385, + ATOM_APP_COMPAT_STATE_CHANGED = 386, + ATOM_SIZE_COMPAT_RESTART_BUTTON_EVENT_REPORTED = 387, + ATOM_SPLITSCREEN_UI_CHANGED = 388, + ATOM_NETWORK_DNS_HANDSHAKE_REPORTED = 389, + ATOM_BLUETOOTH_CODE_PATH_COUNTER = 390, + ATOM_BLUETOOTH_LE_BATCH_SCAN_REPORT_DELAY = 392, + ATOM_ACCESSIBILITY_FLOATING_MENU_UI_CHANGED = 393, + ATOM_NEURALNETWORKS_COMPILATION_COMPLETED = 394, + ATOM_NEURALNETWORKS_EXECUTION_COMPLETED = 395, + ATOM_NEURALNETWORKS_COMPILATION_FAILED = 396, + ATOM_NEURALNETWORKS_EXECUTION_FAILED = 397, + ATOM_CONTEXT_HUB_BOOTED = 398, + ATOM_CONTEXT_HUB_RESTARTED = 399, + ATOM_CONTEXT_HUB_LOADED_NANOAPP_SNAPSHOT_REPORTED = 400, + ATOM_CHRE_CODE_DOWNLOAD_TRANSACTED = 401, + ATOM_UWB_SESSION_INITED = 402, + ATOM_UWB_SESSION_CLOSED = 403, + ATOM_UWB_FIRST_RANGING_RECEIVED = 404, + ATOM_UWB_RANGING_MEASUREMENT_RECEIVED = 405, + ATOM_TEXT_CLASSIFIER_DOWNLOAD_WORK_SCHEDULED = 406, + ATOM_TEXT_CLASSIFIER_DOWNLOAD_WORK_COMPLETED = 407, + ATOM_CLIPBOARD_CLEARED = 408, + ATOM_VM_CREATION_REQUESTED = 409, + ATOM_NEARBY_DEVICE_SCAN_STATE_CHANGED = 410, + ATOM_CAMERA_COMPAT_CONTROL_EVENT_REPORTED = 411, + ATOM_APPLICATION_LOCALES_CHANGED = 412, + ATOM_MEDIAMETRICS_AUDIOTRACKSTATUS_REPORTED = 413, + ATOM_FOLD_STATE_DURATION_REPORTED = 414, + ATOM_LOCATION_TIME_ZONE_PROVIDER_CONTROLLER_STATE_CHANGED = 415, + ATOM_DISPLAY_HBM_STATE_CHANGED = 416, + ATOM_DISPLAY_HBM_BRIGHTNESS_CHANGED = 417, + ATOM_PERSISTENT_URI_PERMISSIONS_FLUSHED = 418, + ATOM_EARLY_BOOT_COMP_OS_ARTIFACTS_CHECK_REPORTED = 419, + ATOM_VBMETA_DIGEST_REPORTED = 420, + ATOM_APEX_INFO_GATHERED = 421, + ATOM_PVM_INFO_GATHERED = 422, + ATOM_WEAR_SETTINGS_UI_INTERACTED = 423, + ATOM_TRACING_SERVICE_REPORT_EVENT = 424, + ATOM_MEDIAMETRICS_AUDIORECORDSTATUS_REPORTED = 425, + ATOM_LAUNCHER_LATENCY = 426, + ATOM_DROPBOX_ENTRY_DROPPED = 427, + ATOM_WIFI_P2P_CONNECTION_REPORTED = 428, + ATOM_GAME_STATE_CHANGED = 429, + ATOM_HOTWORD_DETECTOR_CREATE_REQUESTED = 430, + ATOM_HOTWORD_DETECTION_SERVICE_INIT_RESULT_REPORTED = 431, + ATOM_HOTWORD_DETECTION_SERVICE_RESTARTED = 432, + ATOM_HOTWORD_DETECTOR_KEYPHRASE_TRIGGERED = 433, + ATOM_HOTWORD_DETECTOR_EVENTS = 434, + ATOM_AD_SERVICES_API_CALLED = 435, + ATOM_AD_SERVICES_MESUREMENT_REPORTS_UPLOADED = 436, + ATOM_BOOT_COMPLETED_BROADCAST_COMPLETION_LATENCY_REPORTED = 437, + ATOM_CONTACTS_INDEXER_UPDATE_STATS_REPORTED = 440, + ATOM_APP_BACKGROUND_RESTRICTIONS_INFO = 441, + ATOM_MMS_SMS_PROVIDER_GET_THREAD_ID_FAILED = 442, + ATOM_MMS_SMS_DATABASE_HELPER_ON_UPGRADE_FAILED = 443, + ATOM_PERMISSION_REMINDER_NOTIFICATION_INTERACTED = 444, + ATOM_RECENT_PERMISSION_DECISIONS_INTERACTED = 445, + ATOM_GNSS_PSDS_DOWNLOAD_REPORTED = 446, + ATOM_LE_AUDIO_CONNECTION_SESSION_REPORTED = 447, + ATOM_LE_AUDIO_BROADCAST_SESSION_REPORTED = 448, + ATOM_DREAM_UI_EVENT_REPORTED = 449, + ATOM_TASK_MANAGER_EVENT_REPORTED = 450, + ATOM_CDM_ASSOCIATION_ACTION = 451, + ATOM_MAGNIFICATION_TRIPLE_TAP_AND_HOLD_ACTIVATED_SESSION_REPORTED = 452, + ATOM_MAGNIFICATION_FOLLOW_TYPING_FOCUS_ACTIVATED_SESSION_REPORTED = 453, + ATOM_ACCESSIBILITY_TEXT_READING_OPTIONS_CHANGED = 454, + ATOM_WIFI_SETUP_FAILURE_CRASH_REPORTED = 455, + ATOM_UWB_DEVICE_ERROR_REPORTED = 456, + ATOM_ISOLATED_COMPILATION_SCHEDULED = 457, + ATOM_ISOLATED_COMPILATION_ENDED = 458, + ATOM_ONS_OPPORTUNISTIC_ESIM_PROVISIONING_COMPLETE = 459, + ATOM_SYSTEM_SERVER_PRE_WATCHDOG_OCCURRED = 460, + ATOM_TELEPHONY_ANOMALY_DETECTED = 461, + ATOM_LETTERBOX_POSITION_CHANGED = 462, + ATOM_REMOTE_KEY_PROVISIONING_ATTEMPT = 463, + ATOM_REMOTE_KEY_PROVISIONING_NETWORK_INFO = 464, + ATOM_REMOTE_KEY_PROVISIONING_TIMING = 465, + ATOM_MEDIAOUTPUT_OP_INTERACTION_REPORT = 466, + ATOM_SYNC_EXEMPTION_OCCURRED = 468, + ATOM_AUTOFILL_PRESENTATION_EVENT_REPORTED = 469, + ATOM_DOCK_STATE_CHANGED = 470, + ATOM_SAFETY_SOURCE_STATE_COLLECTED = 471, + ATOM_SAFETY_CENTER_SYSTEM_EVENT_REPORTED = 472, + ATOM_SAFETY_CENTER_INTERACTION_REPORTED = 473, + ATOM_SETTINGS_PROVIDER_SETTING_CHANGED = 474, + ATOM_BROADCAST_DELIVERY_EVENT_REPORTED = 475, + ATOM_SERVICE_REQUEST_EVENT_REPORTED = 476, + ATOM_PROVIDER_ACQUISITION_EVENT_REPORTED = 477, + ATOM_BLUETOOTH_DEVICE_NAME_REPORTED = 478, + ATOM_CB_CONFIG_UPDATED = 479, + ATOM_CB_MODULE_ERROR_REPORTED = 480, + ATOM_CB_SERVICE_FEATURE_CHANGED = 481, + ATOM_CB_RECEIVER_FEATURE_CHANGED = 482, + ATOM_JSSCRIPTENGINE_LATENCY_REPORTED = 483, + ATOM_PRIVACY_SIGNAL_NOTIFICATION_INTERACTION = 484, + ATOM_PRIVACY_SIGNAL_ISSUE_CARD_INTERACTION = 485, + ATOM_PRIVACY_SIGNALS_JOB_FAILURE = 486, + ATOM_VIBRATION_REPORTED = 487, + ATOM_UWB_RANGING_START = 489, + ATOM_MOBILE_DATA_DOWNLOAD_FILE_GROUP_STATUS_REPORTED = 490, + ATOM_APP_COMPACTED_V2 = 491, + ATOM_AD_SERVICES_SETTINGS_USAGE_REPORTED = 493, + ATOM_DISPLAY_BRIGHTNESS_CHANGED = 494, + ATOM_ACTIVITY_ACTION_BLOCKED = 495, + ATOM_BACKGROUND_FETCH_PROCESS_REPORTED = 496, + ATOM_UPDATE_CUSTOM_AUDIENCE_PROCESS_REPORTED = 497, + ATOM_RUN_AD_BIDDING_PROCESS_REPORTED = 498, + ATOM_RUN_AD_SCORING_PROCESS_REPORTED = 499, + ATOM_RUN_AD_SELECTION_PROCESS_REPORTED = 500, + ATOM_RUN_AD_BIDDING_PER_CA_PROCESS_REPORTED = 501, + ATOM_MOBILE_DATA_DOWNLOAD_DOWNLOAD_RESULT_REPORTED = 502, + ATOM_MOBILE_DATA_DOWNLOAD_FILE_GROUP_STORAGE_STATS_REPORTED = 503, + ATOM_NETWORK_DNS_SERVER_SUPPORT_REPORTED = 504, + ATOM_VM_BOOTED = 505, + ATOM_VM_EXITED = 506, + ATOM_AMBIENT_BRIGHTNESS_STATS_REPORTED = 507, + ATOM_MEDIAMETRICS_SPATIALIZERCAPABILITIES_REPORTED = 508, + ATOM_MEDIAMETRICS_SPATIALIZERDEVICEENABLED_REPORTED = 509, + ATOM_MEDIAMETRICS_HEADTRACKERDEVICEENABLED_REPORTED = 510, + ATOM_MEDIAMETRICS_HEADTRACKERDEVICESUPPORTED_REPORTED = 511, + ATOM_AD_SERVICES_MEASUREMENT_REGISTRATIONS = 512, + ATOM_HEARING_AID_INFO_REPORTED = 513, + ATOM_DEVICE_WIDE_JOB_CONSTRAINT_CHANGED = 514, + ATOM_AMBIENT_MODE_CHANGED = 515, + ATOM_ANR_LATENCY_REPORTED = 516, + ATOM_RESOURCE_API_INFO = 517, + ATOM_SYSTEM_DEFAULT_NETWORK_CHANGED = 518, + ATOM_IWLAN_SETUP_DATA_CALL_RESULT_REPORTED = 519, + ATOM_IWLAN_PDN_DISCONNECTED_REASON_REPORTED = 520, + ATOM_AIRPLANE_MODE_SESSION_REPORTED = 521, + ATOM_VM_CPU_STATUS_REPORTED = 522, + ATOM_VM_MEM_STATUS_REPORTED = 523, + ATOM_PACKAGE_INSTALLATION_SESSION_REPORTED = 524, + ATOM_DEFAULT_NETWORK_REMATCH_INFO = 525, + ATOM_NETWORK_SELECTION_PERFORMANCE = 526, + ATOM_NETWORK_NSD_REPORTED = 527, + ATOM_BLUETOOTH_DISCONNECTION_REASON_REPORTED = 529, + ATOM_BLUETOOTH_LOCAL_VERSIONS_REPORTED = 530, + ATOM_BLUETOOTH_REMOTE_SUPPORTED_FEATURES_REPORTED = 531, + ATOM_BLUETOOTH_LOCAL_SUPPORTED_FEATURES_REPORTED = 532, + ATOM_BLUETOOTH_GATT_APP_INFO = 533, + ATOM_BRIGHTNESS_CONFIGURATION_UPDATED = 534, + ATOM_AD_SERVICES_GET_TOPICS_REPORTED = 535, + ATOM_AD_SERVICES_EPOCH_COMPUTATION_GET_TOP_TOPICS_REPORTED = 536, + ATOM_AD_SERVICES_EPOCH_COMPUTATION_CLASSIFIER_REPORTED = 537, + ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_LAUNCHED = 538, + ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_FINISHED = 539, + ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_CONNECTION_REPORTED = 540, + ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_DEVICE_SCAN_TRIGGERED = 541, + ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_FIRST_DEVICE_SCAN_LATENCY = 542, + ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_CONNECT_DEVICE_LATENCY = 543, + ATOM_PACKAGE_MANAGER_SNAPSHOT_REPORTED = 544, + ATOM_PACKAGE_MANAGER_APPS_FILTER_CACHE_BUILD_REPORTED = 545, + ATOM_PACKAGE_MANAGER_APPS_FILTER_CACHE_UPDATE_REPORTED = 546, + ATOM_LAUNCHER_IMPRESSION_EVENT = 547, + ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_ALL_DEVICES_SCAN_LATENCY = 549, + ATOM_WS_WATCH_FACE_EDITED = 551, + ATOM_WS_WATCH_FACE_FAVORITE_ACTION_REPORTED = 552, + ATOM_WS_WATCH_FACE_SET_ACTION_REPORTED = 553, + ATOM_PACKAGE_UNINSTALLATION_REPORTED = 554, + ATOM_GAME_MODE_CHANGED = 555, + ATOM_GAME_MODE_CONFIGURATION_CHANGED = 556, + ATOM_BEDTIME_MODE_STATE_CHANGED = 557, + ATOM_NETWORK_SLICE_SESSION_ENDED = 558, + ATOM_NETWORK_SLICE_DAILY_DATA_USAGE_REPORTED = 559, + ATOM_NFC_TAG_TYPE_OCCURRED = 560, + ATOM_NFC_AID_CONFLICT_OCCURRED = 561, + ATOM_NFC_READER_CONFLICT_OCCURRED = 562, + ATOM_WS_TILE_LIST_CHANGED = 563, + ATOM_GET_TYPE_ACCESSED_WITHOUT_PERMISSION = 564, + ATOM_MOBILE_BUNDLED_APP_INFO_GATHERED = 566, + ATOM_WS_WATCH_FACE_COMPLICATION_SET_CHANGED = 567, + ATOM_MEDIA_DRM_CREATED = 568, + ATOM_MEDIA_DRM_ERRORED = 569, + ATOM_MEDIA_DRM_SESSION_OPENED = 570, + ATOM_MEDIA_DRM_SESSION_CLOSED = 571, + ATOM_USER_SELECTED_RESOLUTION = 572, + ATOM_UNSAFE_INTENT_EVENT_REPORTED = 573, + ATOM_PERFORMANCE_HINT_SESSION_REPORTED = 574, + ATOM_MEDIAMETRICS_MIDI_DEVICE_CLOSE_REPORTED = 576, + ATOM_BIOMETRIC_TOUCH_REPORTED = 577, + ATOM_HOTWORD_AUDIO_EGRESS_EVENT_REPORTED = 578, + ATOM_APP_SEARCH_SCHEMA_MIGRATION_STATS_REPORTED = 579, + ATOM_LOCATION_ENABLED_STATE_CHANGED = 580, + ATOM_IME_REQUEST_FINISHED = 581, + ATOM_USB_COMPLIANCE_WARNINGS_REPORTED = 582, + ATOM_APP_SUPPORTED_LOCALES_CHANGED = 583, + ATOM_GRAMMATICAL_INFLECTION_CHANGED = 584, + ATOM_MEDIA_PROVIDER_VOLUME_RECOVERY_REPORTED = 586, + ATOM_BIOMETRIC_PROPERTIES_COLLECTED = 587, + ATOM_KERNEL_WAKEUP_ATTRIBUTED = 588, + ATOM_SCREEN_STATE_CHANGED_V2 = 589, + ATOM_WS_BACKUP_ACTION_REPORTED = 590, + ATOM_WS_RESTORE_ACTION_REPORTED = 591, + ATOM_DEVICE_LOG_ACCESS_EVENT_REPORTED = 592, + ATOM_MEDIA_SESSION_UPDATED = 594, + ATOM_WEAR_OOBE_STATE_CHANGED = 595, + ATOM_WS_NOTIFICATION_UPDATED = 596, + ATOM_NETWORK_VALIDATION_FAILURE_STATS_DAILY_REPORTED = 601, + ATOM_WS_COMPLICATION_TAPPED = 602, + ATOM_WS_WEAR_TIME_SESSION = 610, + ATOM_WIFI_BYTES_TRANSFER = 10000, + ATOM_WIFI_BYTES_TRANSFER_BY_FG_BG = 10001, + ATOM_MOBILE_BYTES_TRANSFER = 10002, + ATOM_MOBILE_BYTES_TRANSFER_BY_FG_BG = 10003, + ATOM_BLUETOOTH_BYTES_TRANSFER = 10006, + ATOM_KERNEL_WAKELOCK = 10004, + ATOM_SUBSYSTEM_SLEEP_STATE = 10005, + ATOM_CPU_TIME_PER_UID = 10009, + ATOM_CPU_TIME_PER_UID_FREQ = 10010, + ATOM_WIFI_ACTIVITY_INFO = 10011, + ATOM_MODEM_ACTIVITY_INFO = 10012, + ATOM_BLUETOOTH_ACTIVITY_INFO = 10007, + ATOM_PROCESS_MEMORY_STATE = 10013, + ATOM_SYSTEM_ELAPSED_REALTIME = 10014, + ATOM_SYSTEM_UPTIME = 10015, + ATOM_CPU_ACTIVE_TIME = 10016, + ATOM_CPU_CLUSTER_TIME = 10017, + ATOM_DISK_SPACE = 10018, + ATOM_REMAINING_BATTERY_CAPACITY = 10019, + ATOM_FULL_BATTERY_CAPACITY = 10020, + ATOM_TEMPERATURE = 10021, + ATOM_BINDER_CALLS = 10022, + ATOM_BINDER_CALLS_EXCEPTIONS = 10023, + ATOM_LOOPER_STATS = 10024, + ATOM_DISK_STATS = 10025, + ATOM_DIRECTORY_USAGE = 10026, + ATOM_APP_SIZE = 10027, + ATOM_CATEGORY_SIZE = 10028, + ATOM_PROC_STATS = 10029, + ATOM_BATTERY_VOLTAGE = 10030, + ATOM_NUM_FINGERPRINTS_ENROLLED = 10031, + ATOM_DISK_IO = 10032, + ATOM_POWER_PROFILE = 10033, + ATOM_PROC_STATS_PKG_PROC = 10034, + ATOM_PROCESS_CPU_TIME = 10035, + ATOM_CPU_TIME_PER_THREAD_FREQ = 10037, + ATOM_ON_DEVICE_POWER_MEASUREMENT = 10038, + ATOM_DEVICE_CALCULATED_POWER_USE = 10039, + ATOM_PROCESS_MEMORY_HIGH_WATER_MARK = 10042, + ATOM_BATTERY_LEVEL = 10043, + ATOM_BUILD_INFORMATION = 10044, + ATOM_BATTERY_CYCLE_COUNT = 10045, + ATOM_DEBUG_ELAPSED_CLOCK = 10046, + ATOM_DEBUG_FAILING_ELAPSED_CLOCK = 10047, + ATOM_NUM_FACES_ENROLLED = 10048, + ATOM_ROLE_HOLDER = 10049, + ATOM_DANGEROUS_PERMISSION_STATE = 10050, + ATOM_TRAIN_INFO = 10051, + ATOM_TIME_ZONE_DATA_INFO = 10052, + ATOM_EXTERNAL_STORAGE_INFO = 10053, + ATOM_GPU_STATS_GLOBAL_INFO = 10054, + ATOM_GPU_STATS_APP_INFO = 10055, + ATOM_SYSTEM_ION_HEAP_SIZE = 10056, + ATOM_APPS_ON_EXTERNAL_STORAGE_INFO = 10057, + ATOM_FACE_SETTINGS = 10058, + ATOM_COOLING_DEVICE = 10059, + ATOM_APP_OPS = 10060, + ATOM_PROCESS_SYSTEM_ION_HEAP_SIZE = 10061, + ATOM_SURFACEFLINGER_STATS_GLOBAL_INFO = 10062, + ATOM_SURFACEFLINGER_STATS_LAYER_INFO = 10063, + ATOM_PROCESS_MEMORY_SNAPSHOT = 10064, + ATOM_VMS_CLIENT_STATS = 10065, + ATOM_NOTIFICATION_REMOTE_VIEWS = 10066, + ATOM_DANGEROUS_PERMISSION_STATE_SAMPLED = 10067, + ATOM_GRAPHICS_STATS = 10068, + ATOM_RUNTIME_APP_OP_ACCESS = 10069, + ATOM_ION_HEAP_SIZE = 10070, + ATOM_PACKAGE_NOTIFICATION_PREFERENCES = 10071, + ATOM_PACKAGE_NOTIFICATION_CHANNEL_PREFERENCES = 10072, + ATOM_PACKAGE_NOTIFICATION_CHANNEL_GROUP_PREFERENCES = 10073, + ATOM_GNSS_STATS = 10074, + ATOM_ATTRIBUTED_APP_OPS = 10075, + ATOM_VOICE_CALL_SESSION = 10076, + ATOM_VOICE_CALL_RAT_USAGE = 10077, + ATOM_SIM_SLOT_STATE = 10078, + ATOM_SUPPORTED_RADIO_ACCESS_FAMILY = 10079, + ATOM_SETTING_SNAPSHOT = 10080, + ATOM_BLOB_INFO = 10081, + ATOM_DATA_USAGE_BYTES_TRANSFER = 10082, + ATOM_BYTES_TRANSFER_BY_TAG_AND_METERED = 10083, + ATOM_DND_MODE_RULE = 10084, + ATOM_GENERAL_EXTERNAL_STORAGE_ACCESS_STATS = 10085, + ATOM_INCOMING_SMS = 10086, + ATOM_OUTGOING_SMS = 10087, + ATOM_CARRIER_ID_TABLE_VERSION = 10088, + ATOM_DATA_CALL_SESSION = 10089, + ATOM_CELLULAR_SERVICE_STATE = 10090, + ATOM_CELLULAR_DATA_SERVICE_SWITCH = 10091, + ATOM_SYSTEM_MEMORY = 10092, + ATOM_IMS_REGISTRATION_TERMINATION = 10093, + ATOM_IMS_REGISTRATION_STATS = 10094, + ATOM_CPU_TIME_PER_CLUSTER_FREQ = 10095, + ATOM_CPU_CYCLES_PER_UID_CLUSTER = 10096, + ATOM_DEVICE_ROTATED_DATA = 10097, + ATOM_CPU_CYCLES_PER_THREAD_GROUP_CLUSTER = 10098, + ATOM_MEDIA_DRM_ACTIVITY_INFO = 10099, + ATOM_OEM_MANAGED_BYTES_TRANSFER = 10100, + ATOM_GNSS_POWER_STATS = 10101, + ATOM_TIME_ZONE_DETECTOR_STATE = 10102, + ATOM_KEYSTORE2_STORAGE_STATS = 10103, + ATOM_RKP_POOL_STATS = 10104, + ATOM_PROCESS_DMABUF_MEMORY = 10105, + ATOM_PENDING_ALARM_INFO = 10106, + ATOM_USER_LEVEL_HIBERNATED_APPS = 10107, + ATOM_LAUNCHER_LAYOUT_SNAPSHOT = 10108, + ATOM_GLOBAL_HIBERNATED_APPS = 10109, + ATOM_INPUT_EVENT_LATENCY_SKETCH = 10110, + ATOM_BATTERY_USAGE_STATS_BEFORE_RESET = 10111, + ATOM_BATTERY_USAGE_STATS_SINCE_RESET = 10112, + ATOM_BATTERY_USAGE_STATS_SINCE_RESET_USING_POWER_PROFILE_MODEL = 10113, + ATOM_INSTALLED_INCREMENTAL_PACKAGE = 10114, + ATOM_TELEPHONY_NETWORK_REQUESTS = 10115, + ATOM_APP_SEARCH_STORAGE_INFO = 10116, + ATOM_VMSTAT = 10117, + ATOM_KEYSTORE2_KEY_CREATION_WITH_GENERAL_INFO = 10118, + ATOM_KEYSTORE2_KEY_CREATION_WITH_AUTH_INFO = 10119, + ATOM_KEYSTORE2_KEY_CREATION_WITH_PURPOSE_AND_MODES_INFO = 10120, + ATOM_KEYSTORE2_ATOM_WITH_OVERFLOW = 10121, + ATOM_KEYSTORE2_KEY_OPERATION_WITH_PURPOSE_AND_MODES_INFO = 10122, + ATOM_KEYSTORE2_KEY_OPERATION_WITH_GENERAL_INFO = 10123, + ATOM_RKP_ERROR_STATS = 10124, + ATOM_KEYSTORE2_CRASH_STATS = 10125, + ATOM_VENDOR_APEX_INFO = 10126, + ATOM_ACCESSIBILITY_SHORTCUT_STATS = 10127, + ATOM_ACCESSIBILITY_FLOATING_MENU_STATS = 10128, + ATOM_DATA_USAGE_BYTES_TRANSFER_V2 = 10129, + ATOM_MEDIA_CAPABILITIES = 10130, + ATOM_CAR_WATCHDOG_SYSTEM_IO_USAGE_SUMMARY = 10131, + ATOM_CAR_WATCHDOG_UID_IO_USAGE_SUMMARY = 10132, + ATOM_IMS_REGISTRATION_FEATURE_TAG_STATS = 10133, + ATOM_RCS_CLIENT_PROVISIONING_STATS = 10134, + ATOM_RCS_ACS_PROVISIONING_STATS = 10135, + ATOM_SIP_DELEGATE_STATS = 10136, + ATOM_SIP_TRANSPORT_FEATURE_TAG_STATS = 10137, + ATOM_SIP_MESSAGE_RESPONSE = 10138, + ATOM_SIP_TRANSPORT_SESSION = 10139, + ATOM_IMS_DEDICATED_BEARER_LISTENER_EVENT = 10140, + ATOM_IMS_DEDICATED_BEARER_EVENT = 10141, + ATOM_IMS_REGISTRATION_SERVICE_DESC_STATS = 10142, + ATOM_UCE_EVENT_STATS = 10143, + ATOM_PRESENCE_NOTIFY_EVENT = 10144, + ATOM_GBA_EVENT = 10145, + ATOM_PER_SIM_STATUS = 10146, + ATOM_GPU_WORK_PER_UID = 10147, + ATOM_PERSISTENT_URI_PERMISSIONS_AMOUNT_PER_PACKAGE = 10148, + ATOM_SIGNED_PARTITION_INFO = 10149, + ATOM_PINNED_FILE_SIZES_PER_PACKAGE = 10150, + ATOM_PENDING_INTENTS_PER_PACKAGE = 10151, + ATOM_USER_INFO = 10152, + ATOM_TELEPHONY_NETWORK_REQUESTS_V2 = 10153, + ATOM_DEVICE_TELEPHONY_PROPERTIES = 10154, + ATOM_REMOTE_KEY_PROVISIONING_ERROR_COUNTS = 10155, + ATOM_SAFETY_STATE = 10156, + ATOM_INCOMING_MMS = 10157, + ATOM_OUTGOING_MMS = 10158, + ATOM_MULTI_USER_INFO = 10160, + ATOM_NETWORK_BPF_MAP_INFO = 10161, + ATOM_OUTGOING_SHORT_CODE_SMS = 10162, + ATOM_CONNECTIVITY_STATE_SAMPLE = 10163, + ATOM_NETWORK_SELECTION_REMATCH_REASONS_INFO = 10164, + ATOM_GAME_MODE_INFO = 10165, + ATOM_GAME_MODE_CONFIGURATION = 10166, + ATOM_GAME_MODE_LISTENER = 10167, + ATOM_NETWORK_SLICE_REQUEST_COUNT = 10168, + ATOM_WS_TILE_SNAPSHOT = 10169, + ATOM_WS_ACTIVE_WATCH_FACE_COMPLICATION_SET_SNAPSHOT = 10170, + ATOM_PROCESS_STATE = 10171, + ATOM_PROCESS_ASSOCIATION = 10172, + ATOM_ADPF_SYSTEM_COMPONENT_INFO = 10173, + ATOM_NOTIFICATION_MEMORY_USE = 10174, + ATOM_HDR_CAPABILITIES = 10175, + ATOM_WS_FAVOURITE_WATCH_FACE_LIST_SNAPSHOT = 10176, + ATOM_WIFI_AWARE_NDP_REPORTED = 638, + ATOM_WIFI_AWARE_ATTACH_REPORTED = 639, + ATOM_WIFI_SELF_RECOVERY_TRIGGERED = 661, + ATOM_SOFT_AP_STARTED = 680, + ATOM_SOFT_AP_STOPPED = 681, + ATOM_WIFI_LOCK_RELEASED = 687, + ATOM_WIFI_LOCK_DEACTIVATED = 688, + ATOM_WIFI_CONFIG_SAVED = 689, + ATOM_WIFI_AWARE_RESOURCE_USING_CHANGED = 690, + ATOM_WIFI_AWARE_HAL_API_CALLED = 691, + ATOM_WIFI_LOCAL_ONLY_REQUEST_RECEIVED = 692, + ATOM_WIFI_LOCAL_ONLY_REQUEST_SCAN_TRIGGERED = 693, + ATOM_WIFI_THREAD_TASK_EXECUTED = 694, + ATOM_WIFI_STATE_CHANGED = 700, + ATOM_WIFI_AWARE_CAPABILITIES = 10190, + ATOM_WIFI_MODULE_INFO = 10193, + ATOM_SETTINGS_SPA_REPORTED = 622, + ATOM_EXPRESS_EVENT_REPORTED = 528, + ATOM_EXPRESS_HISTOGRAM_SAMPLE_REPORTED = 593, + ATOM_EXPRESS_UID_EVENT_REPORTED = 644, + ATOM_EXPRESS_UID_HISTOGRAM_SAMPLE_REPORTED = 658, + ATOM_PERMISSION_RATIONALE_DIALOG_VIEWED = 645, + ATOM_PERMISSION_RATIONALE_DIALOG_ACTION_REPORTED = 646, + ATOM_APP_DATA_SHARING_UPDATES_NOTIFICATION_INTERACTION = 647, + ATOM_APP_DATA_SHARING_UPDATES_FRAGMENT_VIEWED = 648, + ATOM_APP_DATA_SHARING_UPDATES_FRAGMENT_ACTION_REPORTED = 649, + ATOM_WS_INCOMING_CALL_ACTION_REPORTED = 626, + ATOM_WS_CALL_DISCONNECTION_REPORTED = 627, + ATOM_WS_CALL_DURATION_REPORTED = 628, + ATOM_WS_CALL_USER_EXPERIENCE_LATENCY_REPORTED = 629, + ATOM_WS_CALL_INTERACTION_REPORTED = 630, + ATOM_FULL_SCREEN_INTENT_LAUNCHED = 631, + ATOM_BAL_ALLOWED = 632, + ATOM_IN_TASK_ACTIVITY_STARTED = 685, + ATOM_CACHED_APPS_HIGH_WATERMARK = 10189, + ATOM_ODREFRESH_REPORTED = 366, + ATOM_ODSIGN_REPORTED = 548, + ATOM_ART_DATUM_REPORTED = 332, + ATOM_ART_DEVICE_DATUM_REPORTED = 550, + ATOM_ART_DATUM_DELTA_REPORTED = 565, + ATOM_BACKGROUND_DEXOPT_JOB_ENDED = 467, + ATOM_WEAR_ADAPTIVE_SUSPEND_STATS_REPORTED = 619, + ATOM_WEAR_POWER_ANOMALY_SERVICE_OPERATIONAL_STATS_REPORTED = 620, + ATOM_WEAR_POWER_ANOMALY_SERVICE_EVENT_STATS_REPORTED = 621, + ATOM_EMERGENCY_STATE_CHANGED = 633, + ATOM_DND_STATE_CHANGED = 657, + ATOM_MTE_STATE = 10181, + ATOM_AD_SERVICES_BACK_COMPAT_GET_TOPICS_REPORTED = 598, + ATOM_AD_SERVICES_BACK_COMPAT_EPOCH_COMPUTATION_CLASSIFIER_REPORTED = 599, + ATOM_AD_SERVICES_MEASUREMENT_DEBUG_KEYS = 640, + ATOM_AD_SERVICES_ERROR_REPORTED = 662, + ATOM_AD_SERVICES_BACKGROUND_JOBS_EXECUTION_REPORTED = 663, + ATOM_AD_SERVICES_MEASUREMENT_DELAYED_SOURCE_REGISTRATION = 673, + ATOM_AD_SERVICES_MEASUREMENT_ATTRIBUTION = 674, + ATOM_AD_SERVICES_MEASUREMENT_JOBS = 675, + ATOM_AD_SERVICES_MEASUREMENT_WIPEOUT = 676, + ATOM_AD_SERVICES_CONSENT_MIGRATED = 702, + ATOM_RKPD_POOL_STATS = 664, + ATOM_RKPD_CLIENT_OPERATION = 665, + ATOM_AUTOFILL_UI_EVENT_REPORTED = 603, + ATOM_AUTOFILL_FILL_REQUEST_REPORTED = 604, + ATOM_AUTOFILL_FILL_RESPONSE_REPORTED = 605, + ATOM_AUTOFILL_SAVE_EVENT_REPORTED = 606, + ATOM_AUTOFILL_SESSION_COMMITTED = 607, + ATOM_AUTOFILL_FIELD_CLASSIFICATION_EVENT_REPORTED = 659, + ATOM_TEST_EXTENSION_ATOM_REPORTED = 660, + ATOM_TEST_RESTRICTED_ATOM_REPORTED = 672, + ATOM_STATS_SOCKET_LOSS_REPORTED = 752, + ATOM_PLUGIN_INITIALIZED = 655, + ATOM_TV_LOW_POWER_STANDBY_POLICY = 679, + ATOM_LOCKSCREEN_SHORTCUT_SELECTED = 611, + ATOM_LOCKSCREEN_SHORTCUT_TRIGGERED = 612, + ATOM_EMERGENCY_NUMBERS_INFO = 10180, + ATOM_QUALIFIED_RAT_LIST_CHANGED = 634, + ATOM_QNS_IMS_CALL_DROP_STATS = 635, + ATOM_QNS_FALLBACK_RESTRICTION_CHANGED = 636, + ATOM_QNS_RAT_PREFERENCE_MISMATCH_INFO = 10177, + ATOM_QNS_HANDOVER_TIME_MILLIS = 10178, + ATOM_QNS_HANDOVER_PINGPONG = 10179, + ATOM_SATELLITE_CONTROLLER = 10182, + ATOM_SATELLITE_SESSION = 10183, + ATOM_SATELLITE_INCOMING_DATAGRAM = 10184, + ATOM_SATELLITE_OUTGOING_DATAGRAM = 10185, + ATOM_SATELLITE_PROVISION = 10186, + ATOM_SATELLITE_SOS_MESSAGE_RECOMMENDER = 10187, + ATOM_IKE_SESSION_TERMINATED = 678, + ATOM_IKE_LIVENESS_CHECK_SESSION_VALIDATED = 760, + ATOM_BLUETOOTH_HASHED_DEVICE_NAME_REPORTED = 613, + ATOM_BLUETOOTH_L2CAP_COC_CLIENT_CONNECTION = 614, + ATOM_BLUETOOTH_L2CAP_COC_SERVER_CONNECTION = 615, + ATOM_BLUETOOTH_LE_SESSION_CONNECTED = 656, + ATOM_RESTRICTED_BLUETOOTH_DEVICE_NAME_REPORTED = 666, + ATOM_BLUETOOTH_PROFILE_CONNECTION_ATTEMPTED = 696, + ATOM_HEALTH_CONNECT_UI_IMPRESSION = 623, + ATOM_HEALTH_CONNECT_UI_INTERACTION = 624, + ATOM_HEALTH_CONNECT_APP_OPENED_REPORTED = 625, + ATOM_HEALTH_CONNECT_API_CALLED = 616, + ATOM_HEALTH_CONNECT_USAGE_STATS = 617, + ATOM_HEALTH_CONNECT_STORAGE_STATS = 618, + ATOM_HEALTH_CONNECT_API_INVOKED = 643, + ATOM_EXERCISE_ROUTE_API_CALLED = 654, + ATOM_ATOM_9999 = 9999, + ATOM_ATOM_99999 = 99999, + ATOM_THREADNETWORK_TELEMETRY_DATA_REPORTED = 738, + ATOM_THREADNETWORK_TOPO_ENTRY_REPEATED = 739, + ATOM_THREADNETWORK_DEVICE_INFO_REPORTED = 740, + ATOM_EMERGENCY_NUMBER_DIALED = 637, + ATOM_SANDBOX_API_CALLED = 488, + ATOM_SANDBOX_ACTIVITY_EVENT_OCCURRED = 735, + ATOM_SANDBOX_SDK_STORAGE = 10159, + ATOM_CRONET_ENGINE_CREATED = 703, + ATOM_CRONET_TRAFFIC_REPORTED = 704, + ATOM_CRONET_ENGINE_BUILDER_INITIALIZED = 762, + ATOM_CRONET_HTTP_FLAGS_INITIALIZED = 763, + ATOM_CRONET_INITIALIZED = 764, + ATOM_DAILY_KEEPALIVE_INFO_REPORTED = 650, + ATOM_IP_CLIENT_RA_INFO_REPORTED = 778, + ATOM_APF_SESSION_INFO_REPORTED = 777, + ATOM_CREDENTIAL_MANAGER_API_CALLED = 585, + ATOM_CREDENTIAL_MANAGER_INIT_PHASE_REPORTED = 651, + ATOM_CREDENTIAL_MANAGER_CANDIDATE_PHASE_REPORTED = 652, + ATOM_CREDENTIAL_MANAGER_FINAL_PHASE_REPORTED = 653, + ATOM_CREDENTIAL_MANAGER_TOTAL_REPORTED = 667, + ATOM_CREDENTIAL_MANAGER_FINALNOUID_REPORTED = 668, + ATOM_CREDENTIAL_MANAGER_GET_REPORTED = 669, + ATOM_CREDENTIAL_MANAGER_AUTH_CLICK_REPORTED = 670, + ATOM_CREDENTIAL_MANAGER_APIV2_CALLED = 671, + ATOM_UWB_ACTIVITY_INFO = 10188, + ATOM_MEDIA_ACTION_REPORTED = 608, + ATOM_MEDIA_CONTROLS_LAUNCHED = 609, + ATOM_MEDIA_CODEC_RECLAIM_REQUEST_COMPLETED = 600, + ATOM_MEDIA_CODEC_STARTED = 641, + ATOM_MEDIA_CODEC_STOPPED = 642, + ATOM_MEDIA_CODEC_RENDERED = 684, +}; + +constexpr AtomId AtomId_MIN = AtomId::ATOM_UNSPECIFIED; +constexpr AtomId AtomId_MAX = AtomId::ATOM_ATOM_99999; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* AtomId_Name(::perfetto::protos::pbzero::AtomId value) { + switch (value) { + case ::perfetto::protos::pbzero::AtomId::ATOM_UNSPECIFIED: + return "ATOM_UNSPECIFIED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BLE_SCAN_STATE_CHANGED: + return "ATOM_BLE_SCAN_STATE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_PROCESS_STATE_CHANGED: + return "ATOM_PROCESS_STATE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BLE_SCAN_RESULT_RECEIVED: + return "ATOM_BLE_SCAN_RESULT_RECEIVED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_SENSOR_STATE_CHANGED: + return "ATOM_SENSOR_STATE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_GPS_SCAN_STATE_CHANGED: + return "ATOM_GPS_SCAN_STATE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_SYNC_STATE_CHANGED: + return "ATOM_SYNC_STATE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_SCHEDULED_JOB_STATE_CHANGED: + return "ATOM_SCHEDULED_JOB_STATE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_SCREEN_BRIGHTNESS_CHANGED: + return "ATOM_SCREEN_BRIGHTNESS_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_WAKELOCK_STATE_CHANGED: + return "ATOM_WAKELOCK_STATE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_LONG_PARTIAL_WAKELOCK_STATE_CHANGED: + return "ATOM_LONG_PARTIAL_WAKELOCK_STATE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_MOBILE_RADIO_POWER_STATE_CHANGED: + return "ATOM_MOBILE_RADIO_POWER_STATE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_RADIO_POWER_STATE_CHANGED: + return "ATOM_WIFI_RADIO_POWER_STATE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_ACTIVITY_MANAGER_SLEEP_STATE_CHANGED: + return "ATOM_ACTIVITY_MANAGER_SLEEP_STATE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_MEMORY_FACTOR_STATE_CHANGED: + return "ATOM_MEMORY_FACTOR_STATE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_EXCESSIVE_CPU_USAGE_REPORTED: + return "ATOM_EXCESSIVE_CPU_USAGE_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_CACHED_KILL_REPORTED: + return "ATOM_CACHED_KILL_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_PROCESS_MEMORY_STAT_REPORTED: + return "ATOM_PROCESS_MEMORY_STAT_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_LAUNCHER_EVENT: + return "ATOM_LAUNCHER_EVENT"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BATTERY_SAVER_MODE_STATE_CHANGED: + return "ATOM_BATTERY_SAVER_MODE_STATE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_DEVICE_IDLE_MODE_STATE_CHANGED: + return "ATOM_DEVICE_IDLE_MODE_STATE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_DEVICE_IDLING_MODE_STATE_CHANGED: + return "ATOM_DEVICE_IDLING_MODE_STATE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_AUDIO_STATE_CHANGED: + return "ATOM_AUDIO_STATE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIA_CODEC_STATE_CHANGED: + return "ATOM_MEDIA_CODEC_STATE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_CAMERA_STATE_CHANGED: + return "ATOM_CAMERA_STATE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_FLASHLIGHT_STATE_CHANGED: + return "ATOM_FLASHLIGHT_STATE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_UID_PROCESS_STATE_CHANGED: + return "ATOM_UID_PROCESS_STATE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_PROCESS_LIFE_CYCLE_STATE_CHANGED: + return "ATOM_PROCESS_LIFE_CYCLE_STATE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_SCREEN_STATE_CHANGED: + return "ATOM_SCREEN_STATE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BATTERY_LEVEL_CHANGED: + return "ATOM_BATTERY_LEVEL_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_CHARGING_STATE_CHANGED: + return "ATOM_CHARGING_STATE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_PLUGGED_STATE_CHANGED: + return "ATOM_PLUGGED_STATE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_INTERACTIVE_STATE_CHANGED: + return "ATOM_INTERACTIVE_STATE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_TOUCH_EVENT_REPORTED: + return "ATOM_TOUCH_EVENT_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_WAKEUP_ALARM_OCCURRED: + return "ATOM_WAKEUP_ALARM_OCCURRED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_KERNEL_WAKEUP_REPORTED: + return "ATOM_KERNEL_WAKEUP_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_LOCK_STATE_CHANGED: + return "ATOM_WIFI_LOCK_STATE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_SIGNAL_STRENGTH_CHANGED: + return "ATOM_WIFI_SIGNAL_STRENGTH_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_SCAN_STATE_CHANGED: + return "ATOM_WIFI_SCAN_STATE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_PHONE_SIGNAL_STRENGTH_CHANGED: + return "ATOM_PHONE_SIGNAL_STRENGTH_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_SETTING_CHANGED: + return "ATOM_SETTING_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_ACTIVITY_FOREGROUND_STATE_CHANGED: + return "ATOM_ACTIVITY_FOREGROUND_STATE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_ISOLATED_UID_CHANGED: + return "ATOM_ISOLATED_UID_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_PACKET_WAKEUP_OCCURRED: + return "ATOM_PACKET_WAKEUP_OCCURRED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_WALL_CLOCK_TIME_SHIFTED: + return "ATOM_WALL_CLOCK_TIME_SHIFTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_ANOMALY_DETECTED: + return "ATOM_ANOMALY_DETECTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_APP_BREADCRUMB_REPORTED: + return "ATOM_APP_BREADCRUMB_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_APP_START_OCCURRED: + return "ATOM_APP_START_OCCURRED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_APP_START_CANCELED: + return "ATOM_APP_START_CANCELED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_APP_START_FULLY_DRAWN: + return "ATOM_APP_START_FULLY_DRAWN"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_LMK_KILL_OCCURRED: + return "ATOM_LMK_KILL_OCCURRED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_PICTURE_IN_PICTURE_STATE_CHANGED: + return "ATOM_PICTURE_IN_PICTURE_STATE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_MULTICAST_LOCK_STATE_CHANGED: + return "ATOM_WIFI_MULTICAST_LOCK_STATE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_LMK_STATE_CHANGED: + return "ATOM_LMK_STATE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_APP_START_MEMORY_STATE_CAPTURED: + return "ATOM_APP_START_MEMORY_STATE_CAPTURED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_SHUTDOWN_SEQUENCE_REPORTED: + return "ATOM_SHUTDOWN_SEQUENCE_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BOOT_SEQUENCE_REPORTED: + return "ATOM_BOOT_SEQUENCE_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_DAVEY_OCCURRED: + return "ATOM_DAVEY_OCCURRED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_OVERLAY_STATE_CHANGED: + return "ATOM_OVERLAY_STATE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_FOREGROUND_SERVICE_STATE_CHANGED: + return "ATOM_FOREGROUND_SERVICE_STATE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_CALL_STATE_CHANGED: + return "ATOM_CALL_STATE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_KEYGUARD_STATE_CHANGED: + return "ATOM_KEYGUARD_STATE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_KEYGUARD_BOUNCER_STATE_CHANGED: + return "ATOM_KEYGUARD_BOUNCER_STATE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_KEYGUARD_BOUNCER_PASSWORD_ENTERED: + return "ATOM_KEYGUARD_BOUNCER_PASSWORD_ENTERED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_APP_DIED: + return "ATOM_APP_DIED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_RESOURCE_CONFIGURATION_CHANGED: + return "ATOM_RESOURCE_CONFIGURATION_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_ENABLED_STATE_CHANGED: + return "ATOM_BLUETOOTH_ENABLED_STATE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_CONNECTION_STATE_CHANGED: + return "ATOM_BLUETOOTH_CONNECTION_STATE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_GPS_SIGNAL_QUALITY_CHANGED: + return "ATOM_GPS_SIGNAL_QUALITY_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_USB_CONNECTOR_STATE_CHANGED: + return "ATOM_USB_CONNECTOR_STATE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_SPEAKER_IMPEDANCE_REPORTED: + return "ATOM_SPEAKER_IMPEDANCE_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_HARDWARE_FAILED: + return "ATOM_HARDWARE_FAILED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_PHYSICAL_DROP_DETECTED: + return "ATOM_PHYSICAL_DROP_DETECTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_CHARGE_CYCLES_REPORTED: + return "ATOM_CHARGE_CYCLES_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_MOBILE_CONNECTION_STATE_CHANGED: + return "ATOM_MOBILE_CONNECTION_STATE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_MOBILE_RADIO_TECHNOLOGY_CHANGED: + return "ATOM_MOBILE_RADIO_TECHNOLOGY_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_USB_DEVICE_ATTACHED: + return "ATOM_USB_DEVICE_ATTACHED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_APP_CRASH_OCCURRED: + return "ATOM_APP_CRASH_OCCURRED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_ANR_OCCURRED: + return "ATOM_ANR_OCCURRED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_WTF_OCCURRED: + return "ATOM_WTF_OCCURRED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_LOW_MEM_REPORTED: + return "ATOM_LOW_MEM_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_GENERIC_ATOM: + return "ATOM_GENERIC_ATOM"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_VIBRATOR_STATE_CHANGED: + return "ATOM_VIBRATOR_STATE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_DEFERRED_JOB_STATS_REPORTED: + return "ATOM_DEFERRED_JOB_STATS_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_THERMAL_THROTTLING: + return "ATOM_THERMAL_THROTTLING"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BIOMETRIC_ACQUIRED: + return "ATOM_BIOMETRIC_ACQUIRED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BIOMETRIC_AUTHENTICATED: + return "ATOM_BIOMETRIC_AUTHENTICATED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BIOMETRIC_ERROR_OCCURRED: + return "ATOM_BIOMETRIC_ERROR_OCCURRED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_UI_EVENT_REPORTED: + return "ATOM_UI_EVENT_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BATTERY_HEALTH_SNAPSHOT: + return "ATOM_BATTERY_HEALTH_SNAPSHOT"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_SLOW_IO: + return "ATOM_SLOW_IO"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BATTERY_CAUSED_SHUTDOWN: + return "ATOM_BATTERY_CAUSED_SHUTDOWN"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_PHONE_SERVICE_STATE_CHANGED: + return "ATOM_PHONE_SERVICE_STATE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_PHONE_STATE_CHANGED: + return "ATOM_PHONE_STATE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_USER_RESTRICTION_CHANGED: + return "ATOM_USER_RESTRICTION_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_SETTINGS_UI_CHANGED: + return "ATOM_SETTINGS_UI_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_CONNECTIVITY_STATE_CHANGED: + return "ATOM_CONNECTIVITY_STATE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_SERVICE_STATE_CHANGED: + return "ATOM_SERVICE_STATE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_SERVICE_LAUNCH_REPORTED: + return "ATOM_SERVICE_LAUNCH_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_FLAG_FLIP_UPDATE_OCCURRED: + return "ATOM_FLAG_FLIP_UPDATE_OCCURRED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BINARY_PUSH_STATE_CHANGED: + return "ATOM_BINARY_PUSH_STATE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_DEVICE_POLICY_EVENT: + return "ATOM_DEVICE_POLICY_EVENT"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_DOCS_UI_FILE_OP_CANCELED: + return "ATOM_DOCS_UI_FILE_OP_CANCELED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_DOCS_UI_FILE_OP_COPY_MOVE_MODE_REPORTED: + return "ATOM_DOCS_UI_FILE_OP_COPY_MOVE_MODE_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_DOCS_UI_FILE_OP_FAILURE: + return "ATOM_DOCS_UI_FILE_OP_FAILURE"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_DOCS_UI_PROVIDER_FILE_OP: + return "ATOM_DOCS_UI_PROVIDER_FILE_OP"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_DOCS_UI_INVALID_SCOPED_ACCESS_REQUEST: + return "ATOM_DOCS_UI_INVALID_SCOPED_ACCESS_REQUEST"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_DOCS_UI_LAUNCH_REPORTED: + return "ATOM_DOCS_UI_LAUNCH_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_DOCS_UI_ROOT_VISITED: + return "ATOM_DOCS_UI_ROOT_VISITED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_DOCS_UI_STARTUP_MS: + return "ATOM_DOCS_UI_STARTUP_MS"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_DOCS_UI_USER_ACTION_REPORTED: + return "ATOM_DOCS_UI_USER_ACTION_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_ENABLED_STATE_CHANGED: + return "ATOM_WIFI_ENABLED_STATE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_RUNNING_STATE_CHANGED: + return "ATOM_WIFI_RUNNING_STATE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_APP_COMPACTED: + return "ATOM_APP_COMPACTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_NETWORK_DNS_EVENT_REPORTED: + return "ATOM_NETWORK_DNS_EVENT_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_DOCS_UI_PICKER_LAUNCHED_FROM_REPORTED: + return "ATOM_DOCS_UI_PICKER_LAUNCHED_FROM_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_DOCS_UI_PICK_RESULT_REPORTED: + return "ATOM_DOCS_UI_PICK_RESULT_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_DOCS_UI_SEARCH_MODE_REPORTED: + return "ATOM_DOCS_UI_SEARCH_MODE_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_DOCS_UI_SEARCH_TYPE_REPORTED: + return "ATOM_DOCS_UI_SEARCH_TYPE_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_DATA_STALL_EVENT: + return "ATOM_DATA_STALL_EVENT"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_RESCUE_PARTY_RESET_REPORTED: + return "ATOM_RESCUE_PARTY_RESET_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_SIGNED_CONFIG_REPORTED: + return "ATOM_SIGNED_CONFIG_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_GNSS_NI_EVENT_REPORTED: + return "ATOM_GNSS_NI_EVENT_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_LINK_LAYER_CONNECTION_EVENT: + return "ATOM_BLUETOOTH_LINK_LAYER_CONNECTION_EVENT"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_ACL_CONNECTION_STATE_CHANGED: + return "ATOM_BLUETOOTH_ACL_CONNECTION_STATE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_SCO_CONNECTION_STATE_CHANGED: + return "ATOM_BLUETOOTH_SCO_CONNECTION_STATE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_APP_DOWNGRADED: + return "ATOM_APP_DOWNGRADED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_APP_OPTIMIZED_AFTER_DOWNGRADED: + return "ATOM_APP_OPTIMIZED_AFTER_DOWNGRADED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_LOW_STORAGE_STATE_CHANGED: + return "ATOM_LOW_STORAGE_STATE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_GNSS_NFW_NOTIFICATION_REPORTED: + return "ATOM_GNSS_NFW_NOTIFICATION_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_GNSS_CONFIGURATION_REPORTED: + return "ATOM_GNSS_CONFIGURATION_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_USB_PORT_OVERHEAT_EVENT_REPORTED: + return "ATOM_USB_PORT_OVERHEAT_EVENT_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_NFC_ERROR_OCCURRED: + return "ATOM_NFC_ERROR_OCCURRED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_NFC_STATE_CHANGED: + return "ATOM_NFC_STATE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_NFC_BEAM_OCCURRED: + return "ATOM_NFC_BEAM_OCCURRED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_NFC_CARDEMULATION_OCCURRED: + return "ATOM_NFC_CARDEMULATION_OCCURRED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_NFC_TAG_OCCURRED: + return "ATOM_NFC_TAG_OCCURRED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_NFC_HCE_TRANSACTION_OCCURRED: + return "ATOM_NFC_HCE_TRANSACTION_OCCURRED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_SE_STATE_CHANGED: + return "ATOM_SE_STATE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_SE_OMAPI_REPORTED: + return "ATOM_SE_OMAPI_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BROADCAST_DISPATCH_LATENCY_REPORTED: + return "ATOM_BROADCAST_DISPATCH_LATENCY_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_ATTENTION_MANAGER_SERVICE_RESULT_REPORTED: + return "ATOM_ATTENTION_MANAGER_SERVICE_RESULT_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_ADB_CONNECTION_CHANGED: + return "ATOM_ADB_CONNECTION_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_SPEECH_DSP_STAT_REPORTED: + return "ATOM_SPEECH_DSP_STAT_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_USB_CONTAMINANT_REPORTED: + return "ATOM_USB_CONTAMINANT_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_WATCHDOG_ROLLBACK_OCCURRED: + return "ATOM_WATCHDOG_ROLLBACK_OCCURRED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BIOMETRIC_SYSTEM_HEALTH_ISSUE_DETECTED: + return "ATOM_BIOMETRIC_SYSTEM_HEALTH_ISSUE_DETECTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BUBBLE_UI_CHANGED: + return "ATOM_BUBBLE_UI_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_SCHEDULED_JOB_CONSTRAINT_CHANGED: + return "ATOM_SCHEDULED_JOB_CONSTRAINT_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_ACTIVE_DEVICE_CHANGED: + return "ATOM_BLUETOOTH_ACTIVE_DEVICE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_A2DP_PLAYBACK_STATE_CHANGED: + return "ATOM_BLUETOOTH_A2DP_PLAYBACK_STATE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_A2DP_CODEC_CONFIG_CHANGED: + return "ATOM_BLUETOOTH_A2DP_CODEC_CONFIG_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_A2DP_CODEC_CAPABILITY_CHANGED: + return "ATOM_BLUETOOTH_A2DP_CODEC_CAPABILITY_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_A2DP_AUDIO_UNDERRUN_REPORTED: + return "ATOM_BLUETOOTH_A2DP_AUDIO_UNDERRUN_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_A2DP_AUDIO_OVERRUN_REPORTED: + return "ATOM_BLUETOOTH_A2DP_AUDIO_OVERRUN_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_DEVICE_RSSI_REPORTED: + return "ATOM_BLUETOOTH_DEVICE_RSSI_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_DEVICE_FAILED_CONTACT_COUNTER_REPORTED: + return "ATOM_BLUETOOTH_DEVICE_FAILED_CONTACT_COUNTER_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_DEVICE_TX_POWER_LEVEL_REPORTED: + return "ATOM_BLUETOOTH_DEVICE_TX_POWER_LEVEL_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_HCI_TIMEOUT_REPORTED: + return "ATOM_BLUETOOTH_HCI_TIMEOUT_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_QUALITY_REPORT_REPORTED: + return "ATOM_BLUETOOTH_QUALITY_REPORT_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_DEVICE_INFO_REPORTED: + return "ATOM_BLUETOOTH_DEVICE_INFO_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_REMOTE_VERSION_INFO_REPORTED: + return "ATOM_BLUETOOTH_REMOTE_VERSION_INFO_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_SDP_ATTRIBUTE_REPORTED: + return "ATOM_BLUETOOTH_SDP_ATTRIBUTE_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_BOND_STATE_CHANGED: + return "ATOM_BLUETOOTH_BOND_STATE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_CLASSIC_PAIRING_EVENT_REPORTED: + return "ATOM_BLUETOOTH_CLASSIC_PAIRING_EVENT_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_SMP_PAIRING_EVENT_REPORTED: + return "ATOM_BLUETOOTH_SMP_PAIRING_EVENT_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_SCREEN_TIMEOUT_EXTENSION_REPORTED: + return "ATOM_SCREEN_TIMEOUT_EXTENSION_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_PROCESS_START_TIME: + return "ATOM_PROCESS_START_TIME"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_PERMISSION_GRANT_REQUEST_RESULT_REPORTED: + return "ATOM_PERMISSION_GRANT_REQUEST_RESULT_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_SOCKET_CONNECTION_STATE_CHANGED: + return "ATOM_BLUETOOTH_SOCKET_CONNECTION_STATE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_DEVICE_IDENTIFIER_ACCESS_DENIED: + return "ATOM_DEVICE_IDENTIFIER_ACCESS_DENIED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BUBBLE_DEVELOPER_ERROR_REPORTED: + return "ATOM_BUBBLE_DEVELOPER_ERROR_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_ASSIST_GESTURE_STAGE_REPORTED: + return "ATOM_ASSIST_GESTURE_STAGE_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_ASSIST_GESTURE_FEEDBACK_REPORTED: + return "ATOM_ASSIST_GESTURE_FEEDBACK_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_ASSIST_GESTURE_PROGRESS_REPORTED: + return "ATOM_ASSIST_GESTURE_PROGRESS_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_TOUCH_GESTURE_CLASSIFIED: + return "ATOM_TOUCH_GESTURE_CLASSIFIED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_HIDDEN_API_USED: + return "ATOM_HIDDEN_API_USED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_STYLE_UI_CHANGED: + return "ATOM_STYLE_UI_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_PRIVACY_INDICATORS_INTERACTED: + return "ATOM_PRIVACY_INDICATORS_INTERACTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_APP_INSTALL_ON_EXTERNAL_STORAGE_REPORTED: + return "ATOM_APP_INSTALL_ON_EXTERNAL_STORAGE_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_NETWORK_STACK_REPORTED: + return "ATOM_NETWORK_STACK_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_APP_MOVED_STORAGE_REPORTED: + return "ATOM_APP_MOVED_STORAGE_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BIOMETRIC_ENROLLED: + return "ATOM_BIOMETRIC_ENROLLED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_SYSTEM_SERVER_WATCHDOG_OCCURRED: + return "ATOM_SYSTEM_SERVER_WATCHDOG_OCCURRED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_TOMB_STONE_OCCURRED: + return "ATOM_TOMB_STONE_OCCURRED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_CLASS_OF_DEVICE_REPORTED: + return "ATOM_BLUETOOTH_CLASS_OF_DEVICE_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_INTELLIGENCE_EVENT_REPORTED: + return "ATOM_INTELLIGENCE_EVENT_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_THERMAL_THROTTLING_SEVERITY_STATE_CHANGED: + return "ATOM_THERMAL_THROTTLING_SEVERITY_STATE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_ROLE_REQUEST_RESULT_REPORTED: + return "ATOM_ROLE_REQUEST_RESULT_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIAMETRICS_AUDIOPOLICY_REPORTED: + return "ATOM_MEDIAMETRICS_AUDIOPOLICY_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIAMETRICS_AUDIORECORD_REPORTED: + return "ATOM_MEDIAMETRICS_AUDIORECORD_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIAMETRICS_AUDIOTHREAD_REPORTED: + return "ATOM_MEDIAMETRICS_AUDIOTHREAD_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIAMETRICS_AUDIOTRACK_REPORTED: + return "ATOM_MEDIAMETRICS_AUDIOTRACK_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIAMETRICS_CODEC_REPORTED: + return "ATOM_MEDIAMETRICS_CODEC_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIAMETRICS_DRM_WIDEVINE_REPORTED: + return "ATOM_MEDIAMETRICS_DRM_WIDEVINE_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIAMETRICS_EXTRACTOR_REPORTED: + return "ATOM_MEDIAMETRICS_EXTRACTOR_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIAMETRICS_MEDIADRM_REPORTED: + return "ATOM_MEDIAMETRICS_MEDIADRM_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIAMETRICS_NUPLAYER_REPORTED: + return "ATOM_MEDIAMETRICS_NUPLAYER_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIAMETRICS_RECORDER_REPORTED: + return "ATOM_MEDIAMETRICS_RECORDER_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIAMETRICS_DRMMANAGER_REPORTED: + return "ATOM_MEDIAMETRICS_DRMMANAGER_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_CAR_POWER_STATE_CHANGED: + return "ATOM_CAR_POWER_STATE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_GARAGE_MODE_INFO: + return "ATOM_GARAGE_MODE_INFO"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_TEST_ATOM_REPORTED: + return "ATOM_TEST_ATOM_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_CONTENT_CAPTURE_CALLER_MISMATCH_REPORTED: + return "ATOM_CONTENT_CAPTURE_CALLER_MISMATCH_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_CONTENT_CAPTURE_SERVICE_EVENTS: + return "ATOM_CONTENT_CAPTURE_SERVICE_EVENTS"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_CONTENT_CAPTURE_SESSION_EVENTS: + return "ATOM_CONTENT_CAPTURE_SESSION_EVENTS"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_CONTENT_CAPTURE_FLUSHED: + return "ATOM_CONTENT_CAPTURE_FLUSHED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_LOCATION_MANAGER_API_USAGE_REPORTED: + return "ATOM_LOCATION_MANAGER_API_USAGE_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_REVIEW_PERMISSIONS_FRAGMENT_RESULT_REPORTED: + return "ATOM_REVIEW_PERMISSIONS_FRAGMENT_RESULT_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_RUNTIME_PERMISSIONS_UPGRADE_RESULT: + return "ATOM_RUNTIME_PERMISSIONS_UPGRADE_RESULT"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_GRANT_PERMISSIONS_ACTIVITY_BUTTON_ACTIONS: + return "ATOM_GRANT_PERMISSIONS_ACTIVITY_BUTTON_ACTIONS"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_LOCATION_ACCESS_CHECK_NOTIFICATION_ACTION: + return "ATOM_LOCATION_ACCESS_CHECK_NOTIFICATION_ACTION"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_APP_PERMISSION_FRAGMENT_ACTION_REPORTED: + return "ATOM_APP_PERMISSION_FRAGMENT_ACTION_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_APP_PERMISSION_FRAGMENT_VIEWED: + return "ATOM_APP_PERMISSION_FRAGMENT_VIEWED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_APP_PERMISSIONS_FRAGMENT_VIEWED: + return "ATOM_APP_PERMISSIONS_FRAGMENT_VIEWED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_PERMISSION_APPS_FRAGMENT_VIEWED: + return "ATOM_PERMISSION_APPS_FRAGMENT_VIEWED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_TEXT_SELECTION_EVENT: + return "ATOM_TEXT_SELECTION_EVENT"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_TEXT_LINKIFY_EVENT: + return "ATOM_TEXT_LINKIFY_EVENT"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_CONVERSATION_ACTIONS_EVENT: + return "ATOM_CONVERSATION_ACTIONS_EVENT"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_LANGUAGE_DETECTION_EVENT: + return "ATOM_LANGUAGE_DETECTION_EVENT"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_EXCLUSION_RECT_STATE_CHANGED: + return "ATOM_EXCLUSION_RECT_STATE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BACK_GESTURE_REPORTED_REPORTED: + return "ATOM_BACK_GESTURE_REPORTED_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_UPDATE_ENGINE_UPDATE_ATTEMPT_REPORTED: + return "ATOM_UPDATE_ENGINE_UPDATE_ATTEMPT_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_UPDATE_ENGINE_SUCCESSFUL_UPDATE_REPORTED: + return "ATOM_UPDATE_ENGINE_SUCCESSFUL_UPDATE_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_CAMERA_ACTION_EVENT: + return "ATOM_CAMERA_ACTION_EVENT"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_APP_COMPATIBILITY_CHANGE_REPORTED: + return "ATOM_APP_COMPATIBILITY_CHANGE_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_PERFETTO_UPLOADED: + return "ATOM_PERFETTO_UPLOADED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_VMS_CLIENT_CONNECTION_STATE_CHANGED: + return "ATOM_VMS_CLIENT_CONNECTION_STATE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIA_PROVIDER_SCAN_OCCURRED: + return "ATOM_MEDIA_PROVIDER_SCAN_OCCURRED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIA_CONTENT_DELETED: + return "ATOM_MEDIA_CONTENT_DELETED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIA_PROVIDER_PERMISSION_REQUESTED: + return "ATOM_MEDIA_PROVIDER_PERMISSION_REQUESTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIA_PROVIDER_SCHEMA_CHANGED: + return "ATOM_MEDIA_PROVIDER_SCHEMA_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIA_PROVIDER_IDLE_MAINTENANCE_FINISHED: + return "ATOM_MEDIA_PROVIDER_IDLE_MAINTENANCE_FINISHED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_REBOOT_ESCROW_RECOVERY_REPORTED: + return "ATOM_REBOOT_ESCROW_RECOVERY_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BOOT_TIME_EVENT_DURATION_REPORTED: + return "ATOM_BOOT_TIME_EVENT_DURATION_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BOOT_TIME_EVENT_ELAPSED_TIME_REPORTED: + return "ATOM_BOOT_TIME_EVENT_ELAPSED_TIME_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BOOT_TIME_EVENT_UTC_TIME_REPORTED: + return "ATOM_BOOT_TIME_EVENT_UTC_TIME_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BOOT_TIME_EVENT_ERROR_CODE_REPORTED: + return "ATOM_BOOT_TIME_EVENT_ERROR_CODE_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_USERSPACE_REBOOT_REPORTED: + return "ATOM_USERSPACE_REBOOT_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_NOTIFICATION_REPORTED: + return "ATOM_NOTIFICATION_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_NOTIFICATION_PANEL_REPORTED: + return "ATOM_NOTIFICATION_PANEL_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_NOTIFICATION_CHANNEL_MODIFIED: + return "ATOM_NOTIFICATION_CHANNEL_MODIFIED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_INTEGRITY_CHECK_RESULT_REPORTED: + return "ATOM_INTEGRITY_CHECK_RESULT_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_INTEGRITY_RULES_PUSHED: + return "ATOM_INTEGRITY_RULES_PUSHED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_CB_MESSAGE_REPORTED: + return "ATOM_CB_MESSAGE_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_CB_MESSAGE_ERROR: + return "ATOM_CB_MESSAGE_ERROR"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_HEALTH_STAT_REPORTED: + return "ATOM_WIFI_HEALTH_STAT_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_FAILURE_STAT_REPORTED: + return "ATOM_WIFI_FAILURE_STAT_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_CONNECTION_RESULT_REPORTED: + return "ATOM_WIFI_CONNECTION_RESULT_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_APP_FREEZE_CHANGED: + return "ATOM_APP_FREEZE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_SNAPSHOT_MERGE_REPORTED: + return "ATOM_SNAPSHOT_MERGE_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_FOREGROUND_SERVICE_APP_OP_SESSION_ENDED: + return "ATOM_FOREGROUND_SERVICE_APP_OP_SESSION_ENDED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_DISPLAY_JANK_REPORTED: + return "ATOM_DISPLAY_JANK_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_APP_STANDBY_BUCKET_CHANGED: + return "ATOM_APP_STANDBY_BUCKET_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_SHARESHEET_STARTED: + return "ATOM_SHARESHEET_STARTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_RANKING_SELECTED: + return "ATOM_RANKING_SELECTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_TVSETTINGS_UI_INTERACTED: + return "ATOM_TVSETTINGS_UI_INTERACTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_LAUNCHER_SNAPSHOT: + return "ATOM_LAUNCHER_SNAPSHOT"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_PACKAGE_INSTALLER_V2_REPORTED: + return "ATOM_PACKAGE_INSTALLER_V2_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_USER_LIFECYCLE_JOURNEY_REPORTED: + return "ATOM_USER_LIFECYCLE_JOURNEY_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_USER_LIFECYCLE_EVENT_OCCURRED: + return "ATOM_USER_LIFECYCLE_EVENT_OCCURRED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_ACCESSIBILITY_SHORTCUT_REPORTED: + return "ATOM_ACCESSIBILITY_SHORTCUT_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_ACCESSIBILITY_SERVICE_REPORTED: + return "ATOM_ACCESSIBILITY_SERVICE_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_DOCS_UI_DRAG_AND_DROP_REPORTED: + return "ATOM_DOCS_UI_DRAG_AND_DROP_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_APP_USAGE_EVENT_OCCURRED: + return "ATOM_APP_USAGE_EVENT_OCCURRED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_AUTO_REVOKE_NOTIFICATION_CLICKED: + return "ATOM_AUTO_REVOKE_NOTIFICATION_CLICKED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_AUTO_REVOKE_FRAGMENT_APP_VIEWED: + return "ATOM_AUTO_REVOKE_FRAGMENT_APP_VIEWED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_AUTO_REVOKED_APP_INTERACTION: + return "ATOM_AUTO_REVOKED_APP_INTERACTION"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_APP_PERMISSION_GROUPS_FRAGMENT_AUTO_REVOKE_ACTION: + return "ATOM_APP_PERMISSION_GROUPS_FRAGMENT_AUTO_REVOKE_ACTION"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_EVS_USAGE_STATS_REPORTED: + return "ATOM_EVS_USAGE_STATS_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_AUDIO_POWER_USAGE_DATA_REPORTED: + return "ATOM_AUDIO_POWER_USAGE_DATA_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_TV_TUNER_STATE_CHANGED: + return "ATOM_TV_TUNER_STATE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIAOUTPUT_OP_SWITCH_REPORTED: + return "ATOM_MEDIAOUTPUT_OP_SWITCH_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_CB_MESSAGE_FILTERED: + return "ATOM_CB_MESSAGE_FILTERED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_TV_TUNER_DVR_STATUS: + return "ATOM_TV_TUNER_DVR_STATUS"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_TV_CAS_SESSION_OPEN_STATUS: + return "ATOM_TV_CAS_SESSION_OPEN_STATUS"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_ASSISTANT_INVOCATION_REPORTED: + return "ATOM_ASSISTANT_INVOCATION_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_DISPLAY_WAKE_REPORTED: + return "ATOM_DISPLAY_WAKE_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_CAR_USER_HAL_MODIFY_USER_REQUEST_REPORTED: + return "ATOM_CAR_USER_HAL_MODIFY_USER_REQUEST_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_CAR_USER_HAL_MODIFY_USER_RESPONSE_REPORTED: + return "ATOM_CAR_USER_HAL_MODIFY_USER_RESPONSE_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_CAR_USER_HAL_POST_SWITCH_RESPONSE_REPORTED: + return "ATOM_CAR_USER_HAL_POST_SWITCH_RESPONSE_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_CAR_USER_HAL_INITIAL_USER_INFO_REQUEST_REPORTED: + return "ATOM_CAR_USER_HAL_INITIAL_USER_INFO_REQUEST_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_CAR_USER_HAL_INITIAL_USER_INFO_RESPONSE_REPORTED: + return "ATOM_CAR_USER_HAL_INITIAL_USER_INFO_RESPONSE_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_CAR_USER_HAL_USER_ASSOCIATION_REQUEST_REPORTED: + return "ATOM_CAR_USER_HAL_USER_ASSOCIATION_REQUEST_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_CAR_USER_HAL_SET_USER_ASSOCIATION_RESPONSE_REPORTED: + return "ATOM_CAR_USER_HAL_SET_USER_ASSOCIATION_RESPONSE_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_NETWORK_IP_PROVISIONING_REPORTED: + return "ATOM_NETWORK_IP_PROVISIONING_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_NETWORK_DHCP_RENEW_REPORTED: + return "ATOM_NETWORK_DHCP_RENEW_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_NETWORK_VALIDATION_REPORTED: + return "ATOM_NETWORK_VALIDATION_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_NETWORK_STACK_QUIRK_REPORTED: + return "ATOM_NETWORK_STACK_QUIRK_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIAMETRICS_AUDIORECORDDEVICEUSAGE_REPORTED: + return "ATOM_MEDIAMETRICS_AUDIORECORDDEVICEUSAGE_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIAMETRICS_AUDIOTHREADDEVICEUSAGE_REPORTED: + return "ATOM_MEDIAMETRICS_AUDIOTHREADDEVICEUSAGE_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIAMETRICS_AUDIOTRACKDEVICEUSAGE_REPORTED: + return "ATOM_MEDIAMETRICS_AUDIOTRACKDEVICEUSAGE_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIAMETRICS_AUDIODEVICECONNECTION_REPORTED: + return "ATOM_MEDIAMETRICS_AUDIODEVICECONNECTION_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BLOB_COMMITTED: + return "ATOM_BLOB_COMMITTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BLOB_LEASED: + return "ATOM_BLOB_LEASED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BLOB_OPENED: + return "ATOM_BLOB_OPENED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_CONTACTS_PROVIDER_STATUS_REPORTED: + return "ATOM_CONTACTS_PROVIDER_STATUS_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_KEYSTORE_KEY_EVENT_REPORTED: + return "ATOM_KEYSTORE_KEY_EVENT_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_NETWORK_TETHERING_REPORTED: + return "ATOM_NETWORK_TETHERING_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_IME_TOUCH_REPORTED: + return "ATOM_IME_TOUCH_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_UI_INTERACTION_FRAME_INFO_REPORTED: + return "ATOM_UI_INTERACTION_FRAME_INFO_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_UI_ACTION_LATENCY_REPORTED: + return "ATOM_UI_ACTION_LATENCY_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_DISCONNECT_REPORTED: + return "ATOM_WIFI_DISCONNECT_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_CONNECTION_STATE_CHANGED: + return "ATOM_WIFI_CONNECTION_STATE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_HDMI_CEC_ACTIVE_SOURCE_CHANGED: + return "ATOM_HDMI_CEC_ACTIVE_SOURCE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_HDMI_CEC_MESSAGE_REPORTED: + return "ATOM_HDMI_CEC_MESSAGE_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_AIRPLANE_MODE: + return "ATOM_AIRPLANE_MODE"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_MODEM_RESTART: + return "ATOM_MODEM_RESTART"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_CARRIER_ID_MISMATCH_REPORTED: + return "ATOM_CARRIER_ID_MISMATCH_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_CARRIER_ID_TABLE_UPDATED: + return "ATOM_CARRIER_ID_TABLE_UPDATED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_DATA_STALL_RECOVERY_REPORTED: + return "ATOM_DATA_STALL_RECOVERY_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIAMETRICS_MEDIAPARSER_REPORTED: + return "ATOM_MEDIAMETRICS_MEDIAPARSER_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_TLS_HANDSHAKE_REPORTED: + return "ATOM_TLS_HANDSHAKE_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_TEXT_CLASSIFIER_API_USAGE_REPORTED: + return "ATOM_TEXT_CLASSIFIER_API_USAGE_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_CAR_WATCHDOG_KILL_STATS_REPORTED: + return "ATOM_CAR_WATCHDOG_KILL_STATS_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIAMETRICS_PLAYBACK_REPORTED: + return "ATOM_MEDIAMETRICS_PLAYBACK_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIA_NETWORK_INFO_CHANGED: + return "ATOM_MEDIA_NETWORK_INFO_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIA_PLAYBACK_STATE_CHANGED: + return "ATOM_MEDIA_PLAYBACK_STATE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIA_PLAYBACK_ERROR_REPORTED: + return "ATOM_MEDIA_PLAYBACK_ERROR_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIA_PLAYBACK_TRACK_CHANGED: + return "ATOM_MEDIA_PLAYBACK_TRACK_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_SCAN_REPORTED: + return "ATOM_WIFI_SCAN_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_PNO_SCAN_REPORTED: + return "ATOM_WIFI_PNO_SCAN_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_TIF_TUNE_CHANGED: + return "ATOM_TIF_TUNE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_AUTO_ROTATE_REPORTED: + return "ATOM_AUTO_ROTATE_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_PERFETTO_TRIGGER: + return "ATOM_PERFETTO_TRIGGER"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_TRANSCODING_DATA: + return "ATOM_TRANSCODING_DATA"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_IMS_SERVICE_ENTITLEMENT_UPDATED: + return "ATOM_IMS_SERVICE_ENTITLEMENT_UPDATED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_DEVICE_ROTATED: + return "ATOM_DEVICE_ROTATED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_SIM_SPECIFIC_SETTINGS_RESTORED: + return "ATOM_SIM_SPECIFIC_SETTINGS_RESTORED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_TEXT_CLASSIFIER_DOWNLOAD_REPORTED: + return "ATOM_TEXT_CLASSIFIER_DOWNLOAD_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_PIN_STORAGE_EVENT: + return "ATOM_PIN_STORAGE_EVENT"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_FACE_DOWN_REPORTED: + return "ATOM_FACE_DOWN_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_HAL_CRASH_REASON_REPORTED: + return "ATOM_BLUETOOTH_HAL_CRASH_REASON_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_REBOOT_ESCROW_PREPARATION_REPORTED: + return "ATOM_REBOOT_ESCROW_PREPARATION_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_REBOOT_ESCROW_LSKF_CAPTURE_REPORTED: + return "ATOM_REBOOT_ESCROW_LSKF_CAPTURE_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_REBOOT_ESCROW_REBOOT_REPORTED: + return "ATOM_REBOOT_ESCROW_REBOOT_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BINDER_LATENCY_REPORTED: + return "ATOM_BINDER_LATENCY_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIAMETRICS_AAUDIOSTREAM_REPORTED: + return "ATOM_MEDIAMETRICS_AAUDIOSTREAM_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIA_TRANSCODING_SESSION_ENDED: + return "ATOM_MEDIA_TRANSCODING_SESSION_ENDED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_MAGNIFICATION_USAGE_REPORTED: + return "ATOM_MAGNIFICATION_USAGE_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_MAGNIFICATION_MODE_WITH_IME_ON_REPORTED: + return "ATOM_MAGNIFICATION_MODE_WITH_IME_ON_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_APP_SEARCH_CALL_STATS_REPORTED: + return "ATOM_APP_SEARCH_CALL_STATS_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_APP_SEARCH_PUT_DOCUMENT_STATS_REPORTED: + return "ATOM_APP_SEARCH_PUT_DOCUMENT_STATS_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_DEVICE_CONTROL_CHANGED: + return "ATOM_DEVICE_CONTROL_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_DEVICE_STATE_CHANGED: + return "ATOM_DEVICE_STATE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_INPUTDEVICE_REGISTERED: + return "ATOM_INPUTDEVICE_REGISTERED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_SMARTSPACE_CARD_REPORTED: + return "ATOM_SMARTSPACE_CARD_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_AUTH_PROMPT_AUTHENTICATE_INVOKED: + return "ATOM_AUTH_PROMPT_AUTHENTICATE_INVOKED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_AUTH_MANAGER_CAN_AUTHENTICATE_INVOKED: + return "ATOM_AUTH_MANAGER_CAN_AUTHENTICATE_INVOKED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_AUTH_ENROLL_ACTION_INVOKED: + return "ATOM_AUTH_ENROLL_ACTION_INVOKED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_AUTH_DEPRECATED_API_USED: + return "ATOM_AUTH_DEPRECATED_API_USED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_UNATTENDED_REBOOT_OCCURRED: + return "ATOM_UNATTENDED_REBOOT_OCCURRED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_LONG_REBOOT_BLOCKING_REPORTED: + return "ATOM_LONG_REBOOT_BLOCKING_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_LOCATION_TIME_ZONE_PROVIDER_STATE_CHANGED: + return "ATOM_LOCATION_TIME_ZONE_PROVIDER_STATE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_FDTRACK_EVENT_OCCURRED: + return "ATOM_FDTRACK_EVENT_OCCURRED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_TIMEOUT_AUTO_EXTENDED_REPORTED: + return "ATOM_TIMEOUT_AUTO_EXTENDED_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_ALARM_BATCH_DELIVERED: + return "ATOM_ALARM_BATCH_DELIVERED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_ALARM_SCHEDULED: + return "ATOM_ALARM_SCHEDULED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_CAR_WATCHDOG_IO_OVERUSE_STATS_REPORTED: + return "ATOM_CAR_WATCHDOG_IO_OVERUSE_STATS_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_USER_LEVEL_HIBERNATION_STATE_CHANGED: + return "ATOM_USER_LEVEL_HIBERNATION_STATE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_APP_SEARCH_INITIALIZE_STATS_REPORTED: + return "ATOM_APP_SEARCH_INITIALIZE_STATS_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_APP_SEARCH_QUERY_STATS_REPORTED: + return "ATOM_APP_SEARCH_QUERY_STATS_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_APP_PROCESS_DIED: + return "ATOM_APP_PROCESS_DIED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_NETWORK_IP_REACHABILITY_MONITOR_REPORTED: + return "ATOM_NETWORK_IP_REACHABILITY_MONITOR_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_SLOW_INPUT_EVENT_REPORTED: + return "ATOM_SLOW_INPUT_EVENT_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_ANR_OCCURRED_PROCESSING_STARTED: + return "ATOM_ANR_OCCURRED_PROCESSING_STARTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_APP_SEARCH_REMOVE_STATS_REPORTED: + return "ATOM_APP_SEARCH_REMOVE_STATS_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIA_CODEC_REPORTED: + return "ATOM_MEDIA_CODEC_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_PERMISSION_USAGE_FRAGMENT_INTERACTION: + return "ATOM_PERMISSION_USAGE_FRAGMENT_INTERACTION"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_PERMISSION_DETAILS_INTERACTION: + return "ATOM_PERMISSION_DETAILS_INTERACTION"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_PRIVACY_SENSOR_TOGGLE_INTERACTION: + return "ATOM_PRIVACY_SENSOR_TOGGLE_INTERACTION"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_PRIVACY_TOGGLE_DIALOG_INTERACTION: + return "ATOM_PRIVACY_TOGGLE_DIALOG_INTERACTION"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_APP_SEARCH_OPTIMIZE_STATS_REPORTED: + return "ATOM_APP_SEARCH_OPTIMIZE_STATS_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_NON_A11Y_TOOL_SERVICE_WARNING_REPORT: + return "ATOM_NON_A11Y_TOOL_SERVICE_WARNING_REPORT"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_APP_SEARCH_SET_SCHEMA_STATS_REPORTED: + return "ATOM_APP_SEARCH_SET_SCHEMA_STATS_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_APP_COMPAT_STATE_CHANGED: + return "ATOM_APP_COMPAT_STATE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_SIZE_COMPAT_RESTART_BUTTON_EVENT_REPORTED: + return "ATOM_SIZE_COMPAT_RESTART_BUTTON_EVENT_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_SPLITSCREEN_UI_CHANGED: + return "ATOM_SPLITSCREEN_UI_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_NETWORK_DNS_HANDSHAKE_REPORTED: + return "ATOM_NETWORK_DNS_HANDSHAKE_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_CODE_PATH_COUNTER: + return "ATOM_BLUETOOTH_CODE_PATH_COUNTER"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_LE_BATCH_SCAN_REPORT_DELAY: + return "ATOM_BLUETOOTH_LE_BATCH_SCAN_REPORT_DELAY"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_ACCESSIBILITY_FLOATING_MENU_UI_CHANGED: + return "ATOM_ACCESSIBILITY_FLOATING_MENU_UI_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_NEURALNETWORKS_COMPILATION_COMPLETED: + return "ATOM_NEURALNETWORKS_COMPILATION_COMPLETED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_NEURALNETWORKS_EXECUTION_COMPLETED: + return "ATOM_NEURALNETWORKS_EXECUTION_COMPLETED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_NEURALNETWORKS_COMPILATION_FAILED: + return "ATOM_NEURALNETWORKS_COMPILATION_FAILED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_NEURALNETWORKS_EXECUTION_FAILED: + return "ATOM_NEURALNETWORKS_EXECUTION_FAILED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_CONTEXT_HUB_BOOTED: + return "ATOM_CONTEXT_HUB_BOOTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_CONTEXT_HUB_RESTARTED: + return "ATOM_CONTEXT_HUB_RESTARTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_CONTEXT_HUB_LOADED_NANOAPP_SNAPSHOT_REPORTED: + return "ATOM_CONTEXT_HUB_LOADED_NANOAPP_SNAPSHOT_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_CHRE_CODE_DOWNLOAD_TRANSACTED: + return "ATOM_CHRE_CODE_DOWNLOAD_TRANSACTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_UWB_SESSION_INITED: + return "ATOM_UWB_SESSION_INITED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_UWB_SESSION_CLOSED: + return "ATOM_UWB_SESSION_CLOSED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_UWB_FIRST_RANGING_RECEIVED: + return "ATOM_UWB_FIRST_RANGING_RECEIVED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_UWB_RANGING_MEASUREMENT_RECEIVED: + return "ATOM_UWB_RANGING_MEASUREMENT_RECEIVED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_TEXT_CLASSIFIER_DOWNLOAD_WORK_SCHEDULED: + return "ATOM_TEXT_CLASSIFIER_DOWNLOAD_WORK_SCHEDULED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_TEXT_CLASSIFIER_DOWNLOAD_WORK_COMPLETED: + return "ATOM_TEXT_CLASSIFIER_DOWNLOAD_WORK_COMPLETED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_CLIPBOARD_CLEARED: + return "ATOM_CLIPBOARD_CLEARED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_VM_CREATION_REQUESTED: + return "ATOM_VM_CREATION_REQUESTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_NEARBY_DEVICE_SCAN_STATE_CHANGED: + return "ATOM_NEARBY_DEVICE_SCAN_STATE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_CAMERA_COMPAT_CONTROL_EVENT_REPORTED: + return "ATOM_CAMERA_COMPAT_CONTROL_EVENT_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_APPLICATION_LOCALES_CHANGED: + return "ATOM_APPLICATION_LOCALES_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIAMETRICS_AUDIOTRACKSTATUS_REPORTED: + return "ATOM_MEDIAMETRICS_AUDIOTRACKSTATUS_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_FOLD_STATE_DURATION_REPORTED: + return "ATOM_FOLD_STATE_DURATION_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_LOCATION_TIME_ZONE_PROVIDER_CONTROLLER_STATE_CHANGED: + return "ATOM_LOCATION_TIME_ZONE_PROVIDER_CONTROLLER_STATE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_DISPLAY_HBM_STATE_CHANGED: + return "ATOM_DISPLAY_HBM_STATE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_DISPLAY_HBM_BRIGHTNESS_CHANGED: + return "ATOM_DISPLAY_HBM_BRIGHTNESS_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_PERSISTENT_URI_PERMISSIONS_FLUSHED: + return "ATOM_PERSISTENT_URI_PERMISSIONS_FLUSHED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_EARLY_BOOT_COMP_OS_ARTIFACTS_CHECK_REPORTED: + return "ATOM_EARLY_BOOT_COMP_OS_ARTIFACTS_CHECK_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_VBMETA_DIGEST_REPORTED: + return "ATOM_VBMETA_DIGEST_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_APEX_INFO_GATHERED: + return "ATOM_APEX_INFO_GATHERED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_PVM_INFO_GATHERED: + return "ATOM_PVM_INFO_GATHERED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_WEAR_SETTINGS_UI_INTERACTED: + return "ATOM_WEAR_SETTINGS_UI_INTERACTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_TRACING_SERVICE_REPORT_EVENT: + return "ATOM_TRACING_SERVICE_REPORT_EVENT"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIAMETRICS_AUDIORECORDSTATUS_REPORTED: + return "ATOM_MEDIAMETRICS_AUDIORECORDSTATUS_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_LAUNCHER_LATENCY: + return "ATOM_LAUNCHER_LATENCY"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_DROPBOX_ENTRY_DROPPED: + return "ATOM_DROPBOX_ENTRY_DROPPED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_P2P_CONNECTION_REPORTED: + return "ATOM_WIFI_P2P_CONNECTION_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_GAME_STATE_CHANGED: + return "ATOM_GAME_STATE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_HOTWORD_DETECTOR_CREATE_REQUESTED: + return "ATOM_HOTWORD_DETECTOR_CREATE_REQUESTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_HOTWORD_DETECTION_SERVICE_INIT_RESULT_REPORTED: + return "ATOM_HOTWORD_DETECTION_SERVICE_INIT_RESULT_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_HOTWORD_DETECTION_SERVICE_RESTARTED: + return "ATOM_HOTWORD_DETECTION_SERVICE_RESTARTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_HOTWORD_DETECTOR_KEYPHRASE_TRIGGERED: + return "ATOM_HOTWORD_DETECTOR_KEYPHRASE_TRIGGERED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_HOTWORD_DETECTOR_EVENTS: + return "ATOM_HOTWORD_DETECTOR_EVENTS"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_API_CALLED: + return "ATOM_AD_SERVICES_API_CALLED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_MESUREMENT_REPORTS_UPLOADED: + return "ATOM_AD_SERVICES_MESUREMENT_REPORTS_UPLOADED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BOOT_COMPLETED_BROADCAST_COMPLETION_LATENCY_REPORTED: + return "ATOM_BOOT_COMPLETED_BROADCAST_COMPLETION_LATENCY_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_CONTACTS_INDEXER_UPDATE_STATS_REPORTED: + return "ATOM_CONTACTS_INDEXER_UPDATE_STATS_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_APP_BACKGROUND_RESTRICTIONS_INFO: + return "ATOM_APP_BACKGROUND_RESTRICTIONS_INFO"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_MMS_SMS_PROVIDER_GET_THREAD_ID_FAILED: + return "ATOM_MMS_SMS_PROVIDER_GET_THREAD_ID_FAILED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_MMS_SMS_DATABASE_HELPER_ON_UPGRADE_FAILED: + return "ATOM_MMS_SMS_DATABASE_HELPER_ON_UPGRADE_FAILED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_PERMISSION_REMINDER_NOTIFICATION_INTERACTED: + return "ATOM_PERMISSION_REMINDER_NOTIFICATION_INTERACTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_RECENT_PERMISSION_DECISIONS_INTERACTED: + return "ATOM_RECENT_PERMISSION_DECISIONS_INTERACTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_GNSS_PSDS_DOWNLOAD_REPORTED: + return "ATOM_GNSS_PSDS_DOWNLOAD_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_LE_AUDIO_CONNECTION_SESSION_REPORTED: + return "ATOM_LE_AUDIO_CONNECTION_SESSION_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_LE_AUDIO_BROADCAST_SESSION_REPORTED: + return "ATOM_LE_AUDIO_BROADCAST_SESSION_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_DREAM_UI_EVENT_REPORTED: + return "ATOM_DREAM_UI_EVENT_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_TASK_MANAGER_EVENT_REPORTED: + return "ATOM_TASK_MANAGER_EVENT_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_CDM_ASSOCIATION_ACTION: + return "ATOM_CDM_ASSOCIATION_ACTION"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_MAGNIFICATION_TRIPLE_TAP_AND_HOLD_ACTIVATED_SESSION_REPORTED: + return "ATOM_MAGNIFICATION_TRIPLE_TAP_AND_HOLD_ACTIVATED_SESSION_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_MAGNIFICATION_FOLLOW_TYPING_FOCUS_ACTIVATED_SESSION_REPORTED: + return "ATOM_MAGNIFICATION_FOLLOW_TYPING_FOCUS_ACTIVATED_SESSION_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_ACCESSIBILITY_TEXT_READING_OPTIONS_CHANGED: + return "ATOM_ACCESSIBILITY_TEXT_READING_OPTIONS_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_SETUP_FAILURE_CRASH_REPORTED: + return "ATOM_WIFI_SETUP_FAILURE_CRASH_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_UWB_DEVICE_ERROR_REPORTED: + return "ATOM_UWB_DEVICE_ERROR_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_ISOLATED_COMPILATION_SCHEDULED: + return "ATOM_ISOLATED_COMPILATION_SCHEDULED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_ISOLATED_COMPILATION_ENDED: + return "ATOM_ISOLATED_COMPILATION_ENDED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_ONS_OPPORTUNISTIC_ESIM_PROVISIONING_COMPLETE: + return "ATOM_ONS_OPPORTUNISTIC_ESIM_PROVISIONING_COMPLETE"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_SYSTEM_SERVER_PRE_WATCHDOG_OCCURRED: + return "ATOM_SYSTEM_SERVER_PRE_WATCHDOG_OCCURRED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_TELEPHONY_ANOMALY_DETECTED: + return "ATOM_TELEPHONY_ANOMALY_DETECTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_LETTERBOX_POSITION_CHANGED: + return "ATOM_LETTERBOX_POSITION_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_REMOTE_KEY_PROVISIONING_ATTEMPT: + return "ATOM_REMOTE_KEY_PROVISIONING_ATTEMPT"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_REMOTE_KEY_PROVISIONING_NETWORK_INFO: + return "ATOM_REMOTE_KEY_PROVISIONING_NETWORK_INFO"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_REMOTE_KEY_PROVISIONING_TIMING: + return "ATOM_REMOTE_KEY_PROVISIONING_TIMING"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIAOUTPUT_OP_INTERACTION_REPORT: + return "ATOM_MEDIAOUTPUT_OP_INTERACTION_REPORT"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_SYNC_EXEMPTION_OCCURRED: + return "ATOM_SYNC_EXEMPTION_OCCURRED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_AUTOFILL_PRESENTATION_EVENT_REPORTED: + return "ATOM_AUTOFILL_PRESENTATION_EVENT_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_DOCK_STATE_CHANGED: + return "ATOM_DOCK_STATE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_SAFETY_SOURCE_STATE_COLLECTED: + return "ATOM_SAFETY_SOURCE_STATE_COLLECTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_SAFETY_CENTER_SYSTEM_EVENT_REPORTED: + return "ATOM_SAFETY_CENTER_SYSTEM_EVENT_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_SAFETY_CENTER_INTERACTION_REPORTED: + return "ATOM_SAFETY_CENTER_INTERACTION_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_SETTINGS_PROVIDER_SETTING_CHANGED: + return "ATOM_SETTINGS_PROVIDER_SETTING_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BROADCAST_DELIVERY_EVENT_REPORTED: + return "ATOM_BROADCAST_DELIVERY_EVENT_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_SERVICE_REQUEST_EVENT_REPORTED: + return "ATOM_SERVICE_REQUEST_EVENT_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_PROVIDER_ACQUISITION_EVENT_REPORTED: + return "ATOM_PROVIDER_ACQUISITION_EVENT_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_DEVICE_NAME_REPORTED: + return "ATOM_BLUETOOTH_DEVICE_NAME_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_CB_CONFIG_UPDATED: + return "ATOM_CB_CONFIG_UPDATED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_CB_MODULE_ERROR_REPORTED: + return "ATOM_CB_MODULE_ERROR_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_CB_SERVICE_FEATURE_CHANGED: + return "ATOM_CB_SERVICE_FEATURE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_CB_RECEIVER_FEATURE_CHANGED: + return "ATOM_CB_RECEIVER_FEATURE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_JSSCRIPTENGINE_LATENCY_REPORTED: + return "ATOM_JSSCRIPTENGINE_LATENCY_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_PRIVACY_SIGNAL_NOTIFICATION_INTERACTION: + return "ATOM_PRIVACY_SIGNAL_NOTIFICATION_INTERACTION"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_PRIVACY_SIGNAL_ISSUE_CARD_INTERACTION: + return "ATOM_PRIVACY_SIGNAL_ISSUE_CARD_INTERACTION"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_PRIVACY_SIGNALS_JOB_FAILURE: + return "ATOM_PRIVACY_SIGNALS_JOB_FAILURE"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_VIBRATION_REPORTED: + return "ATOM_VIBRATION_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_UWB_RANGING_START: + return "ATOM_UWB_RANGING_START"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_MOBILE_DATA_DOWNLOAD_FILE_GROUP_STATUS_REPORTED: + return "ATOM_MOBILE_DATA_DOWNLOAD_FILE_GROUP_STATUS_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_APP_COMPACTED_V2: + return "ATOM_APP_COMPACTED_V2"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_SETTINGS_USAGE_REPORTED: + return "ATOM_AD_SERVICES_SETTINGS_USAGE_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_DISPLAY_BRIGHTNESS_CHANGED: + return "ATOM_DISPLAY_BRIGHTNESS_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_ACTIVITY_ACTION_BLOCKED: + return "ATOM_ACTIVITY_ACTION_BLOCKED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BACKGROUND_FETCH_PROCESS_REPORTED: + return "ATOM_BACKGROUND_FETCH_PROCESS_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_UPDATE_CUSTOM_AUDIENCE_PROCESS_REPORTED: + return "ATOM_UPDATE_CUSTOM_AUDIENCE_PROCESS_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_RUN_AD_BIDDING_PROCESS_REPORTED: + return "ATOM_RUN_AD_BIDDING_PROCESS_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_RUN_AD_SCORING_PROCESS_REPORTED: + return "ATOM_RUN_AD_SCORING_PROCESS_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_RUN_AD_SELECTION_PROCESS_REPORTED: + return "ATOM_RUN_AD_SELECTION_PROCESS_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_RUN_AD_BIDDING_PER_CA_PROCESS_REPORTED: + return "ATOM_RUN_AD_BIDDING_PER_CA_PROCESS_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_MOBILE_DATA_DOWNLOAD_DOWNLOAD_RESULT_REPORTED: + return "ATOM_MOBILE_DATA_DOWNLOAD_DOWNLOAD_RESULT_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_MOBILE_DATA_DOWNLOAD_FILE_GROUP_STORAGE_STATS_REPORTED: + return "ATOM_MOBILE_DATA_DOWNLOAD_FILE_GROUP_STORAGE_STATS_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_NETWORK_DNS_SERVER_SUPPORT_REPORTED: + return "ATOM_NETWORK_DNS_SERVER_SUPPORT_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_VM_BOOTED: + return "ATOM_VM_BOOTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_VM_EXITED: + return "ATOM_VM_EXITED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_AMBIENT_BRIGHTNESS_STATS_REPORTED: + return "ATOM_AMBIENT_BRIGHTNESS_STATS_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIAMETRICS_SPATIALIZERCAPABILITIES_REPORTED: + return "ATOM_MEDIAMETRICS_SPATIALIZERCAPABILITIES_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIAMETRICS_SPATIALIZERDEVICEENABLED_REPORTED: + return "ATOM_MEDIAMETRICS_SPATIALIZERDEVICEENABLED_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIAMETRICS_HEADTRACKERDEVICEENABLED_REPORTED: + return "ATOM_MEDIAMETRICS_HEADTRACKERDEVICEENABLED_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIAMETRICS_HEADTRACKERDEVICESUPPORTED_REPORTED: + return "ATOM_MEDIAMETRICS_HEADTRACKERDEVICESUPPORTED_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_MEASUREMENT_REGISTRATIONS: + return "ATOM_AD_SERVICES_MEASUREMENT_REGISTRATIONS"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_HEARING_AID_INFO_REPORTED: + return "ATOM_HEARING_AID_INFO_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_DEVICE_WIDE_JOB_CONSTRAINT_CHANGED: + return "ATOM_DEVICE_WIDE_JOB_CONSTRAINT_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_AMBIENT_MODE_CHANGED: + return "ATOM_AMBIENT_MODE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_ANR_LATENCY_REPORTED: + return "ATOM_ANR_LATENCY_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_RESOURCE_API_INFO: + return "ATOM_RESOURCE_API_INFO"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_SYSTEM_DEFAULT_NETWORK_CHANGED: + return "ATOM_SYSTEM_DEFAULT_NETWORK_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_IWLAN_SETUP_DATA_CALL_RESULT_REPORTED: + return "ATOM_IWLAN_SETUP_DATA_CALL_RESULT_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_IWLAN_PDN_DISCONNECTED_REASON_REPORTED: + return "ATOM_IWLAN_PDN_DISCONNECTED_REASON_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_AIRPLANE_MODE_SESSION_REPORTED: + return "ATOM_AIRPLANE_MODE_SESSION_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_VM_CPU_STATUS_REPORTED: + return "ATOM_VM_CPU_STATUS_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_VM_MEM_STATUS_REPORTED: + return "ATOM_VM_MEM_STATUS_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_PACKAGE_INSTALLATION_SESSION_REPORTED: + return "ATOM_PACKAGE_INSTALLATION_SESSION_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_DEFAULT_NETWORK_REMATCH_INFO: + return "ATOM_DEFAULT_NETWORK_REMATCH_INFO"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_NETWORK_SELECTION_PERFORMANCE: + return "ATOM_NETWORK_SELECTION_PERFORMANCE"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_NETWORK_NSD_REPORTED: + return "ATOM_NETWORK_NSD_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_DISCONNECTION_REASON_REPORTED: + return "ATOM_BLUETOOTH_DISCONNECTION_REASON_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_LOCAL_VERSIONS_REPORTED: + return "ATOM_BLUETOOTH_LOCAL_VERSIONS_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_REMOTE_SUPPORTED_FEATURES_REPORTED: + return "ATOM_BLUETOOTH_REMOTE_SUPPORTED_FEATURES_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_LOCAL_SUPPORTED_FEATURES_REPORTED: + return "ATOM_BLUETOOTH_LOCAL_SUPPORTED_FEATURES_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_GATT_APP_INFO: + return "ATOM_BLUETOOTH_GATT_APP_INFO"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BRIGHTNESS_CONFIGURATION_UPDATED: + return "ATOM_BRIGHTNESS_CONFIGURATION_UPDATED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_GET_TOPICS_REPORTED: + return "ATOM_AD_SERVICES_GET_TOPICS_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_EPOCH_COMPUTATION_GET_TOP_TOPICS_REPORTED: + return "ATOM_AD_SERVICES_EPOCH_COMPUTATION_GET_TOP_TOPICS_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_EPOCH_COMPUTATION_CLASSIFIER_REPORTED: + return "ATOM_AD_SERVICES_EPOCH_COMPUTATION_CLASSIFIER_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_LAUNCHED: + return "ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_LAUNCHED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_FINISHED: + return "ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_FINISHED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_CONNECTION_REPORTED: + return "ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_CONNECTION_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_DEVICE_SCAN_TRIGGERED: + return "ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_DEVICE_SCAN_TRIGGERED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_FIRST_DEVICE_SCAN_LATENCY: + return "ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_FIRST_DEVICE_SCAN_LATENCY"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_CONNECT_DEVICE_LATENCY: + return "ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_CONNECT_DEVICE_LATENCY"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_PACKAGE_MANAGER_SNAPSHOT_REPORTED: + return "ATOM_PACKAGE_MANAGER_SNAPSHOT_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_PACKAGE_MANAGER_APPS_FILTER_CACHE_BUILD_REPORTED: + return "ATOM_PACKAGE_MANAGER_APPS_FILTER_CACHE_BUILD_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_PACKAGE_MANAGER_APPS_FILTER_CACHE_UPDATE_REPORTED: + return "ATOM_PACKAGE_MANAGER_APPS_FILTER_CACHE_UPDATE_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_LAUNCHER_IMPRESSION_EVENT: + return "ATOM_LAUNCHER_IMPRESSION_EVENT"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_ALL_DEVICES_SCAN_LATENCY: + return "ATOM_WEAR_MEDIA_OUTPUT_SWITCHER_ALL_DEVICES_SCAN_LATENCY"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_WS_WATCH_FACE_EDITED: + return "ATOM_WS_WATCH_FACE_EDITED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_WS_WATCH_FACE_FAVORITE_ACTION_REPORTED: + return "ATOM_WS_WATCH_FACE_FAVORITE_ACTION_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_WS_WATCH_FACE_SET_ACTION_REPORTED: + return "ATOM_WS_WATCH_FACE_SET_ACTION_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_PACKAGE_UNINSTALLATION_REPORTED: + return "ATOM_PACKAGE_UNINSTALLATION_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_GAME_MODE_CHANGED: + return "ATOM_GAME_MODE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_GAME_MODE_CONFIGURATION_CHANGED: + return "ATOM_GAME_MODE_CONFIGURATION_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BEDTIME_MODE_STATE_CHANGED: + return "ATOM_BEDTIME_MODE_STATE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_NETWORK_SLICE_SESSION_ENDED: + return "ATOM_NETWORK_SLICE_SESSION_ENDED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_NETWORK_SLICE_DAILY_DATA_USAGE_REPORTED: + return "ATOM_NETWORK_SLICE_DAILY_DATA_USAGE_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_NFC_TAG_TYPE_OCCURRED: + return "ATOM_NFC_TAG_TYPE_OCCURRED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_NFC_AID_CONFLICT_OCCURRED: + return "ATOM_NFC_AID_CONFLICT_OCCURRED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_NFC_READER_CONFLICT_OCCURRED: + return "ATOM_NFC_READER_CONFLICT_OCCURRED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_WS_TILE_LIST_CHANGED: + return "ATOM_WS_TILE_LIST_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_GET_TYPE_ACCESSED_WITHOUT_PERMISSION: + return "ATOM_GET_TYPE_ACCESSED_WITHOUT_PERMISSION"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_MOBILE_BUNDLED_APP_INFO_GATHERED: + return "ATOM_MOBILE_BUNDLED_APP_INFO_GATHERED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_WS_WATCH_FACE_COMPLICATION_SET_CHANGED: + return "ATOM_WS_WATCH_FACE_COMPLICATION_SET_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIA_DRM_CREATED: + return "ATOM_MEDIA_DRM_CREATED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIA_DRM_ERRORED: + return "ATOM_MEDIA_DRM_ERRORED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIA_DRM_SESSION_OPENED: + return "ATOM_MEDIA_DRM_SESSION_OPENED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIA_DRM_SESSION_CLOSED: + return "ATOM_MEDIA_DRM_SESSION_CLOSED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_USER_SELECTED_RESOLUTION: + return "ATOM_USER_SELECTED_RESOLUTION"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_UNSAFE_INTENT_EVENT_REPORTED: + return "ATOM_UNSAFE_INTENT_EVENT_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_PERFORMANCE_HINT_SESSION_REPORTED: + return "ATOM_PERFORMANCE_HINT_SESSION_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIAMETRICS_MIDI_DEVICE_CLOSE_REPORTED: + return "ATOM_MEDIAMETRICS_MIDI_DEVICE_CLOSE_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BIOMETRIC_TOUCH_REPORTED: + return "ATOM_BIOMETRIC_TOUCH_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_HOTWORD_AUDIO_EGRESS_EVENT_REPORTED: + return "ATOM_HOTWORD_AUDIO_EGRESS_EVENT_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_APP_SEARCH_SCHEMA_MIGRATION_STATS_REPORTED: + return "ATOM_APP_SEARCH_SCHEMA_MIGRATION_STATS_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_LOCATION_ENABLED_STATE_CHANGED: + return "ATOM_LOCATION_ENABLED_STATE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_IME_REQUEST_FINISHED: + return "ATOM_IME_REQUEST_FINISHED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_USB_COMPLIANCE_WARNINGS_REPORTED: + return "ATOM_USB_COMPLIANCE_WARNINGS_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_APP_SUPPORTED_LOCALES_CHANGED: + return "ATOM_APP_SUPPORTED_LOCALES_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_GRAMMATICAL_INFLECTION_CHANGED: + return "ATOM_GRAMMATICAL_INFLECTION_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIA_PROVIDER_VOLUME_RECOVERY_REPORTED: + return "ATOM_MEDIA_PROVIDER_VOLUME_RECOVERY_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BIOMETRIC_PROPERTIES_COLLECTED: + return "ATOM_BIOMETRIC_PROPERTIES_COLLECTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_KERNEL_WAKEUP_ATTRIBUTED: + return "ATOM_KERNEL_WAKEUP_ATTRIBUTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_SCREEN_STATE_CHANGED_V2: + return "ATOM_SCREEN_STATE_CHANGED_V2"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_WS_BACKUP_ACTION_REPORTED: + return "ATOM_WS_BACKUP_ACTION_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_WS_RESTORE_ACTION_REPORTED: + return "ATOM_WS_RESTORE_ACTION_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_DEVICE_LOG_ACCESS_EVENT_REPORTED: + return "ATOM_DEVICE_LOG_ACCESS_EVENT_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIA_SESSION_UPDATED: + return "ATOM_MEDIA_SESSION_UPDATED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_WEAR_OOBE_STATE_CHANGED: + return "ATOM_WEAR_OOBE_STATE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_WS_NOTIFICATION_UPDATED: + return "ATOM_WS_NOTIFICATION_UPDATED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_NETWORK_VALIDATION_FAILURE_STATS_DAILY_REPORTED: + return "ATOM_NETWORK_VALIDATION_FAILURE_STATS_DAILY_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_WS_COMPLICATION_TAPPED: + return "ATOM_WS_COMPLICATION_TAPPED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_WS_WEAR_TIME_SESSION: + return "ATOM_WS_WEAR_TIME_SESSION"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_BYTES_TRANSFER: + return "ATOM_WIFI_BYTES_TRANSFER"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_BYTES_TRANSFER_BY_FG_BG: + return "ATOM_WIFI_BYTES_TRANSFER_BY_FG_BG"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_MOBILE_BYTES_TRANSFER: + return "ATOM_MOBILE_BYTES_TRANSFER"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_MOBILE_BYTES_TRANSFER_BY_FG_BG: + return "ATOM_MOBILE_BYTES_TRANSFER_BY_FG_BG"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_BYTES_TRANSFER: + return "ATOM_BLUETOOTH_BYTES_TRANSFER"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_KERNEL_WAKELOCK: + return "ATOM_KERNEL_WAKELOCK"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_SUBSYSTEM_SLEEP_STATE: + return "ATOM_SUBSYSTEM_SLEEP_STATE"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_CPU_TIME_PER_UID: + return "ATOM_CPU_TIME_PER_UID"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_CPU_TIME_PER_UID_FREQ: + return "ATOM_CPU_TIME_PER_UID_FREQ"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_ACTIVITY_INFO: + return "ATOM_WIFI_ACTIVITY_INFO"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_MODEM_ACTIVITY_INFO: + return "ATOM_MODEM_ACTIVITY_INFO"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_ACTIVITY_INFO: + return "ATOM_BLUETOOTH_ACTIVITY_INFO"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_PROCESS_MEMORY_STATE: + return "ATOM_PROCESS_MEMORY_STATE"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_SYSTEM_ELAPSED_REALTIME: + return "ATOM_SYSTEM_ELAPSED_REALTIME"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_SYSTEM_UPTIME: + return "ATOM_SYSTEM_UPTIME"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_CPU_ACTIVE_TIME: + return "ATOM_CPU_ACTIVE_TIME"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_CPU_CLUSTER_TIME: + return "ATOM_CPU_CLUSTER_TIME"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_DISK_SPACE: + return "ATOM_DISK_SPACE"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_REMAINING_BATTERY_CAPACITY: + return "ATOM_REMAINING_BATTERY_CAPACITY"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_FULL_BATTERY_CAPACITY: + return "ATOM_FULL_BATTERY_CAPACITY"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_TEMPERATURE: + return "ATOM_TEMPERATURE"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BINDER_CALLS: + return "ATOM_BINDER_CALLS"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BINDER_CALLS_EXCEPTIONS: + return "ATOM_BINDER_CALLS_EXCEPTIONS"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_LOOPER_STATS: + return "ATOM_LOOPER_STATS"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_DISK_STATS: + return "ATOM_DISK_STATS"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_DIRECTORY_USAGE: + return "ATOM_DIRECTORY_USAGE"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_APP_SIZE: + return "ATOM_APP_SIZE"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_CATEGORY_SIZE: + return "ATOM_CATEGORY_SIZE"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_PROC_STATS: + return "ATOM_PROC_STATS"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BATTERY_VOLTAGE: + return "ATOM_BATTERY_VOLTAGE"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_NUM_FINGERPRINTS_ENROLLED: + return "ATOM_NUM_FINGERPRINTS_ENROLLED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_DISK_IO: + return "ATOM_DISK_IO"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_POWER_PROFILE: + return "ATOM_POWER_PROFILE"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_PROC_STATS_PKG_PROC: + return "ATOM_PROC_STATS_PKG_PROC"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_PROCESS_CPU_TIME: + return "ATOM_PROCESS_CPU_TIME"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_CPU_TIME_PER_THREAD_FREQ: + return "ATOM_CPU_TIME_PER_THREAD_FREQ"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_ON_DEVICE_POWER_MEASUREMENT: + return "ATOM_ON_DEVICE_POWER_MEASUREMENT"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_DEVICE_CALCULATED_POWER_USE: + return "ATOM_DEVICE_CALCULATED_POWER_USE"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_PROCESS_MEMORY_HIGH_WATER_MARK: + return "ATOM_PROCESS_MEMORY_HIGH_WATER_MARK"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BATTERY_LEVEL: + return "ATOM_BATTERY_LEVEL"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BUILD_INFORMATION: + return "ATOM_BUILD_INFORMATION"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BATTERY_CYCLE_COUNT: + return "ATOM_BATTERY_CYCLE_COUNT"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_DEBUG_ELAPSED_CLOCK: + return "ATOM_DEBUG_ELAPSED_CLOCK"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_DEBUG_FAILING_ELAPSED_CLOCK: + return "ATOM_DEBUG_FAILING_ELAPSED_CLOCK"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_NUM_FACES_ENROLLED: + return "ATOM_NUM_FACES_ENROLLED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_ROLE_HOLDER: + return "ATOM_ROLE_HOLDER"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_DANGEROUS_PERMISSION_STATE: + return "ATOM_DANGEROUS_PERMISSION_STATE"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_TRAIN_INFO: + return "ATOM_TRAIN_INFO"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_TIME_ZONE_DATA_INFO: + return "ATOM_TIME_ZONE_DATA_INFO"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_EXTERNAL_STORAGE_INFO: + return "ATOM_EXTERNAL_STORAGE_INFO"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_GPU_STATS_GLOBAL_INFO: + return "ATOM_GPU_STATS_GLOBAL_INFO"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_GPU_STATS_APP_INFO: + return "ATOM_GPU_STATS_APP_INFO"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_SYSTEM_ION_HEAP_SIZE: + return "ATOM_SYSTEM_ION_HEAP_SIZE"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_APPS_ON_EXTERNAL_STORAGE_INFO: + return "ATOM_APPS_ON_EXTERNAL_STORAGE_INFO"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_FACE_SETTINGS: + return "ATOM_FACE_SETTINGS"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_COOLING_DEVICE: + return "ATOM_COOLING_DEVICE"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_APP_OPS: + return "ATOM_APP_OPS"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_PROCESS_SYSTEM_ION_HEAP_SIZE: + return "ATOM_PROCESS_SYSTEM_ION_HEAP_SIZE"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_SURFACEFLINGER_STATS_GLOBAL_INFO: + return "ATOM_SURFACEFLINGER_STATS_GLOBAL_INFO"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_SURFACEFLINGER_STATS_LAYER_INFO: + return "ATOM_SURFACEFLINGER_STATS_LAYER_INFO"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_PROCESS_MEMORY_SNAPSHOT: + return "ATOM_PROCESS_MEMORY_SNAPSHOT"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_VMS_CLIENT_STATS: + return "ATOM_VMS_CLIENT_STATS"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_NOTIFICATION_REMOTE_VIEWS: + return "ATOM_NOTIFICATION_REMOTE_VIEWS"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_DANGEROUS_PERMISSION_STATE_SAMPLED: + return "ATOM_DANGEROUS_PERMISSION_STATE_SAMPLED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_GRAPHICS_STATS: + return "ATOM_GRAPHICS_STATS"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_RUNTIME_APP_OP_ACCESS: + return "ATOM_RUNTIME_APP_OP_ACCESS"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_ION_HEAP_SIZE: + return "ATOM_ION_HEAP_SIZE"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_PACKAGE_NOTIFICATION_PREFERENCES: + return "ATOM_PACKAGE_NOTIFICATION_PREFERENCES"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_PACKAGE_NOTIFICATION_CHANNEL_PREFERENCES: + return "ATOM_PACKAGE_NOTIFICATION_CHANNEL_PREFERENCES"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_PACKAGE_NOTIFICATION_CHANNEL_GROUP_PREFERENCES: + return "ATOM_PACKAGE_NOTIFICATION_CHANNEL_GROUP_PREFERENCES"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_GNSS_STATS: + return "ATOM_GNSS_STATS"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_ATTRIBUTED_APP_OPS: + return "ATOM_ATTRIBUTED_APP_OPS"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_VOICE_CALL_SESSION: + return "ATOM_VOICE_CALL_SESSION"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_VOICE_CALL_RAT_USAGE: + return "ATOM_VOICE_CALL_RAT_USAGE"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_SIM_SLOT_STATE: + return "ATOM_SIM_SLOT_STATE"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_SUPPORTED_RADIO_ACCESS_FAMILY: + return "ATOM_SUPPORTED_RADIO_ACCESS_FAMILY"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_SETTING_SNAPSHOT: + return "ATOM_SETTING_SNAPSHOT"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BLOB_INFO: + return "ATOM_BLOB_INFO"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_DATA_USAGE_BYTES_TRANSFER: + return "ATOM_DATA_USAGE_BYTES_TRANSFER"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BYTES_TRANSFER_BY_TAG_AND_METERED: + return "ATOM_BYTES_TRANSFER_BY_TAG_AND_METERED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_DND_MODE_RULE: + return "ATOM_DND_MODE_RULE"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_GENERAL_EXTERNAL_STORAGE_ACCESS_STATS: + return "ATOM_GENERAL_EXTERNAL_STORAGE_ACCESS_STATS"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_INCOMING_SMS: + return "ATOM_INCOMING_SMS"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_OUTGOING_SMS: + return "ATOM_OUTGOING_SMS"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_CARRIER_ID_TABLE_VERSION: + return "ATOM_CARRIER_ID_TABLE_VERSION"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_DATA_CALL_SESSION: + return "ATOM_DATA_CALL_SESSION"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_CELLULAR_SERVICE_STATE: + return "ATOM_CELLULAR_SERVICE_STATE"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_CELLULAR_DATA_SERVICE_SWITCH: + return "ATOM_CELLULAR_DATA_SERVICE_SWITCH"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_SYSTEM_MEMORY: + return "ATOM_SYSTEM_MEMORY"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_IMS_REGISTRATION_TERMINATION: + return "ATOM_IMS_REGISTRATION_TERMINATION"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_IMS_REGISTRATION_STATS: + return "ATOM_IMS_REGISTRATION_STATS"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_CPU_TIME_PER_CLUSTER_FREQ: + return "ATOM_CPU_TIME_PER_CLUSTER_FREQ"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_CPU_CYCLES_PER_UID_CLUSTER: + return "ATOM_CPU_CYCLES_PER_UID_CLUSTER"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_DEVICE_ROTATED_DATA: + return "ATOM_DEVICE_ROTATED_DATA"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_CPU_CYCLES_PER_THREAD_GROUP_CLUSTER: + return "ATOM_CPU_CYCLES_PER_THREAD_GROUP_CLUSTER"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIA_DRM_ACTIVITY_INFO: + return "ATOM_MEDIA_DRM_ACTIVITY_INFO"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_OEM_MANAGED_BYTES_TRANSFER: + return "ATOM_OEM_MANAGED_BYTES_TRANSFER"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_GNSS_POWER_STATS: + return "ATOM_GNSS_POWER_STATS"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_TIME_ZONE_DETECTOR_STATE: + return "ATOM_TIME_ZONE_DETECTOR_STATE"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_KEYSTORE2_STORAGE_STATS: + return "ATOM_KEYSTORE2_STORAGE_STATS"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_RKP_POOL_STATS: + return "ATOM_RKP_POOL_STATS"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_PROCESS_DMABUF_MEMORY: + return "ATOM_PROCESS_DMABUF_MEMORY"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_PENDING_ALARM_INFO: + return "ATOM_PENDING_ALARM_INFO"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_USER_LEVEL_HIBERNATED_APPS: + return "ATOM_USER_LEVEL_HIBERNATED_APPS"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_LAUNCHER_LAYOUT_SNAPSHOT: + return "ATOM_LAUNCHER_LAYOUT_SNAPSHOT"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_GLOBAL_HIBERNATED_APPS: + return "ATOM_GLOBAL_HIBERNATED_APPS"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_INPUT_EVENT_LATENCY_SKETCH: + return "ATOM_INPUT_EVENT_LATENCY_SKETCH"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BATTERY_USAGE_STATS_BEFORE_RESET: + return "ATOM_BATTERY_USAGE_STATS_BEFORE_RESET"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BATTERY_USAGE_STATS_SINCE_RESET: + return "ATOM_BATTERY_USAGE_STATS_SINCE_RESET"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BATTERY_USAGE_STATS_SINCE_RESET_USING_POWER_PROFILE_MODEL: + return "ATOM_BATTERY_USAGE_STATS_SINCE_RESET_USING_POWER_PROFILE_MODEL"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_INSTALLED_INCREMENTAL_PACKAGE: + return "ATOM_INSTALLED_INCREMENTAL_PACKAGE"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_TELEPHONY_NETWORK_REQUESTS: + return "ATOM_TELEPHONY_NETWORK_REQUESTS"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_APP_SEARCH_STORAGE_INFO: + return "ATOM_APP_SEARCH_STORAGE_INFO"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_VMSTAT: + return "ATOM_VMSTAT"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_KEYSTORE2_KEY_CREATION_WITH_GENERAL_INFO: + return "ATOM_KEYSTORE2_KEY_CREATION_WITH_GENERAL_INFO"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_KEYSTORE2_KEY_CREATION_WITH_AUTH_INFO: + return "ATOM_KEYSTORE2_KEY_CREATION_WITH_AUTH_INFO"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_KEYSTORE2_KEY_CREATION_WITH_PURPOSE_AND_MODES_INFO: + return "ATOM_KEYSTORE2_KEY_CREATION_WITH_PURPOSE_AND_MODES_INFO"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_KEYSTORE2_ATOM_WITH_OVERFLOW: + return "ATOM_KEYSTORE2_ATOM_WITH_OVERFLOW"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_KEYSTORE2_KEY_OPERATION_WITH_PURPOSE_AND_MODES_INFO: + return "ATOM_KEYSTORE2_KEY_OPERATION_WITH_PURPOSE_AND_MODES_INFO"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_KEYSTORE2_KEY_OPERATION_WITH_GENERAL_INFO: + return "ATOM_KEYSTORE2_KEY_OPERATION_WITH_GENERAL_INFO"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_RKP_ERROR_STATS: + return "ATOM_RKP_ERROR_STATS"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_KEYSTORE2_CRASH_STATS: + return "ATOM_KEYSTORE2_CRASH_STATS"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_VENDOR_APEX_INFO: + return "ATOM_VENDOR_APEX_INFO"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_ACCESSIBILITY_SHORTCUT_STATS: + return "ATOM_ACCESSIBILITY_SHORTCUT_STATS"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_ACCESSIBILITY_FLOATING_MENU_STATS: + return "ATOM_ACCESSIBILITY_FLOATING_MENU_STATS"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_DATA_USAGE_BYTES_TRANSFER_V2: + return "ATOM_DATA_USAGE_BYTES_TRANSFER_V2"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIA_CAPABILITIES: + return "ATOM_MEDIA_CAPABILITIES"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_CAR_WATCHDOG_SYSTEM_IO_USAGE_SUMMARY: + return "ATOM_CAR_WATCHDOG_SYSTEM_IO_USAGE_SUMMARY"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_CAR_WATCHDOG_UID_IO_USAGE_SUMMARY: + return "ATOM_CAR_WATCHDOG_UID_IO_USAGE_SUMMARY"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_IMS_REGISTRATION_FEATURE_TAG_STATS: + return "ATOM_IMS_REGISTRATION_FEATURE_TAG_STATS"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_RCS_CLIENT_PROVISIONING_STATS: + return "ATOM_RCS_CLIENT_PROVISIONING_STATS"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_RCS_ACS_PROVISIONING_STATS: + return "ATOM_RCS_ACS_PROVISIONING_STATS"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_SIP_DELEGATE_STATS: + return "ATOM_SIP_DELEGATE_STATS"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_SIP_TRANSPORT_FEATURE_TAG_STATS: + return "ATOM_SIP_TRANSPORT_FEATURE_TAG_STATS"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_SIP_MESSAGE_RESPONSE: + return "ATOM_SIP_MESSAGE_RESPONSE"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_SIP_TRANSPORT_SESSION: + return "ATOM_SIP_TRANSPORT_SESSION"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_IMS_DEDICATED_BEARER_LISTENER_EVENT: + return "ATOM_IMS_DEDICATED_BEARER_LISTENER_EVENT"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_IMS_DEDICATED_BEARER_EVENT: + return "ATOM_IMS_DEDICATED_BEARER_EVENT"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_IMS_REGISTRATION_SERVICE_DESC_STATS: + return "ATOM_IMS_REGISTRATION_SERVICE_DESC_STATS"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_UCE_EVENT_STATS: + return "ATOM_UCE_EVENT_STATS"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_PRESENCE_NOTIFY_EVENT: + return "ATOM_PRESENCE_NOTIFY_EVENT"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_GBA_EVENT: + return "ATOM_GBA_EVENT"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_PER_SIM_STATUS: + return "ATOM_PER_SIM_STATUS"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_GPU_WORK_PER_UID: + return "ATOM_GPU_WORK_PER_UID"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_PERSISTENT_URI_PERMISSIONS_AMOUNT_PER_PACKAGE: + return "ATOM_PERSISTENT_URI_PERMISSIONS_AMOUNT_PER_PACKAGE"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_SIGNED_PARTITION_INFO: + return "ATOM_SIGNED_PARTITION_INFO"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_PINNED_FILE_SIZES_PER_PACKAGE: + return "ATOM_PINNED_FILE_SIZES_PER_PACKAGE"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_PENDING_INTENTS_PER_PACKAGE: + return "ATOM_PENDING_INTENTS_PER_PACKAGE"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_USER_INFO: + return "ATOM_USER_INFO"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_TELEPHONY_NETWORK_REQUESTS_V2: + return "ATOM_TELEPHONY_NETWORK_REQUESTS_V2"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_DEVICE_TELEPHONY_PROPERTIES: + return "ATOM_DEVICE_TELEPHONY_PROPERTIES"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_REMOTE_KEY_PROVISIONING_ERROR_COUNTS: + return "ATOM_REMOTE_KEY_PROVISIONING_ERROR_COUNTS"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_SAFETY_STATE: + return "ATOM_SAFETY_STATE"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_INCOMING_MMS: + return "ATOM_INCOMING_MMS"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_OUTGOING_MMS: + return "ATOM_OUTGOING_MMS"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_MULTI_USER_INFO: + return "ATOM_MULTI_USER_INFO"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_NETWORK_BPF_MAP_INFO: + return "ATOM_NETWORK_BPF_MAP_INFO"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_OUTGOING_SHORT_CODE_SMS: + return "ATOM_OUTGOING_SHORT_CODE_SMS"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_CONNECTIVITY_STATE_SAMPLE: + return "ATOM_CONNECTIVITY_STATE_SAMPLE"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_NETWORK_SELECTION_REMATCH_REASONS_INFO: + return "ATOM_NETWORK_SELECTION_REMATCH_REASONS_INFO"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_GAME_MODE_INFO: + return "ATOM_GAME_MODE_INFO"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_GAME_MODE_CONFIGURATION: + return "ATOM_GAME_MODE_CONFIGURATION"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_GAME_MODE_LISTENER: + return "ATOM_GAME_MODE_LISTENER"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_NETWORK_SLICE_REQUEST_COUNT: + return "ATOM_NETWORK_SLICE_REQUEST_COUNT"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_WS_TILE_SNAPSHOT: + return "ATOM_WS_TILE_SNAPSHOT"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_WS_ACTIVE_WATCH_FACE_COMPLICATION_SET_SNAPSHOT: + return "ATOM_WS_ACTIVE_WATCH_FACE_COMPLICATION_SET_SNAPSHOT"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_PROCESS_STATE: + return "ATOM_PROCESS_STATE"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_PROCESS_ASSOCIATION: + return "ATOM_PROCESS_ASSOCIATION"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_ADPF_SYSTEM_COMPONENT_INFO: + return "ATOM_ADPF_SYSTEM_COMPONENT_INFO"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_NOTIFICATION_MEMORY_USE: + return "ATOM_NOTIFICATION_MEMORY_USE"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_HDR_CAPABILITIES: + return "ATOM_HDR_CAPABILITIES"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_WS_FAVOURITE_WATCH_FACE_LIST_SNAPSHOT: + return "ATOM_WS_FAVOURITE_WATCH_FACE_LIST_SNAPSHOT"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_AWARE_NDP_REPORTED: + return "ATOM_WIFI_AWARE_NDP_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_AWARE_ATTACH_REPORTED: + return "ATOM_WIFI_AWARE_ATTACH_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_SELF_RECOVERY_TRIGGERED: + return "ATOM_WIFI_SELF_RECOVERY_TRIGGERED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_SOFT_AP_STARTED: + return "ATOM_SOFT_AP_STARTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_SOFT_AP_STOPPED: + return "ATOM_SOFT_AP_STOPPED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_LOCK_RELEASED: + return "ATOM_WIFI_LOCK_RELEASED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_LOCK_DEACTIVATED: + return "ATOM_WIFI_LOCK_DEACTIVATED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_CONFIG_SAVED: + return "ATOM_WIFI_CONFIG_SAVED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_AWARE_RESOURCE_USING_CHANGED: + return "ATOM_WIFI_AWARE_RESOURCE_USING_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_AWARE_HAL_API_CALLED: + return "ATOM_WIFI_AWARE_HAL_API_CALLED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_LOCAL_ONLY_REQUEST_RECEIVED: + return "ATOM_WIFI_LOCAL_ONLY_REQUEST_RECEIVED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_LOCAL_ONLY_REQUEST_SCAN_TRIGGERED: + return "ATOM_WIFI_LOCAL_ONLY_REQUEST_SCAN_TRIGGERED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_THREAD_TASK_EXECUTED: + return "ATOM_WIFI_THREAD_TASK_EXECUTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_STATE_CHANGED: + return "ATOM_WIFI_STATE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_AWARE_CAPABILITIES: + return "ATOM_WIFI_AWARE_CAPABILITIES"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_WIFI_MODULE_INFO: + return "ATOM_WIFI_MODULE_INFO"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_SETTINGS_SPA_REPORTED: + return "ATOM_SETTINGS_SPA_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_EXPRESS_EVENT_REPORTED: + return "ATOM_EXPRESS_EVENT_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_EXPRESS_HISTOGRAM_SAMPLE_REPORTED: + return "ATOM_EXPRESS_HISTOGRAM_SAMPLE_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_EXPRESS_UID_EVENT_REPORTED: + return "ATOM_EXPRESS_UID_EVENT_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_EXPRESS_UID_HISTOGRAM_SAMPLE_REPORTED: + return "ATOM_EXPRESS_UID_HISTOGRAM_SAMPLE_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_PERMISSION_RATIONALE_DIALOG_VIEWED: + return "ATOM_PERMISSION_RATIONALE_DIALOG_VIEWED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_PERMISSION_RATIONALE_DIALOG_ACTION_REPORTED: + return "ATOM_PERMISSION_RATIONALE_DIALOG_ACTION_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_APP_DATA_SHARING_UPDATES_NOTIFICATION_INTERACTION: + return "ATOM_APP_DATA_SHARING_UPDATES_NOTIFICATION_INTERACTION"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_APP_DATA_SHARING_UPDATES_FRAGMENT_VIEWED: + return "ATOM_APP_DATA_SHARING_UPDATES_FRAGMENT_VIEWED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_APP_DATA_SHARING_UPDATES_FRAGMENT_ACTION_REPORTED: + return "ATOM_APP_DATA_SHARING_UPDATES_FRAGMENT_ACTION_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_WS_INCOMING_CALL_ACTION_REPORTED: + return "ATOM_WS_INCOMING_CALL_ACTION_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_WS_CALL_DISCONNECTION_REPORTED: + return "ATOM_WS_CALL_DISCONNECTION_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_WS_CALL_DURATION_REPORTED: + return "ATOM_WS_CALL_DURATION_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_WS_CALL_USER_EXPERIENCE_LATENCY_REPORTED: + return "ATOM_WS_CALL_USER_EXPERIENCE_LATENCY_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_WS_CALL_INTERACTION_REPORTED: + return "ATOM_WS_CALL_INTERACTION_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_FULL_SCREEN_INTENT_LAUNCHED: + return "ATOM_FULL_SCREEN_INTENT_LAUNCHED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BAL_ALLOWED: + return "ATOM_BAL_ALLOWED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_IN_TASK_ACTIVITY_STARTED: + return "ATOM_IN_TASK_ACTIVITY_STARTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_CACHED_APPS_HIGH_WATERMARK: + return "ATOM_CACHED_APPS_HIGH_WATERMARK"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_ODREFRESH_REPORTED: + return "ATOM_ODREFRESH_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_ODSIGN_REPORTED: + return "ATOM_ODSIGN_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_ART_DATUM_REPORTED: + return "ATOM_ART_DATUM_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_ART_DEVICE_DATUM_REPORTED: + return "ATOM_ART_DEVICE_DATUM_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_ART_DATUM_DELTA_REPORTED: + return "ATOM_ART_DATUM_DELTA_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BACKGROUND_DEXOPT_JOB_ENDED: + return "ATOM_BACKGROUND_DEXOPT_JOB_ENDED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_WEAR_ADAPTIVE_SUSPEND_STATS_REPORTED: + return "ATOM_WEAR_ADAPTIVE_SUSPEND_STATS_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_WEAR_POWER_ANOMALY_SERVICE_OPERATIONAL_STATS_REPORTED: + return "ATOM_WEAR_POWER_ANOMALY_SERVICE_OPERATIONAL_STATS_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_WEAR_POWER_ANOMALY_SERVICE_EVENT_STATS_REPORTED: + return "ATOM_WEAR_POWER_ANOMALY_SERVICE_EVENT_STATS_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_EMERGENCY_STATE_CHANGED: + return "ATOM_EMERGENCY_STATE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_DND_STATE_CHANGED: + return "ATOM_DND_STATE_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_MTE_STATE: + return "ATOM_MTE_STATE"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_BACK_COMPAT_GET_TOPICS_REPORTED: + return "ATOM_AD_SERVICES_BACK_COMPAT_GET_TOPICS_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_BACK_COMPAT_EPOCH_COMPUTATION_CLASSIFIER_REPORTED: + return "ATOM_AD_SERVICES_BACK_COMPAT_EPOCH_COMPUTATION_CLASSIFIER_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_MEASUREMENT_DEBUG_KEYS: + return "ATOM_AD_SERVICES_MEASUREMENT_DEBUG_KEYS"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_ERROR_REPORTED: + return "ATOM_AD_SERVICES_ERROR_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_BACKGROUND_JOBS_EXECUTION_REPORTED: + return "ATOM_AD_SERVICES_BACKGROUND_JOBS_EXECUTION_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_MEASUREMENT_DELAYED_SOURCE_REGISTRATION: + return "ATOM_AD_SERVICES_MEASUREMENT_DELAYED_SOURCE_REGISTRATION"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_MEASUREMENT_ATTRIBUTION: + return "ATOM_AD_SERVICES_MEASUREMENT_ATTRIBUTION"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_MEASUREMENT_JOBS: + return "ATOM_AD_SERVICES_MEASUREMENT_JOBS"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_MEASUREMENT_WIPEOUT: + return "ATOM_AD_SERVICES_MEASUREMENT_WIPEOUT"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_AD_SERVICES_CONSENT_MIGRATED: + return "ATOM_AD_SERVICES_CONSENT_MIGRATED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_RKPD_POOL_STATS: + return "ATOM_RKPD_POOL_STATS"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_RKPD_CLIENT_OPERATION: + return "ATOM_RKPD_CLIENT_OPERATION"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_AUTOFILL_UI_EVENT_REPORTED: + return "ATOM_AUTOFILL_UI_EVENT_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_AUTOFILL_FILL_REQUEST_REPORTED: + return "ATOM_AUTOFILL_FILL_REQUEST_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_AUTOFILL_FILL_RESPONSE_REPORTED: + return "ATOM_AUTOFILL_FILL_RESPONSE_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_AUTOFILL_SAVE_EVENT_REPORTED: + return "ATOM_AUTOFILL_SAVE_EVENT_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_AUTOFILL_SESSION_COMMITTED: + return "ATOM_AUTOFILL_SESSION_COMMITTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_AUTOFILL_FIELD_CLASSIFICATION_EVENT_REPORTED: + return "ATOM_AUTOFILL_FIELD_CLASSIFICATION_EVENT_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_TEST_EXTENSION_ATOM_REPORTED: + return "ATOM_TEST_EXTENSION_ATOM_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_TEST_RESTRICTED_ATOM_REPORTED: + return "ATOM_TEST_RESTRICTED_ATOM_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_STATS_SOCKET_LOSS_REPORTED: + return "ATOM_STATS_SOCKET_LOSS_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_PLUGIN_INITIALIZED: + return "ATOM_PLUGIN_INITIALIZED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_TV_LOW_POWER_STANDBY_POLICY: + return "ATOM_TV_LOW_POWER_STANDBY_POLICY"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_LOCKSCREEN_SHORTCUT_SELECTED: + return "ATOM_LOCKSCREEN_SHORTCUT_SELECTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_LOCKSCREEN_SHORTCUT_TRIGGERED: + return "ATOM_LOCKSCREEN_SHORTCUT_TRIGGERED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_EMERGENCY_NUMBERS_INFO: + return "ATOM_EMERGENCY_NUMBERS_INFO"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_QUALIFIED_RAT_LIST_CHANGED: + return "ATOM_QUALIFIED_RAT_LIST_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_QNS_IMS_CALL_DROP_STATS: + return "ATOM_QNS_IMS_CALL_DROP_STATS"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_QNS_FALLBACK_RESTRICTION_CHANGED: + return "ATOM_QNS_FALLBACK_RESTRICTION_CHANGED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_QNS_RAT_PREFERENCE_MISMATCH_INFO: + return "ATOM_QNS_RAT_PREFERENCE_MISMATCH_INFO"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_QNS_HANDOVER_TIME_MILLIS: + return "ATOM_QNS_HANDOVER_TIME_MILLIS"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_QNS_HANDOVER_PINGPONG: + return "ATOM_QNS_HANDOVER_PINGPONG"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_SATELLITE_CONTROLLER: + return "ATOM_SATELLITE_CONTROLLER"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_SATELLITE_SESSION: + return "ATOM_SATELLITE_SESSION"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_SATELLITE_INCOMING_DATAGRAM: + return "ATOM_SATELLITE_INCOMING_DATAGRAM"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_SATELLITE_OUTGOING_DATAGRAM: + return "ATOM_SATELLITE_OUTGOING_DATAGRAM"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_SATELLITE_PROVISION: + return "ATOM_SATELLITE_PROVISION"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_SATELLITE_SOS_MESSAGE_RECOMMENDER: + return "ATOM_SATELLITE_SOS_MESSAGE_RECOMMENDER"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_IKE_SESSION_TERMINATED: + return "ATOM_IKE_SESSION_TERMINATED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_IKE_LIVENESS_CHECK_SESSION_VALIDATED: + return "ATOM_IKE_LIVENESS_CHECK_SESSION_VALIDATED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_HASHED_DEVICE_NAME_REPORTED: + return "ATOM_BLUETOOTH_HASHED_DEVICE_NAME_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_L2CAP_COC_CLIENT_CONNECTION: + return "ATOM_BLUETOOTH_L2CAP_COC_CLIENT_CONNECTION"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_L2CAP_COC_SERVER_CONNECTION: + return "ATOM_BLUETOOTH_L2CAP_COC_SERVER_CONNECTION"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_LE_SESSION_CONNECTED: + return "ATOM_BLUETOOTH_LE_SESSION_CONNECTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_RESTRICTED_BLUETOOTH_DEVICE_NAME_REPORTED: + return "ATOM_RESTRICTED_BLUETOOTH_DEVICE_NAME_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_BLUETOOTH_PROFILE_CONNECTION_ATTEMPTED: + return "ATOM_BLUETOOTH_PROFILE_CONNECTION_ATTEMPTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_HEALTH_CONNECT_UI_IMPRESSION: + return "ATOM_HEALTH_CONNECT_UI_IMPRESSION"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_HEALTH_CONNECT_UI_INTERACTION: + return "ATOM_HEALTH_CONNECT_UI_INTERACTION"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_HEALTH_CONNECT_APP_OPENED_REPORTED: + return "ATOM_HEALTH_CONNECT_APP_OPENED_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_HEALTH_CONNECT_API_CALLED: + return "ATOM_HEALTH_CONNECT_API_CALLED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_HEALTH_CONNECT_USAGE_STATS: + return "ATOM_HEALTH_CONNECT_USAGE_STATS"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_HEALTH_CONNECT_STORAGE_STATS: + return "ATOM_HEALTH_CONNECT_STORAGE_STATS"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_HEALTH_CONNECT_API_INVOKED: + return "ATOM_HEALTH_CONNECT_API_INVOKED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_EXERCISE_ROUTE_API_CALLED: + return "ATOM_EXERCISE_ROUTE_API_CALLED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_ATOM_9999: + return "ATOM_ATOM_9999"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_ATOM_99999: + return "ATOM_ATOM_99999"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_THREADNETWORK_TELEMETRY_DATA_REPORTED: + return "ATOM_THREADNETWORK_TELEMETRY_DATA_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_THREADNETWORK_TOPO_ENTRY_REPEATED: + return "ATOM_THREADNETWORK_TOPO_ENTRY_REPEATED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_THREADNETWORK_DEVICE_INFO_REPORTED: + return "ATOM_THREADNETWORK_DEVICE_INFO_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_EMERGENCY_NUMBER_DIALED: + return "ATOM_EMERGENCY_NUMBER_DIALED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_SANDBOX_API_CALLED: + return "ATOM_SANDBOX_API_CALLED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_SANDBOX_ACTIVITY_EVENT_OCCURRED: + return "ATOM_SANDBOX_ACTIVITY_EVENT_OCCURRED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_SANDBOX_SDK_STORAGE: + return "ATOM_SANDBOX_SDK_STORAGE"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_CRONET_ENGINE_CREATED: + return "ATOM_CRONET_ENGINE_CREATED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_CRONET_TRAFFIC_REPORTED: + return "ATOM_CRONET_TRAFFIC_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_CRONET_ENGINE_BUILDER_INITIALIZED: + return "ATOM_CRONET_ENGINE_BUILDER_INITIALIZED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_CRONET_HTTP_FLAGS_INITIALIZED: + return "ATOM_CRONET_HTTP_FLAGS_INITIALIZED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_CRONET_INITIALIZED: + return "ATOM_CRONET_INITIALIZED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_DAILY_KEEPALIVE_INFO_REPORTED: + return "ATOM_DAILY_KEEPALIVE_INFO_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_IP_CLIENT_RA_INFO_REPORTED: + return "ATOM_IP_CLIENT_RA_INFO_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_APF_SESSION_INFO_REPORTED: + return "ATOM_APF_SESSION_INFO_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_CREDENTIAL_MANAGER_API_CALLED: + return "ATOM_CREDENTIAL_MANAGER_API_CALLED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_CREDENTIAL_MANAGER_INIT_PHASE_REPORTED: + return "ATOM_CREDENTIAL_MANAGER_INIT_PHASE_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_CREDENTIAL_MANAGER_CANDIDATE_PHASE_REPORTED: + return "ATOM_CREDENTIAL_MANAGER_CANDIDATE_PHASE_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_CREDENTIAL_MANAGER_FINAL_PHASE_REPORTED: + return "ATOM_CREDENTIAL_MANAGER_FINAL_PHASE_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_CREDENTIAL_MANAGER_TOTAL_REPORTED: + return "ATOM_CREDENTIAL_MANAGER_TOTAL_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_CREDENTIAL_MANAGER_FINALNOUID_REPORTED: + return "ATOM_CREDENTIAL_MANAGER_FINALNOUID_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_CREDENTIAL_MANAGER_GET_REPORTED: + return "ATOM_CREDENTIAL_MANAGER_GET_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_CREDENTIAL_MANAGER_AUTH_CLICK_REPORTED: + return "ATOM_CREDENTIAL_MANAGER_AUTH_CLICK_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_CREDENTIAL_MANAGER_APIV2_CALLED: + return "ATOM_CREDENTIAL_MANAGER_APIV2_CALLED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_UWB_ACTIVITY_INFO: + return "ATOM_UWB_ACTIVITY_INFO"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIA_ACTION_REPORTED: + return "ATOM_MEDIA_ACTION_REPORTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIA_CONTROLS_LAUNCHED: + return "ATOM_MEDIA_CONTROLS_LAUNCHED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIA_CODEC_RECLAIM_REQUEST_COMPLETED: + return "ATOM_MEDIA_CODEC_RECLAIM_REQUEST_COMPLETED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIA_CODEC_STARTED: + return "ATOM_MEDIA_CODEC_STARTED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIA_CODEC_STOPPED: + return "ATOM_MEDIA_CODEC_STOPPED"; + + case ::perfetto::protos::pbzero::AtomId::ATOM_MEDIA_CODEC_RENDERED: + return "ATOM_MEDIA_CODEC_RENDERED"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +enum MeminfoCounters : int32_t { + MEMINFO_UNSPECIFIED = 0, + MEMINFO_MEM_TOTAL = 1, + MEMINFO_MEM_FREE = 2, + MEMINFO_MEM_AVAILABLE = 3, + MEMINFO_BUFFERS = 4, + MEMINFO_CACHED = 5, + MEMINFO_SWAP_CACHED = 6, + MEMINFO_ACTIVE = 7, + MEMINFO_INACTIVE = 8, + MEMINFO_ACTIVE_ANON = 9, + MEMINFO_INACTIVE_ANON = 10, + MEMINFO_ACTIVE_FILE = 11, + MEMINFO_INACTIVE_FILE = 12, + MEMINFO_UNEVICTABLE = 13, + MEMINFO_MLOCKED = 14, + MEMINFO_SWAP_TOTAL = 15, + MEMINFO_SWAP_FREE = 16, + MEMINFO_DIRTY = 17, + MEMINFO_WRITEBACK = 18, + MEMINFO_ANON_PAGES = 19, + MEMINFO_MAPPED = 20, + MEMINFO_SHMEM = 21, + MEMINFO_SLAB = 22, + MEMINFO_SLAB_RECLAIMABLE = 23, + MEMINFO_SLAB_UNRECLAIMABLE = 24, + MEMINFO_KERNEL_STACK = 25, + MEMINFO_PAGE_TABLES = 26, + MEMINFO_COMMIT_LIMIT = 27, + MEMINFO_COMMITED_AS = 28, + MEMINFO_VMALLOC_TOTAL = 29, + MEMINFO_VMALLOC_USED = 30, + MEMINFO_VMALLOC_CHUNK = 31, + MEMINFO_CMA_TOTAL = 32, + MEMINFO_CMA_FREE = 33, +}; + +constexpr MeminfoCounters MeminfoCounters_MIN = MeminfoCounters::MEMINFO_UNSPECIFIED; +constexpr MeminfoCounters MeminfoCounters_MAX = MeminfoCounters::MEMINFO_CMA_FREE; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* MeminfoCounters_Name(::perfetto::protos::pbzero::MeminfoCounters value) { + switch (value) { + case ::perfetto::protos::pbzero::MeminfoCounters::MEMINFO_UNSPECIFIED: + return "MEMINFO_UNSPECIFIED"; + + case ::perfetto::protos::pbzero::MeminfoCounters::MEMINFO_MEM_TOTAL: + return "MEMINFO_MEM_TOTAL"; + + case ::perfetto::protos::pbzero::MeminfoCounters::MEMINFO_MEM_FREE: + return "MEMINFO_MEM_FREE"; + + case ::perfetto::protos::pbzero::MeminfoCounters::MEMINFO_MEM_AVAILABLE: + return "MEMINFO_MEM_AVAILABLE"; + + case ::perfetto::protos::pbzero::MeminfoCounters::MEMINFO_BUFFERS: + return "MEMINFO_BUFFERS"; + + case ::perfetto::protos::pbzero::MeminfoCounters::MEMINFO_CACHED: + return "MEMINFO_CACHED"; + + case ::perfetto::protos::pbzero::MeminfoCounters::MEMINFO_SWAP_CACHED: + return "MEMINFO_SWAP_CACHED"; + + case ::perfetto::protos::pbzero::MeminfoCounters::MEMINFO_ACTIVE: + return "MEMINFO_ACTIVE"; + + case ::perfetto::protos::pbzero::MeminfoCounters::MEMINFO_INACTIVE: + return "MEMINFO_INACTIVE"; + + case ::perfetto::protos::pbzero::MeminfoCounters::MEMINFO_ACTIVE_ANON: + return "MEMINFO_ACTIVE_ANON"; + + case ::perfetto::protos::pbzero::MeminfoCounters::MEMINFO_INACTIVE_ANON: + return "MEMINFO_INACTIVE_ANON"; + + case ::perfetto::protos::pbzero::MeminfoCounters::MEMINFO_ACTIVE_FILE: + return "MEMINFO_ACTIVE_FILE"; + + case ::perfetto::protos::pbzero::MeminfoCounters::MEMINFO_INACTIVE_FILE: + return "MEMINFO_INACTIVE_FILE"; + + case ::perfetto::protos::pbzero::MeminfoCounters::MEMINFO_UNEVICTABLE: + return "MEMINFO_UNEVICTABLE"; + + case ::perfetto::protos::pbzero::MeminfoCounters::MEMINFO_MLOCKED: + return "MEMINFO_MLOCKED"; + + case ::perfetto::protos::pbzero::MeminfoCounters::MEMINFO_SWAP_TOTAL: + return "MEMINFO_SWAP_TOTAL"; + + case ::perfetto::protos::pbzero::MeminfoCounters::MEMINFO_SWAP_FREE: + return "MEMINFO_SWAP_FREE"; + + case ::perfetto::protos::pbzero::MeminfoCounters::MEMINFO_DIRTY: + return "MEMINFO_DIRTY"; + + case ::perfetto::protos::pbzero::MeminfoCounters::MEMINFO_WRITEBACK: + return "MEMINFO_WRITEBACK"; + + case ::perfetto::protos::pbzero::MeminfoCounters::MEMINFO_ANON_PAGES: + return "MEMINFO_ANON_PAGES"; + + case ::perfetto::protos::pbzero::MeminfoCounters::MEMINFO_MAPPED: + return "MEMINFO_MAPPED"; + + case ::perfetto::protos::pbzero::MeminfoCounters::MEMINFO_SHMEM: + return "MEMINFO_SHMEM"; + + case ::perfetto::protos::pbzero::MeminfoCounters::MEMINFO_SLAB: + return "MEMINFO_SLAB"; + + case ::perfetto::protos::pbzero::MeminfoCounters::MEMINFO_SLAB_RECLAIMABLE: + return "MEMINFO_SLAB_RECLAIMABLE"; + + case ::perfetto::protos::pbzero::MeminfoCounters::MEMINFO_SLAB_UNRECLAIMABLE: + return "MEMINFO_SLAB_UNRECLAIMABLE"; + + case ::perfetto::protos::pbzero::MeminfoCounters::MEMINFO_KERNEL_STACK: + return "MEMINFO_KERNEL_STACK"; + + case ::perfetto::protos::pbzero::MeminfoCounters::MEMINFO_PAGE_TABLES: + return "MEMINFO_PAGE_TABLES"; + + case ::perfetto::protos::pbzero::MeminfoCounters::MEMINFO_COMMIT_LIMIT: + return "MEMINFO_COMMIT_LIMIT"; + + case ::perfetto::protos::pbzero::MeminfoCounters::MEMINFO_COMMITED_AS: + return "MEMINFO_COMMITED_AS"; + + case ::perfetto::protos::pbzero::MeminfoCounters::MEMINFO_VMALLOC_TOTAL: + return "MEMINFO_VMALLOC_TOTAL"; + + case ::perfetto::protos::pbzero::MeminfoCounters::MEMINFO_VMALLOC_USED: + return "MEMINFO_VMALLOC_USED"; + + case ::perfetto::protos::pbzero::MeminfoCounters::MEMINFO_VMALLOC_CHUNK: + return "MEMINFO_VMALLOC_CHUNK"; + + case ::perfetto::protos::pbzero::MeminfoCounters::MEMINFO_CMA_TOTAL: + return "MEMINFO_CMA_TOTAL"; + + case ::perfetto::protos::pbzero::MeminfoCounters::MEMINFO_CMA_FREE: + return "MEMINFO_CMA_FREE"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +enum VmstatCounters : int32_t { + VMSTAT_UNSPECIFIED = 0, + VMSTAT_NR_FREE_PAGES = 1, + VMSTAT_NR_ALLOC_BATCH = 2, + VMSTAT_NR_INACTIVE_ANON = 3, + VMSTAT_NR_ACTIVE_ANON = 4, + VMSTAT_NR_INACTIVE_FILE = 5, + VMSTAT_NR_ACTIVE_FILE = 6, + VMSTAT_NR_UNEVICTABLE = 7, + VMSTAT_NR_MLOCK = 8, + VMSTAT_NR_ANON_PAGES = 9, + VMSTAT_NR_MAPPED = 10, + VMSTAT_NR_FILE_PAGES = 11, + VMSTAT_NR_DIRTY = 12, + VMSTAT_NR_WRITEBACK = 13, + VMSTAT_NR_SLAB_RECLAIMABLE = 14, + VMSTAT_NR_SLAB_UNRECLAIMABLE = 15, + VMSTAT_NR_PAGE_TABLE_PAGES = 16, + VMSTAT_NR_KERNEL_STACK = 17, + VMSTAT_NR_OVERHEAD = 18, + VMSTAT_NR_UNSTABLE = 19, + VMSTAT_NR_BOUNCE = 20, + VMSTAT_NR_VMSCAN_WRITE = 21, + VMSTAT_NR_VMSCAN_IMMEDIATE_RECLAIM = 22, + VMSTAT_NR_WRITEBACK_TEMP = 23, + VMSTAT_NR_ISOLATED_ANON = 24, + VMSTAT_NR_ISOLATED_FILE = 25, + VMSTAT_NR_SHMEM = 26, + VMSTAT_NR_DIRTIED = 27, + VMSTAT_NR_WRITTEN = 28, + VMSTAT_NR_PAGES_SCANNED = 29, + VMSTAT_WORKINGSET_REFAULT = 30, + VMSTAT_WORKINGSET_ACTIVATE = 31, + VMSTAT_WORKINGSET_NODERECLAIM = 32, + VMSTAT_NR_ANON_TRANSPARENT_HUGEPAGES = 33, + VMSTAT_NR_FREE_CMA = 34, + VMSTAT_NR_SWAPCACHE = 35, + VMSTAT_NR_DIRTY_THRESHOLD = 36, + VMSTAT_NR_DIRTY_BACKGROUND_THRESHOLD = 37, + VMSTAT_PGPGIN = 38, + VMSTAT_PGPGOUT = 39, + VMSTAT_PGPGOUTCLEAN = 40, + VMSTAT_PSWPIN = 41, + VMSTAT_PSWPOUT = 42, + VMSTAT_PGALLOC_DMA = 43, + VMSTAT_PGALLOC_NORMAL = 44, + VMSTAT_PGALLOC_MOVABLE = 45, + VMSTAT_PGFREE = 46, + VMSTAT_PGACTIVATE = 47, + VMSTAT_PGDEACTIVATE = 48, + VMSTAT_PGFAULT = 49, + VMSTAT_PGMAJFAULT = 50, + VMSTAT_PGREFILL_DMA = 51, + VMSTAT_PGREFILL_NORMAL = 52, + VMSTAT_PGREFILL_MOVABLE = 53, + VMSTAT_PGSTEAL_KSWAPD_DMA = 54, + VMSTAT_PGSTEAL_KSWAPD_NORMAL = 55, + VMSTAT_PGSTEAL_KSWAPD_MOVABLE = 56, + VMSTAT_PGSTEAL_DIRECT_DMA = 57, + VMSTAT_PGSTEAL_DIRECT_NORMAL = 58, + VMSTAT_PGSTEAL_DIRECT_MOVABLE = 59, + VMSTAT_PGSCAN_KSWAPD_DMA = 60, + VMSTAT_PGSCAN_KSWAPD_NORMAL = 61, + VMSTAT_PGSCAN_KSWAPD_MOVABLE = 62, + VMSTAT_PGSCAN_DIRECT_DMA = 63, + VMSTAT_PGSCAN_DIRECT_NORMAL = 64, + VMSTAT_PGSCAN_DIRECT_MOVABLE = 65, + VMSTAT_PGSCAN_DIRECT_THROTTLE = 66, + VMSTAT_PGINODESTEAL = 67, + VMSTAT_SLABS_SCANNED = 68, + VMSTAT_KSWAPD_INODESTEAL = 69, + VMSTAT_KSWAPD_LOW_WMARK_HIT_QUICKLY = 70, + VMSTAT_KSWAPD_HIGH_WMARK_HIT_QUICKLY = 71, + VMSTAT_PAGEOUTRUN = 72, + VMSTAT_ALLOCSTALL = 73, + VMSTAT_PGROTATED = 74, + VMSTAT_DROP_PAGECACHE = 75, + VMSTAT_DROP_SLAB = 76, + VMSTAT_PGMIGRATE_SUCCESS = 77, + VMSTAT_PGMIGRATE_FAIL = 78, + VMSTAT_COMPACT_MIGRATE_SCANNED = 79, + VMSTAT_COMPACT_FREE_SCANNED = 80, + VMSTAT_COMPACT_ISOLATED = 81, + VMSTAT_COMPACT_STALL = 82, + VMSTAT_COMPACT_FAIL = 83, + VMSTAT_COMPACT_SUCCESS = 84, + VMSTAT_COMPACT_DAEMON_WAKE = 85, + VMSTAT_UNEVICTABLE_PGS_CULLED = 86, + VMSTAT_UNEVICTABLE_PGS_SCANNED = 87, + VMSTAT_UNEVICTABLE_PGS_RESCUED = 88, + VMSTAT_UNEVICTABLE_PGS_MLOCKED = 89, + VMSTAT_UNEVICTABLE_PGS_MUNLOCKED = 90, + VMSTAT_UNEVICTABLE_PGS_CLEARED = 91, + VMSTAT_UNEVICTABLE_PGS_STRANDED = 92, + VMSTAT_NR_ZSPAGES = 93, + VMSTAT_NR_ION_HEAP = 94, + VMSTAT_NR_GPU_HEAP = 95, + VMSTAT_ALLOCSTALL_DMA = 96, + VMSTAT_ALLOCSTALL_MOVABLE = 97, + VMSTAT_ALLOCSTALL_NORMAL = 98, + VMSTAT_COMPACT_DAEMON_FREE_SCANNED = 99, + VMSTAT_COMPACT_DAEMON_MIGRATE_SCANNED = 100, + VMSTAT_NR_FASTRPC = 101, + VMSTAT_NR_INDIRECTLY_RECLAIMABLE = 102, + VMSTAT_NR_ION_HEAP_POOL = 103, + VMSTAT_NR_KERNEL_MISC_RECLAIMABLE = 104, + VMSTAT_NR_SHADOW_CALL_STACK_BYTES = 105, + VMSTAT_NR_SHMEM_HUGEPAGES = 106, + VMSTAT_NR_SHMEM_PMDMAPPED = 107, + VMSTAT_NR_UNRECLAIMABLE_PAGES = 108, + VMSTAT_NR_ZONE_ACTIVE_ANON = 109, + VMSTAT_NR_ZONE_ACTIVE_FILE = 110, + VMSTAT_NR_ZONE_INACTIVE_ANON = 111, + VMSTAT_NR_ZONE_INACTIVE_FILE = 112, + VMSTAT_NR_ZONE_UNEVICTABLE = 113, + VMSTAT_NR_ZONE_WRITE_PENDING = 114, + VMSTAT_OOM_KILL = 115, + VMSTAT_PGLAZYFREE = 116, + VMSTAT_PGLAZYFREED = 117, + VMSTAT_PGREFILL = 118, + VMSTAT_PGSCAN_DIRECT = 119, + VMSTAT_PGSCAN_KSWAPD = 120, + VMSTAT_PGSKIP_DMA = 121, + VMSTAT_PGSKIP_MOVABLE = 122, + VMSTAT_PGSKIP_NORMAL = 123, + VMSTAT_PGSTEAL_DIRECT = 124, + VMSTAT_PGSTEAL_KSWAPD = 125, + VMSTAT_SWAP_RA = 126, + VMSTAT_SWAP_RA_HIT = 127, + VMSTAT_WORKINGSET_RESTORE = 128, + VMSTAT_ALLOCSTALL_DEVICE = 129, + VMSTAT_ALLOCSTALL_DMA32 = 130, + VMSTAT_BALLOON_DEFLATE = 131, + VMSTAT_BALLOON_INFLATE = 132, + VMSTAT_BALLOON_MIGRATE = 133, + VMSTAT_CMA_ALLOC_FAIL = 134, + VMSTAT_CMA_ALLOC_SUCCESS = 135, + VMSTAT_NR_FILE_HUGEPAGES = 136, + VMSTAT_NR_FILE_PMDMAPPED = 137, + VMSTAT_NR_FOLL_PIN_ACQUIRED = 138, + VMSTAT_NR_FOLL_PIN_RELEASED = 139, + VMSTAT_NR_SEC_PAGE_TABLE_PAGES = 140, + VMSTAT_NR_SHADOW_CALL_STACK = 141, + VMSTAT_NR_SWAPCACHED = 142, + VMSTAT_NR_THROTTLED_WRITTEN = 143, + VMSTAT_PGALLOC_DEVICE = 144, + VMSTAT_PGALLOC_DMA32 = 145, + VMSTAT_PGDEMOTE_DIRECT = 146, + VMSTAT_PGDEMOTE_KSWAPD = 147, + VMSTAT_PGREUSE = 148, + VMSTAT_PGSCAN_ANON = 149, + VMSTAT_PGSCAN_FILE = 150, + VMSTAT_PGSKIP_DEVICE = 151, + VMSTAT_PGSKIP_DMA32 = 152, + VMSTAT_PGSTEAL_ANON = 153, + VMSTAT_PGSTEAL_FILE = 154, + VMSTAT_THP_COLLAPSE_ALLOC = 155, + VMSTAT_THP_COLLAPSE_ALLOC_FAILED = 156, + VMSTAT_THP_DEFERRED_SPLIT_PAGE = 157, + VMSTAT_THP_FAULT_ALLOC = 158, + VMSTAT_THP_FAULT_FALLBACK = 159, + VMSTAT_THP_FAULT_FALLBACK_CHARGE = 160, + VMSTAT_THP_FILE_ALLOC = 161, + VMSTAT_THP_FILE_FALLBACK = 162, + VMSTAT_THP_FILE_FALLBACK_CHARGE = 163, + VMSTAT_THP_FILE_MAPPED = 164, + VMSTAT_THP_MIGRATION_FAIL = 165, + VMSTAT_THP_MIGRATION_SPLIT = 166, + VMSTAT_THP_MIGRATION_SUCCESS = 167, + VMSTAT_THP_SCAN_EXCEED_NONE_PTE = 168, + VMSTAT_THP_SCAN_EXCEED_SHARE_PTE = 169, + VMSTAT_THP_SCAN_EXCEED_SWAP_PTE = 170, + VMSTAT_THP_SPLIT_PAGE = 171, + VMSTAT_THP_SPLIT_PAGE_FAILED = 172, + VMSTAT_THP_SPLIT_PMD = 173, + VMSTAT_THP_SWPOUT = 174, + VMSTAT_THP_SWPOUT_FALLBACK = 175, + VMSTAT_THP_ZERO_PAGE_ALLOC = 176, + VMSTAT_THP_ZERO_PAGE_ALLOC_FAILED = 177, + VMSTAT_VMA_LOCK_ABORT = 178, + VMSTAT_VMA_LOCK_MISS = 179, + VMSTAT_VMA_LOCK_RETRY = 180, + VMSTAT_VMA_LOCK_SUCCESS = 181, + VMSTAT_WORKINGSET_ACTIVATE_ANON = 182, + VMSTAT_WORKINGSET_ACTIVATE_FILE = 183, + VMSTAT_WORKINGSET_NODES = 184, + VMSTAT_WORKINGSET_REFAULT_ANON = 185, + VMSTAT_WORKINGSET_REFAULT_FILE = 186, + VMSTAT_WORKINGSET_RESTORE_ANON = 187, + VMSTAT_WORKINGSET_RESTORE_FILE = 188, +}; + +constexpr VmstatCounters VmstatCounters_MIN = VmstatCounters::VMSTAT_UNSPECIFIED; +constexpr VmstatCounters VmstatCounters_MAX = VmstatCounters::VMSTAT_WORKINGSET_RESTORE_FILE; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* VmstatCounters_Name(::perfetto::protos::pbzero::VmstatCounters value) { + switch (value) { + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_UNSPECIFIED: + return "VMSTAT_UNSPECIFIED"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_NR_FREE_PAGES: + return "VMSTAT_NR_FREE_PAGES"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_NR_ALLOC_BATCH: + return "VMSTAT_NR_ALLOC_BATCH"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_NR_INACTIVE_ANON: + return "VMSTAT_NR_INACTIVE_ANON"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_NR_ACTIVE_ANON: + return "VMSTAT_NR_ACTIVE_ANON"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_NR_INACTIVE_FILE: + return "VMSTAT_NR_INACTIVE_FILE"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_NR_ACTIVE_FILE: + return "VMSTAT_NR_ACTIVE_FILE"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_NR_UNEVICTABLE: + return "VMSTAT_NR_UNEVICTABLE"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_NR_MLOCK: + return "VMSTAT_NR_MLOCK"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_NR_ANON_PAGES: + return "VMSTAT_NR_ANON_PAGES"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_NR_MAPPED: + return "VMSTAT_NR_MAPPED"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_NR_FILE_PAGES: + return "VMSTAT_NR_FILE_PAGES"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_NR_DIRTY: + return "VMSTAT_NR_DIRTY"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_NR_WRITEBACK: + return "VMSTAT_NR_WRITEBACK"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_NR_SLAB_RECLAIMABLE: + return "VMSTAT_NR_SLAB_RECLAIMABLE"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_NR_SLAB_UNRECLAIMABLE: + return "VMSTAT_NR_SLAB_UNRECLAIMABLE"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_NR_PAGE_TABLE_PAGES: + return "VMSTAT_NR_PAGE_TABLE_PAGES"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_NR_KERNEL_STACK: + return "VMSTAT_NR_KERNEL_STACK"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_NR_OVERHEAD: + return "VMSTAT_NR_OVERHEAD"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_NR_UNSTABLE: + return "VMSTAT_NR_UNSTABLE"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_NR_BOUNCE: + return "VMSTAT_NR_BOUNCE"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_NR_VMSCAN_WRITE: + return "VMSTAT_NR_VMSCAN_WRITE"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_NR_VMSCAN_IMMEDIATE_RECLAIM: + return "VMSTAT_NR_VMSCAN_IMMEDIATE_RECLAIM"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_NR_WRITEBACK_TEMP: + return "VMSTAT_NR_WRITEBACK_TEMP"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_NR_ISOLATED_ANON: + return "VMSTAT_NR_ISOLATED_ANON"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_NR_ISOLATED_FILE: + return "VMSTAT_NR_ISOLATED_FILE"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_NR_SHMEM: + return "VMSTAT_NR_SHMEM"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_NR_DIRTIED: + return "VMSTAT_NR_DIRTIED"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_NR_WRITTEN: + return "VMSTAT_NR_WRITTEN"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_NR_PAGES_SCANNED: + return "VMSTAT_NR_PAGES_SCANNED"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_WORKINGSET_REFAULT: + return "VMSTAT_WORKINGSET_REFAULT"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_WORKINGSET_ACTIVATE: + return "VMSTAT_WORKINGSET_ACTIVATE"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_WORKINGSET_NODERECLAIM: + return "VMSTAT_WORKINGSET_NODERECLAIM"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_NR_ANON_TRANSPARENT_HUGEPAGES: + return "VMSTAT_NR_ANON_TRANSPARENT_HUGEPAGES"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_NR_FREE_CMA: + return "VMSTAT_NR_FREE_CMA"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_NR_SWAPCACHE: + return "VMSTAT_NR_SWAPCACHE"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_NR_DIRTY_THRESHOLD: + return "VMSTAT_NR_DIRTY_THRESHOLD"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_NR_DIRTY_BACKGROUND_THRESHOLD: + return "VMSTAT_NR_DIRTY_BACKGROUND_THRESHOLD"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_PGPGIN: + return "VMSTAT_PGPGIN"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_PGPGOUT: + return "VMSTAT_PGPGOUT"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_PGPGOUTCLEAN: + return "VMSTAT_PGPGOUTCLEAN"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_PSWPIN: + return "VMSTAT_PSWPIN"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_PSWPOUT: + return "VMSTAT_PSWPOUT"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_PGALLOC_DMA: + return "VMSTAT_PGALLOC_DMA"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_PGALLOC_NORMAL: + return "VMSTAT_PGALLOC_NORMAL"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_PGALLOC_MOVABLE: + return "VMSTAT_PGALLOC_MOVABLE"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_PGFREE: + return "VMSTAT_PGFREE"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_PGACTIVATE: + return "VMSTAT_PGACTIVATE"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_PGDEACTIVATE: + return "VMSTAT_PGDEACTIVATE"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_PGFAULT: + return "VMSTAT_PGFAULT"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_PGMAJFAULT: + return "VMSTAT_PGMAJFAULT"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_PGREFILL_DMA: + return "VMSTAT_PGREFILL_DMA"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_PGREFILL_NORMAL: + return "VMSTAT_PGREFILL_NORMAL"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_PGREFILL_MOVABLE: + return "VMSTAT_PGREFILL_MOVABLE"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_PGSTEAL_KSWAPD_DMA: + return "VMSTAT_PGSTEAL_KSWAPD_DMA"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_PGSTEAL_KSWAPD_NORMAL: + return "VMSTAT_PGSTEAL_KSWAPD_NORMAL"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_PGSTEAL_KSWAPD_MOVABLE: + return "VMSTAT_PGSTEAL_KSWAPD_MOVABLE"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_PGSTEAL_DIRECT_DMA: + return "VMSTAT_PGSTEAL_DIRECT_DMA"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_PGSTEAL_DIRECT_NORMAL: + return "VMSTAT_PGSTEAL_DIRECT_NORMAL"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_PGSTEAL_DIRECT_MOVABLE: + return "VMSTAT_PGSTEAL_DIRECT_MOVABLE"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_PGSCAN_KSWAPD_DMA: + return "VMSTAT_PGSCAN_KSWAPD_DMA"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_PGSCAN_KSWAPD_NORMAL: + return "VMSTAT_PGSCAN_KSWAPD_NORMAL"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_PGSCAN_KSWAPD_MOVABLE: + return "VMSTAT_PGSCAN_KSWAPD_MOVABLE"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_PGSCAN_DIRECT_DMA: + return "VMSTAT_PGSCAN_DIRECT_DMA"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_PGSCAN_DIRECT_NORMAL: + return "VMSTAT_PGSCAN_DIRECT_NORMAL"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_PGSCAN_DIRECT_MOVABLE: + return "VMSTAT_PGSCAN_DIRECT_MOVABLE"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_PGSCAN_DIRECT_THROTTLE: + return "VMSTAT_PGSCAN_DIRECT_THROTTLE"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_PGINODESTEAL: + return "VMSTAT_PGINODESTEAL"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_SLABS_SCANNED: + return "VMSTAT_SLABS_SCANNED"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_KSWAPD_INODESTEAL: + return "VMSTAT_KSWAPD_INODESTEAL"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_KSWAPD_LOW_WMARK_HIT_QUICKLY: + return "VMSTAT_KSWAPD_LOW_WMARK_HIT_QUICKLY"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_KSWAPD_HIGH_WMARK_HIT_QUICKLY: + return "VMSTAT_KSWAPD_HIGH_WMARK_HIT_QUICKLY"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_PAGEOUTRUN: + return "VMSTAT_PAGEOUTRUN"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_ALLOCSTALL: + return "VMSTAT_ALLOCSTALL"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_PGROTATED: + return "VMSTAT_PGROTATED"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_DROP_PAGECACHE: + return "VMSTAT_DROP_PAGECACHE"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_DROP_SLAB: + return "VMSTAT_DROP_SLAB"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_PGMIGRATE_SUCCESS: + return "VMSTAT_PGMIGRATE_SUCCESS"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_PGMIGRATE_FAIL: + return "VMSTAT_PGMIGRATE_FAIL"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_COMPACT_MIGRATE_SCANNED: + return "VMSTAT_COMPACT_MIGRATE_SCANNED"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_COMPACT_FREE_SCANNED: + return "VMSTAT_COMPACT_FREE_SCANNED"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_COMPACT_ISOLATED: + return "VMSTAT_COMPACT_ISOLATED"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_COMPACT_STALL: + return "VMSTAT_COMPACT_STALL"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_COMPACT_FAIL: + return "VMSTAT_COMPACT_FAIL"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_COMPACT_SUCCESS: + return "VMSTAT_COMPACT_SUCCESS"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_COMPACT_DAEMON_WAKE: + return "VMSTAT_COMPACT_DAEMON_WAKE"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_UNEVICTABLE_PGS_CULLED: + return "VMSTAT_UNEVICTABLE_PGS_CULLED"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_UNEVICTABLE_PGS_SCANNED: + return "VMSTAT_UNEVICTABLE_PGS_SCANNED"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_UNEVICTABLE_PGS_RESCUED: + return "VMSTAT_UNEVICTABLE_PGS_RESCUED"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_UNEVICTABLE_PGS_MLOCKED: + return "VMSTAT_UNEVICTABLE_PGS_MLOCKED"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_UNEVICTABLE_PGS_MUNLOCKED: + return "VMSTAT_UNEVICTABLE_PGS_MUNLOCKED"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_UNEVICTABLE_PGS_CLEARED: + return "VMSTAT_UNEVICTABLE_PGS_CLEARED"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_UNEVICTABLE_PGS_STRANDED: + return "VMSTAT_UNEVICTABLE_PGS_STRANDED"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_NR_ZSPAGES: + return "VMSTAT_NR_ZSPAGES"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_NR_ION_HEAP: + return "VMSTAT_NR_ION_HEAP"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_NR_GPU_HEAP: + return "VMSTAT_NR_GPU_HEAP"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_ALLOCSTALL_DMA: + return "VMSTAT_ALLOCSTALL_DMA"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_ALLOCSTALL_MOVABLE: + return "VMSTAT_ALLOCSTALL_MOVABLE"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_ALLOCSTALL_NORMAL: + return "VMSTAT_ALLOCSTALL_NORMAL"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_COMPACT_DAEMON_FREE_SCANNED: + return "VMSTAT_COMPACT_DAEMON_FREE_SCANNED"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_COMPACT_DAEMON_MIGRATE_SCANNED: + return "VMSTAT_COMPACT_DAEMON_MIGRATE_SCANNED"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_NR_FASTRPC: + return "VMSTAT_NR_FASTRPC"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_NR_INDIRECTLY_RECLAIMABLE: + return "VMSTAT_NR_INDIRECTLY_RECLAIMABLE"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_NR_ION_HEAP_POOL: + return "VMSTAT_NR_ION_HEAP_POOL"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_NR_KERNEL_MISC_RECLAIMABLE: + return "VMSTAT_NR_KERNEL_MISC_RECLAIMABLE"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_NR_SHADOW_CALL_STACK_BYTES: + return "VMSTAT_NR_SHADOW_CALL_STACK_BYTES"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_NR_SHMEM_HUGEPAGES: + return "VMSTAT_NR_SHMEM_HUGEPAGES"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_NR_SHMEM_PMDMAPPED: + return "VMSTAT_NR_SHMEM_PMDMAPPED"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_NR_UNRECLAIMABLE_PAGES: + return "VMSTAT_NR_UNRECLAIMABLE_PAGES"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_NR_ZONE_ACTIVE_ANON: + return "VMSTAT_NR_ZONE_ACTIVE_ANON"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_NR_ZONE_ACTIVE_FILE: + return "VMSTAT_NR_ZONE_ACTIVE_FILE"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_NR_ZONE_INACTIVE_ANON: + return "VMSTAT_NR_ZONE_INACTIVE_ANON"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_NR_ZONE_INACTIVE_FILE: + return "VMSTAT_NR_ZONE_INACTIVE_FILE"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_NR_ZONE_UNEVICTABLE: + return "VMSTAT_NR_ZONE_UNEVICTABLE"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_NR_ZONE_WRITE_PENDING: + return "VMSTAT_NR_ZONE_WRITE_PENDING"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_OOM_KILL: + return "VMSTAT_OOM_KILL"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_PGLAZYFREE: + return "VMSTAT_PGLAZYFREE"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_PGLAZYFREED: + return "VMSTAT_PGLAZYFREED"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_PGREFILL: + return "VMSTAT_PGREFILL"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_PGSCAN_DIRECT: + return "VMSTAT_PGSCAN_DIRECT"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_PGSCAN_KSWAPD: + return "VMSTAT_PGSCAN_KSWAPD"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_PGSKIP_DMA: + return "VMSTAT_PGSKIP_DMA"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_PGSKIP_MOVABLE: + return "VMSTAT_PGSKIP_MOVABLE"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_PGSKIP_NORMAL: + return "VMSTAT_PGSKIP_NORMAL"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_PGSTEAL_DIRECT: + return "VMSTAT_PGSTEAL_DIRECT"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_PGSTEAL_KSWAPD: + return "VMSTAT_PGSTEAL_KSWAPD"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_SWAP_RA: + return "VMSTAT_SWAP_RA"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_SWAP_RA_HIT: + return "VMSTAT_SWAP_RA_HIT"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_WORKINGSET_RESTORE: + return "VMSTAT_WORKINGSET_RESTORE"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_ALLOCSTALL_DEVICE: + return "VMSTAT_ALLOCSTALL_DEVICE"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_ALLOCSTALL_DMA32: + return "VMSTAT_ALLOCSTALL_DMA32"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_BALLOON_DEFLATE: + return "VMSTAT_BALLOON_DEFLATE"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_BALLOON_INFLATE: + return "VMSTAT_BALLOON_INFLATE"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_BALLOON_MIGRATE: + return "VMSTAT_BALLOON_MIGRATE"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_CMA_ALLOC_FAIL: + return "VMSTAT_CMA_ALLOC_FAIL"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_CMA_ALLOC_SUCCESS: + return "VMSTAT_CMA_ALLOC_SUCCESS"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_NR_FILE_HUGEPAGES: + return "VMSTAT_NR_FILE_HUGEPAGES"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_NR_FILE_PMDMAPPED: + return "VMSTAT_NR_FILE_PMDMAPPED"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_NR_FOLL_PIN_ACQUIRED: + return "VMSTAT_NR_FOLL_PIN_ACQUIRED"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_NR_FOLL_PIN_RELEASED: + return "VMSTAT_NR_FOLL_PIN_RELEASED"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_NR_SEC_PAGE_TABLE_PAGES: + return "VMSTAT_NR_SEC_PAGE_TABLE_PAGES"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_NR_SHADOW_CALL_STACK: + return "VMSTAT_NR_SHADOW_CALL_STACK"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_NR_SWAPCACHED: + return "VMSTAT_NR_SWAPCACHED"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_NR_THROTTLED_WRITTEN: + return "VMSTAT_NR_THROTTLED_WRITTEN"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_PGALLOC_DEVICE: + return "VMSTAT_PGALLOC_DEVICE"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_PGALLOC_DMA32: + return "VMSTAT_PGALLOC_DMA32"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_PGDEMOTE_DIRECT: + return "VMSTAT_PGDEMOTE_DIRECT"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_PGDEMOTE_KSWAPD: + return "VMSTAT_PGDEMOTE_KSWAPD"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_PGREUSE: + return "VMSTAT_PGREUSE"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_PGSCAN_ANON: + return "VMSTAT_PGSCAN_ANON"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_PGSCAN_FILE: + return "VMSTAT_PGSCAN_FILE"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_PGSKIP_DEVICE: + return "VMSTAT_PGSKIP_DEVICE"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_PGSKIP_DMA32: + return "VMSTAT_PGSKIP_DMA32"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_PGSTEAL_ANON: + return "VMSTAT_PGSTEAL_ANON"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_PGSTEAL_FILE: + return "VMSTAT_PGSTEAL_FILE"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_THP_COLLAPSE_ALLOC: + return "VMSTAT_THP_COLLAPSE_ALLOC"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_THP_COLLAPSE_ALLOC_FAILED: + return "VMSTAT_THP_COLLAPSE_ALLOC_FAILED"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_THP_DEFERRED_SPLIT_PAGE: + return "VMSTAT_THP_DEFERRED_SPLIT_PAGE"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_THP_FAULT_ALLOC: + return "VMSTAT_THP_FAULT_ALLOC"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_THP_FAULT_FALLBACK: + return "VMSTAT_THP_FAULT_FALLBACK"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_THP_FAULT_FALLBACK_CHARGE: + return "VMSTAT_THP_FAULT_FALLBACK_CHARGE"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_THP_FILE_ALLOC: + return "VMSTAT_THP_FILE_ALLOC"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_THP_FILE_FALLBACK: + return "VMSTAT_THP_FILE_FALLBACK"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_THP_FILE_FALLBACK_CHARGE: + return "VMSTAT_THP_FILE_FALLBACK_CHARGE"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_THP_FILE_MAPPED: + return "VMSTAT_THP_FILE_MAPPED"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_THP_MIGRATION_FAIL: + return "VMSTAT_THP_MIGRATION_FAIL"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_THP_MIGRATION_SPLIT: + return "VMSTAT_THP_MIGRATION_SPLIT"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_THP_MIGRATION_SUCCESS: + return "VMSTAT_THP_MIGRATION_SUCCESS"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_THP_SCAN_EXCEED_NONE_PTE: + return "VMSTAT_THP_SCAN_EXCEED_NONE_PTE"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_THP_SCAN_EXCEED_SHARE_PTE: + return "VMSTAT_THP_SCAN_EXCEED_SHARE_PTE"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_THP_SCAN_EXCEED_SWAP_PTE: + return "VMSTAT_THP_SCAN_EXCEED_SWAP_PTE"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_THP_SPLIT_PAGE: + return "VMSTAT_THP_SPLIT_PAGE"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_THP_SPLIT_PAGE_FAILED: + return "VMSTAT_THP_SPLIT_PAGE_FAILED"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_THP_SPLIT_PMD: + return "VMSTAT_THP_SPLIT_PMD"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_THP_SWPOUT: + return "VMSTAT_THP_SWPOUT"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_THP_SWPOUT_FALLBACK: + return "VMSTAT_THP_SWPOUT_FALLBACK"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_THP_ZERO_PAGE_ALLOC: + return "VMSTAT_THP_ZERO_PAGE_ALLOC"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_THP_ZERO_PAGE_ALLOC_FAILED: + return "VMSTAT_THP_ZERO_PAGE_ALLOC_FAILED"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_VMA_LOCK_ABORT: + return "VMSTAT_VMA_LOCK_ABORT"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_VMA_LOCK_MISS: + return "VMSTAT_VMA_LOCK_MISS"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_VMA_LOCK_RETRY: + return "VMSTAT_VMA_LOCK_RETRY"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_VMA_LOCK_SUCCESS: + return "VMSTAT_VMA_LOCK_SUCCESS"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_WORKINGSET_ACTIVATE_ANON: + return "VMSTAT_WORKINGSET_ACTIVATE_ANON"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_WORKINGSET_ACTIVATE_FILE: + return "VMSTAT_WORKINGSET_ACTIVATE_FILE"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_WORKINGSET_NODES: + return "VMSTAT_WORKINGSET_NODES"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_WORKINGSET_REFAULT_ANON: + return "VMSTAT_WORKINGSET_REFAULT_ANON"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_WORKINGSET_REFAULT_FILE: + return "VMSTAT_WORKINGSET_REFAULT_FILE"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_WORKINGSET_RESTORE_ANON: + return "VMSTAT_WORKINGSET_RESTORE_ANON"; + + case ::perfetto::protos::pbzero::VmstatCounters::VMSTAT_WORKINGSET_RESTORE_FILE: + return "VMSTAT_WORKINGSET_RESTORE_FILE"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +enum TrafficDirection : int32_t { + DIR_UNSPECIFIED = 0, + DIR_INGRESS = 1, + DIR_EGRESS = 2, +}; + +constexpr TrafficDirection TrafficDirection_MIN = TrafficDirection::DIR_UNSPECIFIED; +constexpr TrafficDirection TrafficDirection_MAX = TrafficDirection::DIR_EGRESS; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* TrafficDirection_Name(::perfetto::protos::pbzero::TrafficDirection value) { + switch (value) { + case ::perfetto::protos::pbzero::TrafficDirection::DIR_UNSPECIFIED: + return "DIR_UNSPECIFIED"; + + case ::perfetto::protos::pbzero::TrafficDirection::DIR_INGRESS: + return "DIR_INGRESS"; + + case ::perfetto::protos::pbzero::TrafficDirection::DIR_EGRESS: + return "DIR_EGRESS"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +enum HwcCompositionType : int32_t { + HWC_TYPE_UNSPECIFIED = 0, + HWC_TYPE_CLIENT = 1, + HWC_TYPE_DEVICE = 2, + HWC_TYPE_SOLID_COLOR = 3, + HWC_TYPE_CURSOR = 4, + HWC_TYPE_SIDEBAND = 5, + HWC_TYPE_DISPLAY_DECORATION = 6, +}; + +constexpr HwcCompositionType HwcCompositionType_MIN = HwcCompositionType::HWC_TYPE_UNSPECIFIED; +constexpr HwcCompositionType HwcCompositionType_MAX = HwcCompositionType::HWC_TYPE_DISPLAY_DECORATION; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* HwcCompositionType_Name(::perfetto::protos::pbzero::HwcCompositionType value) { + switch (value) { + case ::perfetto::protos::pbzero::HwcCompositionType::HWC_TYPE_UNSPECIFIED: + return "HWC_TYPE_UNSPECIFIED"; + + case ::perfetto::protos::pbzero::HwcCompositionType::HWC_TYPE_CLIENT: + return "HWC_TYPE_CLIENT"; + + case ::perfetto::protos::pbzero::HwcCompositionType::HWC_TYPE_DEVICE: + return "HWC_TYPE_DEVICE"; + + case ::perfetto::protos::pbzero::HwcCompositionType::HWC_TYPE_SOLID_COLOR: + return "HWC_TYPE_SOLID_COLOR"; + + case ::perfetto::protos::pbzero::HwcCompositionType::HWC_TYPE_CURSOR: + return "HWC_TYPE_CURSOR"; + + case ::perfetto::protos::pbzero::HwcCompositionType::HWC_TYPE_SIDEBAND: + return "HWC_TYPE_SIDEBAND"; + + case ::perfetto::protos::pbzero::HwcCompositionType::HWC_TYPE_DISPLAY_DECORATION: + return "HWC_TYPE_DISPLAY_DECORATION"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +enum FtraceParseStatus : int32_t { + FTRACE_STATUS_UNSPECIFIED = 0, + FTRACE_STATUS_OK = 1, + FTRACE_STATUS_UNEXPECTED_READ_ERROR = 2, + FTRACE_STATUS_PARTIAL_PAGE_READ = 3, + FTRACE_STATUS_ABI_INVALID_PAGE_HEADER = 4, + FTRACE_STATUS_ABI_SHORT_EVENT_HEADER = 5, + FTRACE_STATUS_ABI_NULL_PADDING = 6, + FTRACE_STATUS_ABI_SHORT_PADDING_LENGTH = 7, + FTRACE_STATUS_ABI_INVALID_PADDING_LENGTH = 8, + FTRACE_STATUS_ABI_SHORT_TIME_EXTEND = 9, + FTRACE_STATUS_ABI_SHORT_TIME_STAMP = 10, + FTRACE_STATUS_ABI_SHORT_DATA_LENGTH = 11, + FTRACE_STATUS_ABI_ZERO_DATA_LENGTH = 12, + FTRACE_STATUS_ABI_INVALID_DATA_LENGTH = 13, + FTRACE_STATUS_ABI_SHORT_EVENT_ID = 14, + FTRACE_STATUS_ABI_END_OVERFLOW = 15, + FTRACE_STATUS_SHORT_COMPACT_EVENT = 16, + FTRACE_STATUS_INVALID_EVENT = 17, +}; + +constexpr FtraceParseStatus FtraceParseStatus_MIN = FtraceParseStatus::FTRACE_STATUS_UNSPECIFIED; +constexpr FtraceParseStatus FtraceParseStatus_MAX = FtraceParseStatus::FTRACE_STATUS_INVALID_EVENT; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* FtraceParseStatus_Name(::perfetto::protos::pbzero::FtraceParseStatus value) { + switch (value) { + case ::perfetto::protos::pbzero::FtraceParseStatus::FTRACE_STATUS_UNSPECIFIED: + return "FTRACE_STATUS_UNSPECIFIED"; + + case ::perfetto::protos::pbzero::FtraceParseStatus::FTRACE_STATUS_OK: + return "FTRACE_STATUS_OK"; + + case ::perfetto::protos::pbzero::FtraceParseStatus::FTRACE_STATUS_UNEXPECTED_READ_ERROR: + return "FTRACE_STATUS_UNEXPECTED_READ_ERROR"; + + case ::perfetto::protos::pbzero::FtraceParseStatus::FTRACE_STATUS_PARTIAL_PAGE_READ: + return "FTRACE_STATUS_PARTIAL_PAGE_READ"; + + case ::perfetto::protos::pbzero::FtraceParseStatus::FTRACE_STATUS_ABI_INVALID_PAGE_HEADER: + return "FTRACE_STATUS_ABI_INVALID_PAGE_HEADER"; + + case ::perfetto::protos::pbzero::FtraceParseStatus::FTRACE_STATUS_ABI_SHORT_EVENT_HEADER: + return "FTRACE_STATUS_ABI_SHORT_EVENT_HEADER"; + + case ::perfetto::protos::pbzero::FtraceParseStatus::FTRACE_STATUS_ABI_NULL_PADDING: + return "FTRACE_STATUS_ABI_NULL_PADDING"; + + case ::perfetto::protos::pbzero::FtraceParseStatus::FTRACE_STATUS_ABI_SHORT_PADDING_LENGTH: + return "FTRACE_STATUS_ABI_SHORT_PADDING_LENGTH"; + + case ::perfetto::protos::pbzero::FtraceParseStatus::FTRACE_STATUS_ABI_INVALID_PADDING_LENGTH: + return "FTRACE_STATUS_ABI_INVALID_PADDING_LENGTH"; + + case ::perfetto::protos::pbzero::FtraceParseStatus::FTRACE_STATUS_ABI_SHORT_TIME_EXTEND: + return "FTRACE_STATUS_ABI_SHORT_TIME_EXTEND"; + + case ::perfetto::protos::pbzero::FtraceParseStatus::FTRACE_STATUS_ABI_SHORT_TIME_STAMP: + return "FTRACE_STATUS_ABI_SHORT_TIME_STAMP"; + + case ::perfetto::protos::pbzero::FtraceParseStatus::FTRACE_STATUS_ABI_SHORT_DATA_LENGTH: + return "FTRACE_STATUS_ABI_SHORT_DATA_LENGTH"; + + case ::perfetto::protos::pbzero::FtraceParseStatus::FTRACE_STATUS_ABI_ZERO_DATA_LENGTH: + return "FTRACE_STATUS_ABI_ZERO_DATA_LENGTH"; + + case ::perfetto::protos::pbzero::FtraceParseStatus::FTRACE_STATUS_ABI_INVALID_DATA_LENGTH: + return "FTRACE_STATUS_ABI_INVALID_DATA_LENGTH"; + + case ::perfetto::protos::pbzero::FtraceParseStatus::FTRACE_STATUS_ABI_SHORT_EVENT_ID: + return "FTRACE_STATUS_ABI_SHORT_EVENT_ID"; + + case ::perfetto::protos::pbzero::FtraceParseStatus::FTRACE_STATUS_ABI_END_OVERFLOW: + return "FTRACE_STATUS_ABI_END_OVERFLOW"; + + case ::perfetto::protos::pbzero::FtraceParseStatus::FTRACE_STATUS_SHORT_COMPACT_EVENT: + return "FTRACE_STATUS_SHORT_COMPACT_EVENT"; + + case ::perfetto::protos::pbzero::FtraceParseStatus::FTRACE_STATUS_INVALID_EVENT: + return "FTRACE_STATUS_INVALID_EVENT"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +enum FtraceClock : int32_t { + FTRACE_CLOCK_UNSPECIFIED = 0, + FTRACE_CLOCK_UNKNOWN = 1, + FTRACE_CLOCK_GLOBAL = 2, + FTRACE_CLOCK_LOCAL = 3, + FTRACE_CLOCK_MONO_RAW = 4, +}; + +constexpr FtraceClock FtraceClock_MIN = FtraceClock::FTRACE_CLOCK_UNSPECIFIED; +constexpr FtraceClock FtraceClock_MAX = FtraceClock::FTRACE_CLOCK_MONO_RAW; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* FtraceClock_Name(::perfetto::protos::pbzero::FtraceClock value) { + switch (value) { + case ::perfetto::protos::pbzero::FtraceClock::FTRACE_CLOCK_UNSPECIFIED: + return "FTRACE_CLOCK_UNSPECIFIED"; + + case ::perfetto::protos::pbzero::FtraceClock::FTRACE_CLOCK_UNKNOWN: + return "FTRACE_CLOCK_UNKNOWN"; + + case ::perfetto::protos::pbzero::FtraceClock::FTRACE_CLOCK_GLOBAL: + return "FTRACE_CLOCK_GLOBAL"; + + case ::perfetto::protos::pbzero::FtraceClock::FTRACE_CLOCK_LOCAL: + return "FTRACE_CLOCK_LOCAL"; + + case ::perfetto::protos::pbzero::FtraceClock::FTRACE_CLOCK_MONO_RAW: + return "FTRACE_CLOCK_MONO_RAW"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +enum ChromeCompositorSchedulerAction : int32_t { + CC_SCHEDULER_ACTION_UNSPECIFIED = 0, + CC_SCHEDULER_ACTION_NONE = 1, + CC_SCHEDULER_ACTION_SEND_BEGIN_MAIN_FRAME = 2, + CC_SCHEDULER_ACTION_COMMIT = 3, + CC_SCHEDULER_ACTION_ACTIVATE_SYNC_TREE = 4, + CC_SCHEDULER_ACTION_DRAW_IF_POSSIBLE = 5, + CC_SCHEDULER_ACTION_DRAW_FORCED = 6, + CC_SCHEDULER_ACTION_DRAW_ABORT = 7, + CC_SCHEDULER_ACTION_BEGIN_LAYER_TREE_FRAME_SINK_CREATION = 8, + CC_SCHEDULER_ACTION_PREPARE_TILES = 9, + CC_SCHEDULER_ACTION_INVALIDATE_LAYER_TREE_FRAME_SINK = 10, + CC_SCHEDULER_ACTION_PERFORM_IMPL_SIDE_INVALIDATION = 11, + CC_SCHEDULER_ACTION_NOTIFY_BEGIN_MAIN_FRAME_NOT_EXPECTED_UNTIL = 12, + CC_SCHEDULER_ACTION_NOTIFY_BEGIN_MAIN_FRAME_NOT_EXPECTED_SOON = 13, +}; + +constexpr ChromeCompositorSchedulerAction ChromeCompositorSchedulerAction_MIN = ChromeCompositorSchedulerAction::CC_SCHEDULER_ACTION_UNSPECIFIED; +constexpr ChromeCompositorSchedulerAction ChromeCompositorSchedulerAction_MAX = ChromeCompositorSchedulerAction::CC_SCHEDULER_ACTION_NOTIFY_BEGIN_MAIN_FRAME_NOT_EXPECTED_SOON; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* ChromeCompositorSchedulerAction_Name(::perfetto::protos::pbzero::ChromeCompositorSchedulerAction value) { + switch (value) { + case ::perfetto::protos::pbzero::ChromeCompositorSchedulerAction::CC_SCHEDULER_ACTION_UNSPECIFIED: + return "CC_SCHEDULER_ACTION_UNSPECIFIED"; + + case ::perfetto::protos::pbzero::ChromeCompositorSchedulerAction::CC_SCHEDULER_ACTION_NONE: + return "CC_SCHEDULER_ACTION_NONE"; + + case ::perfetto::protos::pbzero::ChromeCompositorSchedulerAction::CC_SCHEDULER_ACTION_SEND_BEGIN_MAIN_FRAME: + return "CC_SCHEDULER_ACTION_SEND_BEGIN_MAIN_FRAME"; + + case ::perfetto::protos::pbzero::ChromeCompositorSchedulerAction::CC_SCHEDULER_ACTION_COMMIT: + return "CC_SCHEDULER_ACTION_COMMIT"; + + case ::perfetto::protos::pbzero::ChromeCompositorSchedulerAction::CC_SCHEDULER_ACTION_ACTIVATE_SYNC_TREE: + return "CC_SCHEDULER_ACTION_ACTIVATE_SYNC_TREE"; + + case ::perfetto::protos::pbzero::ChromeCompositorSchedulerAction::CC_SCHEDULER_ACTION_DRAW_IF_POSSIBLE: + return "CC_SCHEDULER_ACTION_DRAW_IF_POSSIBLE"; + + case ::perfetto::protos::pbzero::ChromeCompositorSchedulerAction::CC_SCHEDULER_ACTION_DRAW_FORCED: + return "CC_SCHEDULER_ACTION_DRAW_FORCED"; + + case ::perfetto::protos::pbzero::ChromeCompositorSchedulerAction::CC_SCHEDULER_ACTION_DRAW_ABORT: + return "CC_SCHEDULER_ACTION_DRAW_ABORT"; + + case ::perfetto::protos::pbzero::ChromeCompositorSchedulerAction::CC_SCHEDULER_ACTION_BEGIN_LAYER_TREE_FRAME_SINK_CREATION: + return "CC_SCHEDULER_ACTION_BEGIN_LAYER_TREE_FRAME_SINK_CREATION"; + + case ::perfetto::protos::pbzero::ChromeCompositorSchedulerAction::CC_SCHEDULER_ACTION_PREPARE_TILES: + return "CC_SCHEDULER_ACTION_PREPARE_TILES"; + + case ::perfetto::protos::pbzero::ChromeCompositorSchedulerAction::CC_SCHEDULER_ACTION_INVALIDATE_LAYER_TREE_FRAME_SINK: + return "CC_SCHEDULER_ACTION_INVALIDATE_LAYER_TREE_FRAME_SINK"; + + case ::perfetto::protos::pbzero::ChromeCompositorSchedulerAction::CC_SCHEDULER_ACTION_PERFORM_IMPL_SIDE_INVALIDATION: + return "CC_SCHEDULER_ACTION_PERFORM_IMPL_SIDE_INVALIDATION"; + + case ::perfetto::protos::pbzero::ChromeCompositorSchedulerAction::CC_SCHEDULER_ACTION_NOTIFY_BEGIN_MAIN_FRAME_NOT_EXPECTED_UNTIL: + return "CC_SCHEDULER_ACTION_NOTIFY_BEGIN_MAIN_FRAME_NOT_EXPECTED_UNTIL"; + + case ::perfetto::protos::pbzero::ChromeCompositorSchedulerAction::CC_SCHEDULER_ACTION_NOTIFY_BEGIN_MAIN_FRAME_NOT_EXPECTED_SOON: + return "CC_SCHEDULER_ACTION_NOTIFY_BEGIN_MAIN_FRAME_NOT_EXPECTED_SOON"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +enum ChromeRAILMode : int32_t { + RAIL_MODE_NONE = 0, + RAIL_MODE_RESPONSE = 1, + RAIL_MODE_ANIMATION = 2, + RAIL_MODE_IDLE = 3, + RAIL_MODE_LOAD = 4, +}; + +constexpr ChromeRAILMode ChromeRAILMode_MIN = ChromeRAILMode::RAIL_MODE_NONE; +constexpr ChromeRAILMode ChromeRAILMode_MAX = ChromeRAILMode::RAIL_MODE_LOAD; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* ChromeRAILMode_Name(::perfetto::protos::pbzero::ChromeRAILMode value) { + switch (value) { + case ::perfetto::protos::pbzero::ChromeRAILMode::RAIL_MODE_NONE: + return "RAIL_MODE_NONE"; + + case ::perfetto::protos::pbzero::ChromeRAILMode::RAIL_MODE_RESPONSE: + return "RAIL_MODE_RESPONSE"; + + case ::perfetto::protos::pbzero::ChromeRAILMode::RAIL_MODE_ANIMATION: + return "RAIL_MODE_ANIMATION"; + + case ::perfetto::protos::pbzero::ChromeRAILMode::RAIL_MODE_IDLE: + return "RAIL_MODE_IDLE"; + + case ::perfetto::protos::pbzero::ChromeRAILMode::RAIL_MODE_LOAD: + return "RAIL_MODE_LOAD"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_TracePacket { +enum SequenceFlags : int32_t { + SEQ_UNSPECIFIED = 0, + SEQ_INCREMENTAL_STATE_CLEARED = 1, + SEQ_NEEDS_INCREMENTAL_STATE = 2, +}; +} // namespace perfetto_pbzero_enum_TracePacket +using TracePacket_SequenceFlags = perfetto_pbzero_enum_TracePacket::SequenceFlags; + + +constexpr TracePacket_SequenceFlags TracePacket_SequenceFlags_MIN = TracePacket_SequenceFlags::SEQ_UNSPECIFIED; +constexpr TracePacket_SequenceFlags TracePacket_SequenceFlags_MAX = TracePacket_SequenceFlags::SEQ_NEEDS_INCREMENTAL_STATE; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* TracePacket_SequenceFlags_Name(::perfetto::protos::pbzero::TracePacket_SequenceFlags value) { + switch (value) { + case ::perfetto::protos::pbzero::TracePacket_SequenceFlags::SEQ_UNSPECIFIED: + return "SEQ_UNSPECIFIED"; + + case ::perfetto::protos::pbzero::TracePacket_SequenceFlags::SEQ_INCREMENTAL_STATE_CLEARED: + return "SEQ_INCREMENTAL_STATE_CLEARED"; + + case ::perfetto::protos::pbzero::TracePacket_SequenceFlags::SEQ_NEEDS_INCREMENTAL_STATE: + return "SEQ_NEEDS_INCREMENTAL_STATE"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_CounterDescriptor { +enum BuiltinCounterType : int32_t { + COUNTER_UNSPECIFIED = 0, + COUNTER_THREAD_TIME_NS = 1, + COUNTER_THREAD_INSTRUCTION_COUNT = 2, +}; +} // namespace perfetto_pbzero_enum_CounterDescriptor +using CounterDescriptor_BuiltinCounterType = perfetto_pbzero_enum_CounterDescriptor::BuiltinCounterType; + + +constexpr CounterDescriptor_BuiltinCounterType CounterDescriptor_BuiltinCounterType_MIN = CounterDescriptor_BuiltinCounterType::COUNTER_UNSPECIFIED; +constexpr CounterDescriptor_BuiltinCounterType CounterDescriptor_BuiltinCounterType_MAX = CounterDescriptor_BuiltinCounterType::COUNTER_THREAD_INSTRUCTION_COUNT; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* CounterDescriptor_BuiltinCounterType_Name(::perfetto::protos::pbzero::CounterDescriptor_BuiltinCounterType value) { + switch (value) { + case ::perfetto::protos::pbzero::CounterDescriptor_BuiltinCounterType::COUNTER_UNSPECIFIED: + return "COUNTER_UNSPECIFIED"; + + case ::perfetto::protos::pbzero::CounterDescriptor_BuiltinCounterType::COUNTER_THREAD_TIME_NS: + return "COUNTER_THREAD_TIME_NS"; + + case ::perfetto::protos::pbzero::CounterDescriptor_BuiltinCounterType::COUNTER_THREAD_INSTRUCTION_COUNT: + return "COUNTER_THREAD_INSTRUCTION_COUNT"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_CounterDescriptor { +enum Unit : int32_t { + UNIT_UNSPECIFIED = 0, + UNIT_TIME_NS = 1, + UNIT_COUNT = 2, + UNIT_SIZE_BYTES = 3, +}; +} // namespace perfetto_pbzero_enum_CounterDescriptor +using CounterDescriptor_Unit = perfetto_pbzero_enum_CounterDescriptor::Unit; + + +constexpr CounterDescriptor_Unit CounterDescriptor_Unit_MIN = CounterDescriptor_Unit::UNIT_UNSPECIFIED; +constexpr CounterDescriptor_Unit CounterDescriptor_Unit_MAX = CounterDescriptor_Unit::UNIT_SIZE_BYTES; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* CounterDescriptor_Unit_Name(::perfetto::protos::pbzero::CounterDescriptor_Unit value) { + switch (value) { + case ::perfetto::protos::pbzero::CounterDescriptor_Unit::UNIT_UNSPECIFIED: + return "UNIT_UNSPECIFIED"; + + case ::perfetto::protos::pbzero::CounterDescriptor_Unit::UNIT_TIME_NS: + return "UNIT_TIME_NS"; + + case ::perfetto::protos::pbzero::CounterDescriptor_Unit::UNIT_COUNT: + return "UNIT_COUNT"; + + case ::perfetto::protos::pbzero::CounterDescriptor_Unit::UNIT_SIZE_BYTES: + return "UNIT_SIZE_BYTES"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_ChromeThreadDescriptor { +enum ThreadType : int32_t { + THREAD_UNSPECIFIED = 0, + THREAD_MAIN = 1, + THREAD_IO = 2, + THREAD_POOL_BG_WORKER = 3, + THREAD_POOL_FG_WORKER = 4, + THREAD_POOL_FG_BLOCKING = 5, + THREAD_POOL_BG_BLOCKING = 6, + THREAD_POOL_SERVICE = 7, + THREAD_COMPOSITOR = 8, + THREAD_VIZ_COMPOSITOR = 9, + THREAD_COMPOSITOR_WORKER = 10, + THREAD_SERVICE_WORKER = 11, + THREAD_NETWORK_SERVICE = 12, + THREAD_CHILD_IO = 13, + THREAD_BROWSER_IO = 14, + THREAD_BROWSER_MAIN = 15, + THREAD_RENDERER_MAIN = 16, + THREAD_UTILITY_MAIN = 17, + THREAD_GPU_MAIN = 18, + THREAD_CACHE_BLOCKFILE = 19, + THREAD_MEDIA = 20, + THREAD_AUDIO_OUTPUTDEVICE = 21, + THREAD_AUDIO_INPUTDEVICE = 22, + THREAD_GPU_MEMORY = 23, + THREAD_GPU_VSYNC = 24, + THREAD_DXA_VIDEODECODER = 25, + THREAD_BROWSER_WATCHDOG = 26, + THREAD_WEBRTC_NETWORK = 27, + THREAD_WINDOW_OWNER = 28, + THREAD_WEBRTC_SIGNALING = 29, + THREAD_WEBRTC_WORKER = 30, + THREAD_PPAPI_MAIN = 31, + THREAD_GPU_WATCHDOG = 32, + THREAD_SWAPPER = 33, + THREAD_GAMEPAD_POLLING = 34, + THREAD_WEBCRYPTO = 35, + THREAD_DATABASE = 36, + THREAD_PROXYRESOLVER = 37, + THREAD_DEVTOOLSADB = 38, + THREAD_NETWORKCONFIGWATCHER = 39, + THREAD_WASAPI_RENDER = 40, + THREAD_LOADER_LOCK_SAMPLER = 41, + THREAD_MEMORY_INFRA = 50, + THREAD_SAMPLING_PROFILER = 51, +}; +} // namespace perfetto_pbzero_enum_ChromeThreadDescriptor +using ChromeThreadDescriptor_ThreadType = perfetto_pbzero_enum_ChromeThreadDescriptor::ThreadType; + + +constexpr ChromeThreadDescriptor_ThreadType ChromeThreadDescriptor_ThreadType_MIN = ChromeThreadDescriptor_ThreadType::THREAD_UNSPECIFIED; +constexpr ChromeThreadDescriptor_ThreadType ChromeThreadDescriptor_ThreadType_MAX = ChromeThreadDescriptor_ThreadType::THREAD_SAMPLING_PROFILER; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* ChromeThreadDescriptor_ThreadType_Name(::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType value) { + switch (value) { + case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_UNSPECIFIED: + return "THREAD_UNSPECIFIED"; + + case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_MAIN: + return "THREAD_MAIN"; + + case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_IO: + return "THREAD_IO"; + + case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_POOL_BG_WORKER: + return "THREAD_POOL_BG_WORKER"; + + case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_POOL_FG_WORKER: + return "THREAD_POOL_FG_WORKER"; + + case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_POOL_FG_BLOCKING: + return "THREAD_POOL_FG_BLOCKING"; + + case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_POOL_BG_BLOCKING: + return "THREAD_POOL_BG_BLOCKING"; + + case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_POOL_SERVICE: + return "THREAD_POOL_SERVICE"; + + case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_COMPOSITOR: + return "THREAD_COMPOSITOR"; + + case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_VIZ_COMPOSITOR: + return "THREAD_VIZ_COMPOSITOR"; + + case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_COMPOSITOR_WORKER: + return "THREAD_COMPOSITOR_WORKER"; + + case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_SERVICE_WORKER: + return "THREAD_SERVICE_WORKER"; + + case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_NETWORK_SERVICE: + return "THREAD_NETWORK_SERVICE"; + + case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_CHILD_IO: + return "THREAD_CHILD_IO"; + + case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_BROWSER_IO: + return "THREAD_BROWSER_IO"; + + case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_BROWSER_MAIN: + return "THREAD_BROWSER_MAIN"; + + case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_RENDERER_MAIN: + return "THREAD_RENDERER_MAIN"; + + case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_UTILITY_MAIN: + return "THREAD_UTILITY_MAIN"; + + case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_GPU_MAIN: + return "THREAD_GPU_MAIN"; + + case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_CACHE_BLOCKFILE: + return "THREAD_CACHE_BLOCKFILE"; + + case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_MEDIA: + return "THREAD_MEDIA"; + + case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_AUDIO_OUTPUTDEVICE: + return "THREAD_AUDIO_OUTPUTDEVICE"; + + case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_AUDIO_INPUTDEVICE: + return "THREAD_AUDIO_INPUTDEVICE"; + + case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_GPU_MEMORY: + return "THREAD_GPU_MEMORY"; + + case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_GPU_VSYNC: + return "THREAD_GPU_VSYNC"; + + case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_DXA_VIDEODECODER: + return "THREAD_DXA_VIDEODECODER"; + + case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_BROWSER_WATCHDOG: + return "THREAD_BROWSER_WATCHDOG"; + + case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_WEBRTC_NETWORK: + return "THREAD_WEBRTC_NETWORK"; + + case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_WINDOW_OWNER: + return "THREAD_WINDOW_OWNER"; + + case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_WEBRTC_SIGNALING: + return "THREAD_WEBRTC_SIGNALING"; + + case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_WEBRTC_WORKER: + return "THREAD_WEBRTC_WORKER"; + + case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_PPAPI_MAIN: + return "THREAD_PPAPI_MAIN"; + + case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_GPU_WATCHDOG: + return "THREAD_GPU_WATCHDOG"; + + case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_SWAPPER: + return "THREAD_SWAPPER"; + + case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_GAMEPAD_POLLING: + return "THREAD_GAMEPAD_POLLING"; + + case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_WEBCRYPTO: + return "THREAD_WEBCRYPTO"; + + case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_DATABASE: + return "THREAD_DATABASE"; + + case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_PROXYRESOLVER: + return "THREAD_PROXYRESOLVER"; + + case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_DEVTOOLSADB: + return "THREAD_DEVTOOLSADB"; + + case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_NETWORKCONFIGWATCHER: + return "THREAD_NETWORKCONFIGWATCHER"; + + case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_WASAPI_RENDER: + return "THREAD_WASAPI_RENDER"; + + case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_LOADER_LOCK_SAMPLER: + return "THREAD_LOADER_LOCK_SAMPLER"; + + case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_MEMORY_INFRA: + return "THREAD_MEMORY_INFRA"; + + case ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType::THREAD_SAMPLING_PROFILER: + return "THREAD_SAMPLING_PROFILER"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_ChromeProcessDescriptor { +enum ProcessType : int32_t { + PROCESS_UNSPECIFIED = 0, + PROCESS_BROWSER = 1, + PROCESS_RENDERER = 2, + PROCESS_UTILITY = 3, + PROCESS_ZYGOTE = 4, + PROCESS_SANDBOX_HELPER = 5, + PROCESS_GPU = 6, + PROCESS_PPAPI_PLUGIN = 7, + PROCESS_PPAPI_BROKER = 8, + PROCESS_SERVICE_NETWORK = 9, + PROCESS_SERVICE_TRACING = 10, + PROCESS_SERVICE_STORAGE = 11, + PROCESS_SERVICE_AUDIO = 12, + PROCESS_SERVICE_DATA_DECODER = 13, + PROCESS_SERVICE_UTIL_WIN = 14, + PROCESS_SERVICE_PROXY_RESOLVER = 15, + PROCESS_SERVICE_CDM = 16, + PROCESS_SERVICE_VIDEO_CAPTURE = 17, + PROCESS_SERVICE_UNZIPPER = 18, + PROCESS_SERVICE_MIRRORING = 19, + PROCESS_SERVICE_FILEPATCHER = 20, + PROCESS_SERVICE_TTS = 21, + PROCESS_SERVICE_PRINTING = 22, + PROCESS_SERVICE_QUARANTINE = 23, + PROCESS_SERVICE_CROS_LOCALSEARCH = 24, + PROCESS_SERVICE_CROS_ASSISTANT_AUDIO_DECODER = 25, + PROCESS_SERVICE_FILEUTIL = 26, + PROCESS_SERVICE_PRINTCOMPOSITOR = 27, + PROCESS_SERVICE_PAINTPREVIEW = 28, + PROCESS_SERVICE_SPEECHRECOGNITION = 29, + PROCESS_SERVICE_XRDEVICE = 30, + PROCESS_SERVICE_READICON = 31, + PROCESS_SERVICE_LANGUAGEDETECTION = 32, + PROCESS_SERVICE_SHARING = 33, + PROCESS_SERVICE_MEDIAPARSER = 34, + PROCESS_SERVICE_QRCODEGENERATOR = 35, + PROCESS_SERVICE_PROFILEIMPORT = 36, + PROCESS_SERVICE_IME = 37, + PROCESS_SERVICE_RECORDING = 38, + PROCESS_SERVICE_SHAPEDETECTION = 39, + PROCESS_RENDERER_EXTENSION = 40, + PROCESS_SERVICE_MEDIA_FOUNDATION = 41, +}; +} // namespace perfetto_pbzero_enum_ChromeProcessDescriptor +using ChromeProcessDescriptor_ProcessType = perfetto_pbzero_enum_ChromeProcessDescriptor::ProcessType; + + +constexpr ChromeProcessDescriptor_ProcessType ChromeProcessDescriptor_ProcessType_MIN = ChromeProcessDescriptor_ProcessType::PROCESS_UNSPECIFIED; +constexpr ChromeProcessDescriptor_ProcessType ChromeProcessDescriptor_ProcessType_MAX = ChromeProcessDescriptor_ProcessType::PROCESS_SERVICE_MEDIA_FOUNDATION; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* ChromeProcessDescriptor_ProcessType_Name(::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType value) { + switch (value) { + case ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType::PROCESS_UNSPECIFIED: + return "PROCESS_UNSPECIFIED"; + + case ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType::PROCESS_BROWSER: + return "PROCESS_BROWSER"; + + case ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType::PROCESS_RENDERER: + return "PROCESS_RENDERER"; + + case ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType::PROCESS_UTILITY: + return "PROCESS_UTILITY"; + + case ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType::PROCESS_ZYGOTE: + return "PROCESS_ZYGOTE"; + + case ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType::PROCESS_SANDBOX_HELPER: + return "PROCESS_SANDBOX_HELPER"; + + case ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType::PROCESS_GPU: + return "PROCESS_GPU"; + + case ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType::PROCESS_PPAPI_PLUGIN: + return "PROCESS_PPAPI_PLUGIN"; + + case ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType::PROCESS_PPAPI_BROKER: + return "PROCESS_PPAPI_BROKER"; + + case ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType::PROCESS_SERVICE_NETWORK: + return "PROCESS_SERVICE_NETWORK"; + + case ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType::PROCESS_SERVICE_TRACING: + return "PROCESS_SERVICE_TRACING"; + + case ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType::PROCESS_SERVICE_STORAGE: + return "PROCESS_SERVICE_STORAGE"; + + case ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType::PROCESS_SERVICE_AUDIO: + return "PROCESS_SERVICE_AUDIO"; + + case ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType::PROCESS_SERVICE_DATA_DECODER: + return "PROCESS_SERVICE_DATA_DECODER"; + + case ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType::PROCESS_SERVICE_UTIL_WIN: + return "PROCESS_SERVICE_UTIL_WIN"; + + case ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType::PROCESS_SERVICE_PROXY_RESOLVER: + return "PROCESS_SERVICE_PROXY_RESOLVER"; + + case ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType::PROCESS_SERVICE_CDM: + return "PROCESS_SERVICE_CDM"; + + case ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType::PROCESS_SERVICE_VIDEO_CAPTURE: + return "PROCESS_SERVICE_VIDEO_CAPTURE"; + + case ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType::PROCESS_SERVICE_UNZIPPER: + return "PROCESS_SERVICE_UNZIPPER"; + + case ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType::PROCESS_SERVICE_MIRRORING: + return "PROCESS_SERVICE_MIRRORING"; + + case ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType::PROCESS_SERVICE_FILEPATCHER: + return "PROCESS_SERVICE_FILEPATCHER"; + + case ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType::PROCESS_SERVICE_TTS: + return "PROCESS_SERVICE_TTS"; + + case ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType::PROCESS_SERVICE_PRINTING: + return "PROCESS_SERVICE_PRINTING"; + + case ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType::PROCESS_SERVICE_QUARANTINE: + return "PROCESS_SERVICE_QUARANTINE"; + + case ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType::PROCESS_SERVICE_CROS_LOCALSEARCH: + return "PROCESS_SERVICE_CROS_LOCALSEARCH"; + + case ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType::PROCESS_SERVICE_CROS_ASSISTANT_AUDIO_DECODER: + return "PROCESS_SERVICE_CROS_ASSISTANT_AUDIO_DECODER"; + + case ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType::PROCESS_SERVICE_FILEUTIL: + return "PROCESS_SERVICE_FILEUTIL"; + + case ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType::PROCESS_SERVICE_PRINTCOMPOSITOR: + return "PROCESS_SERVICE_PRINTCOMPOSITOR"; + + case ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType::PROCESS_SERVICE_PAINTPREVIEW: + return "PROCESS_SERVICE_PAINTPREVIEW"; + + case ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType::PROCESS_SERVICE_SPEECHRECOGNITION: + return "PROCESS_SERVICE_SPEECHRECOGNITION"; + + case ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType::PROCESS_SERVICE_XRDEVICE: + return "PROCESS_SERVICE_XRDEVICE"; + + case ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType::PROCESS_SERVICE_READICON: + return "PROCESS_SERVICE_READICON"; + + case ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType::PROCESS_SERVICE_LANGUAGEDETECTION: + return "PROCESS_SERVICE_LANGUAGEDETECTION"; + + case ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType::PROCESS_SERVICE_SHARING: + return "PROCESS_SERVICE_SHARING"; + + case ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType::PROCESS_SERVICE_MEDIAPARSER: + return "PROCESS_SERVICE_MEDIAPARSER"; + + case ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType::PROCESS_SERVICE_QRCODEGENERATOR: + return "PROCESS_SERVICE_QRCODEGENERATOR"; + + case ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType::PROCESS_SERVICE_PROFILEIMPORT: + return "PROCESS_SERVICE_PROFILEIMPORT"; + + case ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType::PROCESS_SERVICE_IME: + return "PROCESS_SERVICE_IME"; + + case ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType::PROCESS_SERVICE_RECORDING: + return "PROCESS_SERVICE_RECORDING"; + + case ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType::PROCESS_SERVICE_SHAPEDETECTION: + return "PROCESS_SERVICE_SHAPEDETECTION"; + + case ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType::PROCESS_RENDERER_EXTENSION: + return "PROCESS_RENDERER_EXTENSION"; + + case ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType::PROCESS_SERVICE_MEDIA_FOUNDATION: + return "PROCESS_SERVICE_MEDIA_FOUNDATION"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_ThreadDescriptor { +enum ChromeThreadType : int32_t { + CHROME_THREAD_UNSPECIFIED = 0, + CHROME_THREAD_MAIN = 1, + CHROME_THREAD_IO = 2, + CHROME_THREAD_POOL_BG_WORKER = 3, + CHROME_THREAD_POOL_FG_WORKER = 4, + CHROME_THREAD_POOL_FB_BLOCKING = 5, + CHROME_THREAD_POOL_BG_BLOCKING = 6, + CHROME_THREAD_POOL_SERVICE = 7, + CHROME_THREAD_COMPOSITOR = 8, + CHROME_THREAD_VIZ_COMPOSITOR = 9, + CHROME_THREAD_COMPOSITOR_WORKER = 10, + CHROME_THREAD_SERVICE_WORKER = 11, + CHROME_THREAD_MEMORY_INFRA = 50, + CHROME_THREAD_SAMPLING_PROFILER = 51, +}; +} // namespace perfetto_pbzero_enum_ThreadDescriptor +using ThreadDescriptor_ChromeThreadType = perfetto_pbzero_enum_ThreadDescriptor::ChromeThreadType; + + +constexpr ThreadDescriptor_ChromeThreadType ThreadDescriptor_ChromeThreadType_MIN = ThreadDescriptor_ChromeThreadType::CHROME_THREAD_UNSPECIFIED; +constexpr ThreadDescriptor_ChromeThreadType ThreadDescriptor_ChromeThreadType_MAX = ThreadDescriptor_ChromeThreadType::CHROME_THREAD_SAMPLING_PROFILER; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* ThreadDescriptor_ChromeThreadType_Name(::perfetto::protos::pbzero::ThreadDescriptor_ChromeThreadType value) { + switch (value) { + case ::perfetto::protos::pbzero::ThreadDescriptor_ChromeThreadType::CHROME_THREAD_UNSPECIFIED: + return "CHROME_THREAD_UNSPECIFIED"; + + case ::perfetto::protos::pbzero::ThreadDescriptor_ChromeThreadType::CHROME_THREAD_MAIN: + return "CHROME_THREAD_MAIN"; + + case ::perfetto::protos::pbzero::ThreadDescriptor_ChromeThreadType::CHROME_THREAD_IO: + return "CHROME_THREAD_IO"; + + case ::perfetto::protos::pbzero::ThreadDescriptor_ChromeThreadType::CHROME_THREAD_POOL_BG_WORKER: + return "CHROME_THREAD_POOL_BG_WORKER"; + + case ::perfetto::protos::pbzero::ThreadDescriptor_ChromeThreadType::CHROME_THREAD_POOL_FG_WORKER: + return "CHROME_THREAD_POOL_FG_WORKER"; + + case ::perfetto::protos::pbzero::ThreadDescriptor_ChromeThreadType::CHROME_THREAD_POOL_FB_BLOCKING: + return "CHROME_THREAD_POOL_FB_BLOCKING"; + + case ::perfetto::protos::pbzero::ThreadDescriptor_ChromeThreadType::CHROME_THREAD_POOL_BG_BLOCKING: + return "CHROME_THREAD_POOL_BG_BLOCKING"; + + case ::perfetto::protos::pbzero::ThreadDescriptor_ChromeThreadType::CHROME_THREAD_POOL_SERVICE: + return "CHROME_THREAD_POOL_SERVICE"; + + case ::perfetto::protos::pbzero::ThreadDescriptor_ChromeThreadType::CHROME_THREAD_COMPOSITOR: + return "CHROME_THREAD_COMPOSITOR"; + + case ::perfetto::protos::pbzero::ThreadDescriptor_ChromeThreadType::CHROME_THREAD_VIZ_COMPOSITOR: + return "CHROME_THREAD_VIZ_COMPOSITOR"; + + case ::perfetto::protos::pbzero::ThreadDescriptor_ChromeThreadType::CHROME_THREAD_COMPOSITOR_WORKER: + return "CHROME_THREAD_COMPOSITOR_WORKER"; + + case ::perfetto::protos::pbzero::ThreadDescriptor_ChromeThreadType::CHROME_THREAD_SERVICE_WORKER: + return "CHROME_THREAD_SERVICE_WORKER"; + + case ::perfetto::protos::pbzero::ThreadDescriptor_ChromeThreadType::CHROME_THREAD_MEMORY_INFRA: + return "CHROME_THREAD_MEMORY_INFRA"; + + case ::perfetto::protos::pbzero::ThreadDescriptor_ChromeThreadType::CHROME_THREAD_SAMPLING_PROFILER: + return "CHROME_THREAD_SAMPLING_PROFILER"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_ProcessDescriptor { +enum ChromeProcessType : int32_t { + PROCESS_UNSPECIFIED = 0, + PROCESS_BROWSER = 1, + PROCESS_RENDERER = 2, + PROCESS_UTILITY = 3, + PROCESS_ZYGOTE = 4, + PROCESS_SANDBOX_HELPER = 5, + PROCESS_GPU = 6, + PROCESS_PPAPI_PLUGIN = 7, + PROCESS_PPAPI_BROKER = 8, +}; +} // namespace perfetto_pbzero_enum_ProcessDescriptor +using ProcessDescriptor_ChromeProcessType = perfetto_pbzero_enum_ProcessDescriptor::ChromeProcessType; + + +constexpr ProcessDescriptor_ChromeProcessType ProcessDescriptor_ChromeProcessType_MIN = ProcessDescriptor_ChromeProcessType::PROCESS_UNSPECIFIED; +constexpr ProcessDescriptor_ChromeProcessType ProcessDescriptor_ChromeProcessType_MAX = ProcessDescriptor_ChromeProcessType::PROCESS_PPAPI_BROKER; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* ProcessDescriptor_ChromeProcessType_Name(::perfetto::protos::pbzero::ProcessDescriptor_ChromeProcessType value) { + switch (value) { + case ::perfetto::protos::pbzero::ProcessDescriptor_ChromeProcessType::PROCESS_UNSPECIFIED: + return "PROCESS_UNSPECIFIED"; + + case ::perfetto::protos::pbzero::ProcessDescriptor_ChromeProcessType::PROCESS_BROWSER: + return "PROCESS_BROWSER"; + + case ::perfetto::protos::pbzero::ProcessDescriptor_ChromeProcessType::PROCESS_RENDERER: + return "PROCESS_RENDERER"; + + case ::perfetto::protos::pbzero::ProcessDescriptor_ChromeProcessType::PROCESS_UTILITY: + return "PROCESS_UTILITY"; + + case ::perfetto::protos::pbzero::ProcessDescriptor_ChromeProcessType::PROCESS_ZYGOTE: + return "PROCESS_ZYGOTE"; + + case ::perfetto::protos::pbzero::ProcessDescriptor_ChromeProcessType::PROCESS_SANDBOX_HELPER: + return "PROCESS_SANDBOX_HELPER"; + + case ::perfetto::protos::pbzero::ProcessDescriptor_ChromeProcessType::PROCESS_GPU: + return "PROCESS_GPU"; + + case ::perfetto::protos::pbzero::ProcessDescriptor_ChromeProcessType::PROCESS_PPAPI_PLUGIN: + return "PROCESS_PPAPI_PLUGIN"; + + case ::perfetto::protos::pbzero::ProcessDescriptor_ChromeProcessType::PROCESS_PPAPI_BROKER: + return "PROCESS_PPAPI_BROKER"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_SysStats_PsiSample { +enum PsiResource : int32_t { + PSI_RESOURCE_UNSPECIFIED = 0, + PSI_RESOURCE_CPU_SOME = 1, + PSI_RESOURCE_CPU_FULL = 2, + PSI_RESOURCE_IO_SOME = 3, + PSI_RESOURCE_IO_FULL = 4, + PSI_RESOURCE_MEMORY_SOME = 5, + PSI_RESOURCE_MEMORY_FULL = 6, +}; +} // namespace perfetto_pbzero_enum_SysStats_PsiSample +using SysStats_PsiSample_PsiResource = perfetto_pbzero_enum_SysStats_PsiSample::PsiResource; + + +constexpr SysStats_PsiSample_PsiResource SysStats_PsiSample_PsiResource_MIN = SysStats_PsiSample_PsiResource::PSI_RESOURCE_UNSPECIFIED; +constexpr SysStats_PsiSample_PsiResource SysStats_PsiSample_PsiResource_MAX = SysStats_PsiSample_PsiResource::PSI_RESOURCE_MEMORY_FULL; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* SysStats_PsiSample_PsiResource_Name(::perfetto::protos::pbzero::SysStats_PsiSample_PsiResource value) { + switch (value) { + case ::perfetto::protos::pbzero::SysStats_PsiSample_PsiResource::PSI_RESOURCE_UNSPECIFIED: + return "PSI_RESOURCE_UNSPECIFIED"; + + case ::perfetto::protos::pbzero::SysStats_PsiSample_PsiResource::PSI_RESOURCE_CPU_SOME: + return "PSI_RESOURCE_CPU_SOME"; + + case ::perfetto::protos::pbzero::SysStats_PsiSample_PsiResource::PSI_RESOURCE_CPU_FULL: + return "PSI_RESOURCE_CPU_FULL"; + + case ::perfetto::protos::pbzero::SysStats_PsiSample_PsiResource::PSI_RESOURCE_IO_SOME: + return "PSI_RESOURCE_IO_SOME"; + + case ::perfetto::protos::pbzero::SysStats_PsiSample_PsiResource::PSI_RESOURCE_IO_FULL: + return "PSI_RESOURCE_IO_FULL"; + + case ::perfetto::protos::pbzero::SysStats_PsiSample_PsiResource::PSI_RESOURCE_MEMORY_SOME: + return "PSI_RESOURCE_MEMORY_SOME"; + + case ::perfetto::protos::pbzero::SysStats_PsiSample_PsiResource::PSI_RESOURCE_MEMORY_FULL: + return "PSI_RESOURCE_MEMORY_FULL"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_PerfSample { +enum SampleSkipReason : int32_t { + PROFILER_SKIP_UNKNOWN = 0, + PROFILER_SKIP_READ_STAGE = 1, + PROFILER_SKIP_UNWIND_STAGE = 2, + PROFILER_SKIP_UNWIND_ENQUEUE = 3, +}; +} // namespace perfetto_pbzero_enum_PerfSample +using PerfSample_SampleSkipReason = perfetto_pbzero_enum_PerfSample::SampleSkipReason; + + +constexpr PerfSample_SampleSkipReason PerfSample_SampleSkipReason_MIN = PerfSample_SampleSkipReason::PROFILER_SKIP_UNKNOWN; +constexpr PerfSample_SampleSkipReason PerfSample_SampleSkipReason_MAX = PerfSample_SampleSkipReason::PROFILER_SKIP_UNWIND_ENQUEUE; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* PerfSample_SampleSkipReason_Name(::perfetto::protos::pbzero::PerfSample_SampleSkipReason value) { + switch (value) { + case ::perfetto::protos::pbzero::PerfSample_SampleSkipReason::PROFILER_SKIP_UNKNOWN: + return "PROFILER_SKIP_UNKNOWN"; + + case ::perfetto::protos::pbzero::PerfSample_SampleSkipReason::PROFILER_SKIP_READ_STAGE: + return "PROFILER_SKIP_READ_STAGE"; + + case ::perfetto::protos::pbzero::PerfSample_SampleSkipReason::PROFILER_SKIP_UNWIND_STAGE: + return "PROFILER_SKIP_UNWIND_STAGE"; + + case ::perfetto::protos::pbzero::PerfSample_SampleSkipReason::PROFILER_SKIP_UNWIND_ENQUEUE: + return "PROFILER_SKIP_UNWIND_ENQUEUE"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_PerfSample_ProducerEvent { +enum DataSourceStopReason : int32_t { + PROFILER_STOP_UNKNOWN = 0, + PROFILER_STOP_GUARDRAIL = 1, +}; +} // namespace perfetto_pbzero_enum_PerfSample_ProducerEvent +using PerfSample_ProducerEvent_DataSourceStopReason = perfetto_pbzero_enum_PerfSample_ProducerEvent::DataSourceStopReason; + + +constexpr PerfSample_ProducerEvent_DataSourceStopReason PerfSample_ProducerEvent_DataSourceStopReason_MIN = PerfSample_ProducerEvent_DataSourceStopReason::PROFILER_STOP_UNKNOWN; +constexpr PerfSample_ProducerEvent_DataSourceStopReason PerfSample_ProducerEvent_DataSourceStopReason_MAX = PerfSample_ProducerEvent_DataSourceStopReason::PROFILER_STOP_GUARDRAIL; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* PerfSample_ProducerEvent_DataSourceStopReason_Name(::perfetto::protos::pbzero::PerfSample_ProducerEvent_DataSourceStopReason value) { + switch (value) { + case ::perfetto::protos::pbzero::PerfSample_ProducerEvent_DataSourceStopReason::PROFILER_STOP_UNKNOWN: + return "PROFILER_STOP_UNKNOWN"; + + case ::perfetto::protos::pbzero::PerfSample_ProducerEvent_DataSourceStopReason::PROFILER_STOP_GUARDRAIL: + return "PROFILER_STOP_GUARDRAIL"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_Profiling { +enum CpuMode : int32_t { + MODE_UNKNOWN = 0, + MODE_KERNEL = 1, + MODE_USER = 2, + MODE_HYPERVISOR = 3, + MODE_GUEST_KERNEL = 4, + MODE_GUEST_USER = 5, +}; +} // namespace perfetto_pbzero_enum_Profiling +using Profiling_CpuMode = perfetto_pbzero_enum_Profiling::CpuMode; + + +constexpr Profiling_CpuMode Profiling_CpuMode_MIN = Profiling_CpuMode::MODE_UNKNOWN; +constexpr Profiling_CpuMode Profiling_CpuMode_MAX = Profiling_CpuMode::MODE_GUEST_USER; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* Profiling_CpuMode_Name(::perfetto::protos::pbzero::Profiling_CpuMode value) { + switch (value) { + case ::perfetto::protos::pbzero::Profiling_CpuMode::MODE_UNKNOWN: + return "MODE_UNKNOWN"; + + case ::perfetto::protos::pbzero::Profiling_CpuMode::MODE_KERNEL: + return "MODE_KERNEL"; + + case ::perfetto::protos::pbzero::Profiling_CpuMode::MODE_USER: + return "MODE_USER"; + + case ::perfetto::protos::pbzero::Profiling_CpuMode::MODE_HYPERVISOR: + return "MODE_HYPERVISOR"; + + case ::perfetto::protos::pbzero::Profiling_CpuMode::MODE_GUEST_KERNEL: + return "MODE_GUEST_KERNEL"; + + case ::perfetto::protos::pbzero::Profiling_CpuMode::MODE_GUEST_USER: + return "MODE_GUEST_USER"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_Profiling { +enum StackUnwindError : int32_t { + UNWIND_ERROR_UNKNOWN = 0, + UNWIND_ERROR_NONE = 1, + UNWIND_ERROR_MEMORY_INVALID = 2, + UNWIND_ERROR_UNWIND_INFO = 3, + UNWIND_ERROR_UNSUPPORTED = 4, + UNWIND_ERROR_INVALID_MAP = 5, + UNWIND_ERROR_MAX_FRAMES_EXCEEDED = 6, + UNWIND_ERROR_REPEATED_FRAME = 7, + UNWIND_ERROR_INVALID_ELF = 8, + UNWIND_ERROR_SYSTEM_CALL = 9, + UNWIND_ERROR_THREAD_TIMEOUT = 10, + UNWIND_ERROR_THREAD_DOES_NOT_EXIST = 11, + UNWIND_ERROR_BAD_ARCH = 12, + UNWIND_ERROR_MAPS_PARSE = 13, + UNWIND_ERROR_INVALID_PARAMETER = 14, + UNWIND_ERROR_PTRACE_CALL = 15, +}; +} // namespace perfetto_pbzero_enum_Profiling +using Profiling_StackUnwindError = perfetto_pbzero_enum_Profiling::StackUnwindError; + + +constexpr Profiling_StackUnwindError Profiling_StackUnwindError_MIN = Profiling_StackUnwindError::UNWIND_ERROR_UNKNOWN; +constexpr Profiling_StackUnwindError Profiling_StackUnwindError_MAX = Profiling_StackUnwindError::UNWIND_ERROR_PTRACE_CALL; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* Profiling_StackUnwindError_Name(::perfetto::protos::pbzero::Profiling_StackUnwindError value) { + switch (value) { + case ::perfetto::protos::pbzero::Profiling_StackUnwindError::UNWIND_ERROR_UNKNOWN: + return "UNWIND_ERROR_UNKNOWN"; + + case ::perfetto::protos::pbzero::Profiling_StackUnwindError::UNWIND_ERROR_NONE: + return "UNWIND_ERROR_NONE"; + + case ::perfetto::protos::pbzero::Profiling_StackUnwindError::UNWIND_ERROR_MEMORY_INVALID: + return "UNWIND_ERROR_MEMORY_INVALID"; + + case ::perfetto::protos::pbzero::Profiling_StackUnwindError::UNWIND_ERROR_UNWIND_INFO: + return "UNWIND_ERROR_UNWIND_INFO"; + + case ::perfetto::protos::pbzero::Profiling_StackUnwindError::UNWIND_ERROR_UNSUPPORTED: + return "UNWIND_ERROR_UNSUPPORTED"; + + case ::perfetto::protos::pbzero::Profiling_StackUnwindError::UNWIND_ERROR_INVALID_MAP: + return "UNWIND_ERROR_INVALID_MAP"; + + case ::perfetto::protos::pbzero::Profiling_StackUnwindError::UNWIND_ERROR_MAX_FRAMES_EXCEEDED: + return "UNWIND_ERROR_MAX_FRAMES_EXCEEDED"; + + case ::perfetto::protos::pbzero::Profiling_StackUnwindError::UNWIND_ERROR_REPEATED_FRAME: + return "UNWIND_ERROR_REPEATED_FRAME"; + + case ::perfetto::protos::pbzero::Profiling_StackUnwindError::UNWIND_ERROR_INVALID_ELF: + return "UNWIND_ERROR_INVALID_ELF"; + + case ::perfetto::protos::pbzero::Profiling_StackUnwindError::UNWIND_ERROR_SYSTEM_CALL: + return "UNWIND_ERROR_SYSTEM_CALL"; + + case ::perfetto::protos::pbzero::Profiling_StackUnwindError::UNWIND_ERROR_THREAD_TIMEOUT: + return "UNWIND_ERROR_THREAD_TIMEOUT"; + + case ::perfetto::protos::pbzero::Profiling_StackUnwindError::UNWIND_ERROR_THREAD_DOES_NOT_EXIST: + return "UNWIND_ERROR_THREAD_DOES_NOT_EXIST"; + + case ::perfetto::protos::pbzero::Profiling_StackUnwindError::UNWIND_ERROR_BAD_ARCH: + return "UNWIND_ERROR_BAD_ARCH"; + + case ::perfetto::protos::pbzero::Profiling_StackUnwindError::UNWIND_ERROR_MAPS_PARSE: + return "UNWIND_ERROR_MAPS_PARSE"; + + case ::perfetto::protos::pbzero::Profiling_StackUnwindError::UNWIND_ERROR_INVALID_PARAMETER: + return "UNWIND_ERROR_INVALID_PARAMETER"; + + case ::perfetto::protos::pbzero::Profiling_StackUnwindError::UNWIND_ERROR_PTRACE_CALL: + return "UNWIND_ERROR_PTRACE_CALL"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_ProfilePacket_ProcessHeapSamples { +enum ClientError : int32_t { + CLIENT_ERROR_NONE = 0, + CLIENT_ERROR_HIT_TIMEOUT = 1, + CLIENT_ERROR_INVALID_STACK_BOUNDS = 2, +}; +} // namespace perfetto_pbzero_enum_ProfilePacket_ProcessHeapSamples +using ProfilePacket_ProcessHeapSamples_ClientError = perfetto_pbzero_enum_ProfilePacket_ProcessHeapSamples::ClientError; + + +constexpr ProfilePacket_ProcessHeapSamples_ClientError ProfilePacket_ProcessHeapSamples_ClientError_MIN = ProfilePacket_ProcessHeapSamples_ClientError::CLIENT_ERROR_NONE; +constexpr ProfilePacket_ProcessHeapSamples_ClientError ProfilePacket_ProcessHeapSamples_ClientError_MAX = ProfilePacket_ProcessHeapSamples_ClientError::CLIENT_ERROR_INVALID_STACK_BOUNDS; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* ProfilePacket_ProcessHeapSamples_ClientError_Name(::perfetto::protos::pbzero::ProfilePacket_ProcessHeapSamples_ClientError value) { + switch (value) { + case ::perfetto::protos::pbzero::ProfilePacket_ProcessHeapSamples_ClientError::CLIENT_ERROR_NONE: + return "CLIENT_ERROR_NONE"; + + case ::perfetto::protos::pbzero::ProfilePacket_ProcessHeapSamples_ClientError::CLIENT_ERROR_HIT_TIMEOUT: + return "CLIENT_ERROR_HIT_TIMEOUT"; + + case ::perfetto::protos::pbzero::ProfilePacket_ProcessHeapSamples_ClientError::CLIENT_ERROR_INVALID_STACK_BOUNDS: + return "CLIENT_ERROR_INVALID_STACK_BOUNDS"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_HeapGraphType { +enum Kind : int32_t { + KIND_UNKNOWN = 0, + KIND_NORMAL = 1, + KIND_NOREFERENCES = 2, + KIND_STRING = 3, + KIND_ARRAY = 4, + KIND_CLASS = 5, + KIND_CLASSLOADER = 6, + KIND_DEXCACHE = 7, + KIND_SOFT_REFERENCE = 8, + KIND_WEAK_REFERENCE = 9, + KIND_FINALIZER_REFERENCE = 10, + KIND_PHANTOM_REFERENCE = 11, +}; +} // namespace perfetto_pbzero_enum_HeapGraphType +using HeapGraphType_Kind = perfetto_pbzero_enum_HeapGraphType::Kind; + + +constexpr HeapGraphType_Kind HeapGraphType_Kind_MIN = HeapGraphType_Kind::KIND_UNKNOWN; +constexpr HeapGraphType_Kind HeapGraphType_Kind_MAX = HeapGraphType_Kind::KIND_PHANTOM_REFERENCE; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* HeapGraphType_Kind_Name(::perfetto::protos::pbzero::HeapGraphType_Kind value) { + switch (value) { + case ::perfetto::protos::pbzero::HeapGraphType_Kind::KIND_UNKNOWN: + return "KIND_UNKNOWN"; + + case ::perfetto::protos::pbzero::HeapGraphType_Kind::KIND_NORMAL: + return "KIND_NORMAL"; + + case ::perfetto::protos::pbzero::HeapGraphType_Kind::KIND_NOREFERENCES: + return "KIND_NOREFERENCES"; + + case ::perfetto::protos::pbzero::HeapGraphType_Kind::KIND_STRING: + return "KIND_STRING"; + + case ::perfetto::protos::pbzero::HeapGraphType_Kind::KIND_ARRAY: + return "KIND_ARRAY"; + + case ::perfetto::protos::pbzero::HeapGraphType_Kind::KIND_CLASS: + return "KIND_CLASS"; + + case ::perfetto::protos::pbzero::HeapGraphType_Kind::KIND_CLASSLOADER: + return "KIND_CLASSLOADER"; + + case ::perfetto::protos::pbzero::HeapGraphType_Kind::KIND_DEXCACHE: + return "KIND_DEXCACHE"; + + case ::perfetto::protos::pbzero::HeapGraphType_Kind::KIND_SOFT_REFERENCE: + return "KIND_SOFT_REFERENCE"; + + case ::perfetto::protos::pbzero::HeapGraphType_Kind::KIND_WEAK_REFERENCE: + return "KIND_WEAK_REFERENCE"; + + case ::perfetto::protos::pbzero::HeapGraphType_Kind::KIND_FINALIZER_REFERENCE: + return "KIND_FINALIZER_REFERENCE"; + + case ::perfetto::protos::pbzero::HeapGraphType_Kind::KIND_PHANTOM_REFERENCE: + return "KIND_PHANTOM_REFERENCE"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_HeapGraphRoot { +enum Type : int32_t { + ROOT_UNKNOWN = 0, + ROOT_JNI_GLOBAL = 1, + ROOT_JNI_LOCAL = 2, + ROOT_JAVA_FRAME = 3, + ROOT_NATIVE_STACK = 4, + ROOT_STICKY_CLASS = 5, + ROOT_THREAD_BLOCK = 6, + ROOT_MONITOR_USED = 7, + ROOT_THREAD_OBJECT = 8, + ROOT_INTERNED_STRING = 9, + ROOT_FINALIZING = 10, + ROOT_DEBUGGER = 11, + ROOT_REFERENCE_CLEANUP = 12, + ROOT_VM_INTERNAL = 13, + ROOT_JNI_MONITOR = 14, +}; +} // namespace perfetto_pbzero_enum_HeapGraphRoot +using HeapGraphRoot_Type = perfetto_pbzero_enum_HeapGraphRoot::Type; + + +constexpr HeapGraphRoot_Type HeapGraphRoot_Type_MIN = HeapGraphRoot_Type::ROOT_UNKNOWN; +constexpr HeapGraphRoot_Type HeapGraphRoot_Type_MAX = HeapGraphRoot_Type::ROOT_JNI_MONITOR; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* HeapGraphRoot_Type_Name(::perfetto::protos::pbzero::HeapGraphRoot_Type value) { + switch (value) { + case ::perfetto::protos::pbzero::HeapGraphRoot_Type::ROOT_UNKNOWN: + return "ROOT_UNKNOWN"; + + case ::perfetto::protos::pbzero::HeapGraphRoot_Type::ROOT_JNI_GLOBAL: + return "ROOT_JNI_GLOBAL"; + + case ::perfetto::protos::pbzero::HeapGraphRoot_Type::ROOT_JNI_LOCAL: + return "ROOT_JNI_LOCAL"; + + case ::perfetto::protos::pbzero::HeapGraphRoot_Type::ROOT_JAVA_FRAME: + return "ROOT_JAVA_FRAME"; + + case ::perfetto::protos::pbzero::HeapGraphRoot_Type::ROOT_NATIVE_STACK: + return "ROOT_NATIVE_STACK"; + + case ::perfetto::protos::pbzero::HeapGraphRoot_Type::ROOT_STICKY_CLASS: + return "ROOT_STICKY_CLASS"; + + case ::perfetto::protos::pbzero::HeapGraphRoot_Type::ROOT_THREAD_BLOCK: + return "ROOT_THREAD_BLOCK"; + + case ::perfetto::protos::pbzero::HeapGraphRoot_Type::ROOT_MONITOR_USED: + return "ROOT_MONITOR_USED"; + + case ::perfetto::protos::pbzero::HeapGraphRoot_Type::ROOT_THREAD_OBJECT: + return "ROOT_THREAD_OBJECT"; + + case ::perfetto::protos::pbzero::HeapGraphRoot_Type::ROOT_INTERNED_STRING: + return "ROOT_INTERNED_STRING"; + + case ::perfetto::protos::pbzero::HeapGraphRoot_Type::ROOT_FINALIZING: + return "ROOT_FINALIZING"; + + case ::perfetto::protos::pbzero::HeapGraphRoot_Type::ROOT_DEBUGGER: + return "ROOT_DEBUGGER"; + + case ::perfetto::protos::pbzero::HeapGraphRoot_Type::ROOT_REFERENCE_CLEANUP: + return "ROOT_REFERENCE_CLEANUP"; + + case ::perfetto::protos::pbzero::HeapGraphRoot_Type::ROOT_VM_INTERNAL: + return "ROOT_VM_INTERNAL"; + + case ::perfetto::protos::pbzero::HeapGraphRoot_Type::ROOT_JNI_MONITOR: + return "ROOT_JNI_MONITOR"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_MemoryTrackerSnapshot { +enum LevelOfDetail : int32_t { + DETAIL_FULL = 0, + DETAIL_LIGHT = 1, + DETAIL_BACKGROUND = 2, +}; +} // namespace perfetto_pbzero_enum_MemoryTrackerSnapshot +using MemoryTrackerSnapshot_LevelOfDetail = perfetto_pbzero_enum_MemoryTrackerSnapshot::LevelOfDetail; + + +constexpr MemoryTrackerSnapshot_LevelOfDetail MemoryTrackerSnapshot_LevelOfDetail_MIN = MemoryTrackerSnapshot_LevelOfDetail::DETAIL_FULL; +constexpr MemoryTrackerSnapshot_LevelOfDetail MemoryTrackerSnapshot_LevelOfDetail_MAX = MemoryTrackerSnapshot_LevelOfDetail::DETAIL_BACKGROUND; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* MemoryTrackerSnapshot_LevelOfDetail_Name(::perfetto::protos::pbzero::MemoryTrackerSnapshot_LevelOfDetail value) { + switch (value) { + case ::perfetto::protos::pbzero::MemoryTrackerSnapshot_LevelOfDetail::DETAIL_FULL: + return "DETAIL_FULL"; + + case ::perfetto::protos::pbzero::MemoryTrackerSnapshot_LevelOfDetail::DETAIL_LIGHT: + return "DETAIL_LIGHT"; + + case ::perfetto::protos::pbzero::MemoryTrackerSnapshot_LevelOfDetail::DETAIL_BACKGROUND: + return "DETAIL_BACKGROUND"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry { +enum Units : int32_t { + UNSPECIFIED = 0, + BYTES = 1, + COUNT = 2, +}; +} // namespace perfetto_pbzero_enum_MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry +using MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry_Units = perfetto_pbzero_enum_MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry::Units; + + +constexpr MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry_Units MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry_Units_MIN = MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry_Units::UNSPECIFIED; +constexpr MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry_Units MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry_Units_MAX = MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry_Units::COUNT; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry_Units_Name(::perfetto::protos::pbzero::MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry_Units value) { + switch (value) { + case ::perfetto::protos::pbzero::MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry_Units::UNSPECIFIED: + return "UNSPECIFIED"; + + case ::perfetto::protos::pbzero::MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry_Units::BYTES: + return "BYTES"; + + case ::perfetto::protos::pbzero::MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry_Units::COUNT: + return "COUNT"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_TrackEvent { +enum Type : int32_t { + TYPE_UNSPECIFIED = 0, + TYPE_SLICE_BEGIN = 1, + TYPE_SLICE_END = 2, + TYPE_INSTANT = 3, + TYPE_COUNTER = 4, +}; +} // namespace perfetto_pbzero_enum_TrackEvent +using TrackEvent_Type = perfetto_pbzero_enum_TrackEvent::Type; + + +constexpr TrackEvent_Type TrackEvent_Type_MIN = TrackEvent_Type::TYPE_UNSPECIFIED; +constexpr TrackEvent_Type TrackEvent_Type_MAX = TrackEvent_Type::TYPE_COUNTER; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* TrackEvent_Type_Name(::perfetto::protos::pbzero::TrackEvent_Type value) { + switch (value) { + case ::perfetto::protos::pbzero::TrackEvent_Type::TYPE_UNSPECIFIED: + return "TYPE_UNSPECIFIED"; + + case ::perfetto::protos::pbzero::TrackEvent_Type::TYPE_SLICE_BEGIN: + return "TYPE_SLICE_BEGIN"; + + case ::perfetto::protos::pbzero::TrackEvent_Type::TYPE_SLICE_END: + return "TYPE_SLICE_END"; + + case ::perfetto::protos::pbzero::TrackEvent_Type::TYPE_INSTANT: + return "TYPE_INSTANT"; + + case ::perfetto::protos::pbzero::TrackEvent_Type::TYPE_COUNTER: + return "TYPE_COUNTER"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_TrackEvent_LegacyEvent { +enum FlowDirection : int32_t { + FLOW_UNSPECIFIED = 0, + FLOW_IN = 1, + FLOW_OUT = 2, + FLOW_INOUT = 3, +}; +} // namespace perfetto_pbzero_enum_TrackEvent_LegacyEvent +using TrackEvent_LegacyEvent_FlowDirection = perfetto_pbzero_enum_TrackEvent_LegacyEvent::FlowDirection; + + +constexpr TrackEvent_LegacyEvent_FlowDirection TrackEvent_LegacyEvent_FlowDirection_MIN = TrackEvent_LegacyEvent_FlowDirection::FLOW_UNSPECIFIED; +constexpr TrackEvent_LegacyEvent_FlowDirection TrackEvent_LegacyEvent_FlowDirection_MAX = TrackEvent_LegacyEvent_FlowDirection::FLOW_INOUT; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* TrackEvent_LegacyEvent_FlowDirection_Name(::perfetto::protos::pbzero::TrackEvent_LegacyEvent_FlowDirection value) { + switch (value) { + case ::perfetto::protos::pbzero::TrackEvent_LegacyEvent_FlowDirection::FLOW_UNSPECIFIED: + return "FLOW_UNSPECIFIED"; + + case ::perfetto::protos::pbzero::TrackEvent_LegacyEvent_FlowDirection::FLOW_IN: + return "FLOW_IN"; + + case ::perfetto::protos::pbzero::TrackEvent_LegacyEvent_FlowDirection::FLOW_OUT: + return "FLOW_OUT"; + + case ::perfetto::protos::pbzero::TrackEvent_LegacyEvent_FlowDirection::FLOW_INOUT: + return "FLOW_INOUT"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_TrackEvent_LegacyEvent { +enum InstantEventScope : int32_t { + SCOPE_UNSPECIFIED = 0, + SCOPE_GLOBAL = 1, + SCOPE_PROCESS = 2, + SCOPE_THREAD = 3, +}; +} // namespace perfetto_pbzero_enum_TrackEvent_LegacyEvent +using TrackEvent_LegacyEvent_InstantEventScope = perfetto_pbzero_enum_TrackEvent_LegacyEvent::InstantEventScope; + + +constexpr TrackEvent_LegacyEvent_InstantEventScope TrackEvent_LegacyEvent_InstantEventScope_MIN = TrackEvent_LegacyEvent_InstantEventScope::SCOPE_UNSPECIFIED; +constexpr TrackEvent_LegacyEvent_InstantEventScope TrackEvent_LegacyEvent_InstantEventScope_MAX = TrackEvent_LegacyEvent_InstantEventScope::SCOPE_THREAD; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* TrackEvent_LegacyEvent_InstantEventScope_Name(::perfetto::protos::pbzero::TrackEvent_LegacyEvent_InstantEventScope value) { + switch (value) { + case ::perfetto::protos::pbzero::TrackEvent_LegacyEvent_InstantEventScope::SCOPE_UNSPECIFIED: + return "SCOPE_UNSPECIFIED"; + + case ::perfetto::protos::pbzero::TrackEvent_LegacyEvent_InstantEventScope::SCOPE_GLOBAL: + return "SCOPE_GLOBAL"; + + case ::perfetto::protos::pbzero::TrackEvent_LegacyEvent_InstantEventScope::SCOPE_PROCESS: + return "SCOPE_PROCESS"; + + case ::perfetto::protos::pbzero::TrackEvent_LegacyEvent_InstantEventScope::SCOPE_THREAD: + return "SCOPE_THREAD"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_ChromeLegacyIpc { +enum MessageClass : int32_t { + CLASS_UNSPECIFIED = 0, + CLASS_AUTOMATION = 1, + CLASS_FRAME = 2, + CLASS_PAGE = 3, + CLASS_VIEW = 4, + CLASS_WIDGET = 5, + CLASS_INPUT = 6, + CLASS_TEST = 7, + CLASS_WORKER = 8, + CLASS_NACL = 9, + CLASS_GPU_CHANNEL = 10, + CLASS_MEDIA = 11, + CLASS_PPAPI = 12, + CLASS_CHROME = 13, + CLASS_DRAG = 14, + CLASS_PRINT = 15, + CLASS_EXTENSION = 16, + CLASS_TEXT_INPUT_CLIENT = 17, + CLASS_BLINK_TEST = 18, + CLASS_ACCESSIBILITY = 19, + CLASS_PRERENDER = 20, + CLASS_CHROMOTING = 21, + CLASS_BROWSER_PLUGIN = 22, + CLASS_ANDROID_WEB_VIEW = 23, + CLASS_NACL_HOST = 24, + CLASS_ENCRYPTED_MEDIA = 25, + CLASS_CAST = 26, + CLASS_GIN_JAVA_BRIDGE = 27, + CLASS_CHROME_UTILITY_PRINTING = 28, + CLASS_OZONE_GPU = 29, + CLASS_WEB_TEST = 30, + CLASS_NETWORK_HINTS = 31, + CLASS_EXTENSIONS_GUEST_VIEW = 32, + CLASS_GUEST_VIEW = 33, + CLASS_MEDIA_PLAYER_DELEGATE = 34, + CLASS_EXTENSION_WORKER = 35, + CLASS_SUBRESOURCE_FILTER = 36, + CLASS_UNFREEZABLE_FRAME = 37, +}; +} // namespace perfetto_pbzero_enum_ChromeLegacyIpc +using ChromeLegacyIpc_MessageClass = perfetto_pbzero_enum_ChromeLegacyIpc::MessageClass; + + +constexpr ChromeLegacyIpc_MessageClass ChromeLegacyIpc_MessageClass_MIN = ChromeLegacyIpc_MessageClass::CLASS_UNSPECIFIED; +constexpr ChromeLegacyIpc_MessageClass ChromeLegacyIpc_MessageClass_MAX = ChromeLegacyIpc_MessageClass::CLASS_UNFREEZABLE_FRAME; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* ChromeLegacyIpc_MessageClass_Name(::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass value) { + switch (value) { + case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_UNSPECIFIED: + return "CLASS_UNSPECIFIED"; + + case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_AUTOMATION: + return "CLASS_AUTOMATION"; + + case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_FRAME: + return "CLASS_FRAME"; + + case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_PAGE: + return "CLASS_PAGE"; + + case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_VIEW: + return "CLASS_VIEW"; + + case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_WIDGET: + return "CLASS_WIDGET"; + + case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_INPUT: + return "CLASS_INPUT"; + + case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_TEST: + return "CLASS_TEST"; + + case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_WORKER: + return "CLASS_WORKER"; + + case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_NACL: + return "CLASS_NACL"; + + case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_GPU_CHANNEL: + return "CLASS_GPU_CHANNEL"; + + case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_MEDIA: + return "CLASS_MEDIA"; + + case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_PPAPI: + return "CLASS_PPAPI"; + + case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_CHROME: + return "CLASS_CHROME"; + + case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_DRAG: + return "CLASS_DRAG"; + + case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_PRINT: + return "CLASS_PRINT"; + + case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_EXTENSION: + return "CLASS_EXTENSION"; + + case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_TEXT_INPUT_CLIENT: + return "CLASS_TEXT_INPUT_CLIENT"; + + case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_BLINK_TEST: + return "CLASS_BLINK_TEST"; + + case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_ACCESSIBILITY: + return "CLASS_ACCESSIBILITY"; + + case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_PRERENDER: + return "CLASS_PRERENDER"; + + case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_CHROMOTING: + return "CLASS_CHROMOTING"; + + case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_BROWSER_PLUGIN: + return "CLASS_BROWSER_PLUGIN"; + + case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_ANDROID_WEB_VIEW: + return "CLASS_ANDROID_WEB_VIEW"; + + case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_NACL_HOST: + return "CLASS_NACL_HOST"; + + case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_ENCRYPTED_MEDIA: + return "CLASS_ENCRYPTED_MEDIA"; + + case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_CAST: + return "CLASS_CAST"; + + case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_GIN_JAVA_BRIDGE: + return "CLASS_GIN_JAVA_BRIDGE"; + + case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_CHROME_UTILITY_PRINTING: + return "CLASS_CHROME_UTILITY_PRINTING"; + + case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_OZONE_GPU: + return "CLASS_OZONE_GPU"; + + case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_WEB_TEST: + return "CLASS_WEB_TEST"; + + case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_NETWORK_HINTS: + return "CLASS_NETWORK_HINTS"; + + case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_EXTENSIONS_GUEST_VIEW: + return "CLASS_EXTENSIONS_GUEST_VIEW"; + + case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_GUEST_VIEW: + return "CLASS_GUEST_VIEW"; + + case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_MEDIA_PLAYER_DELEGATE: + return "CLASS_MEDIA_PLAYER_DELEGATE"; + + case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_EXTENSION_WORKER: + return "CLASS_EXTENSION_WORKER"; + + case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_SUBRESOURCE_FILTER: + return "CLASS_SUBRESOURCE_FILTER"; + + case ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass::CLASS_UNFREEZABLE_FRAME: + return "CLASS_UNFREEZABLE_FRAME"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_ChromeLatencyInfo { +enum Step : int32_t { + STEP_UNSPECIFIED = 0, + STEP_SEND_INPUT_EVENT_UI = 3, + STEP_HANDLE_INPUT_EVENT_IMPL = 5, + STEP_DID_HANDLE_INPUT_AND_OVERSCROLL = 8, + STEP_HANDLE_INPUT_EVENT_MAIN = 4, + STEP_MAIN_THREAD_SCROLL_UPDATE = 2, + STEP_HANDLE_INPUT_EVENT_MAIN_COMMIT = 1, + STEP_HANDLED_INPUT_EVENT_MAIN_OR_IMPL = 9, + STEP_HANDLED_INPUT_EVENT_IMPL = 10, + STEP_SWAP_BUFFERS = 6, + STEP_DRAW_AND_SWAP = 7, + STEP_FINISHED_SWAP_BUFFERS = 11, +}; +} // namespace perfetto_pbzero_enum_ChromeLatencyInfo +using ChromeLatencyInfo_Step = perfetto_pbzero_enum_ChromeLatencyInfo::Step; + + +constexpr ChromeLatencyInfo_Step ChromeLatencyInfo_Step_MIN = ChromeLatencyInfo_Step::STEP_UNSPECIFIED; +constexpr ChromeLatencyInfo_Step ChromeLatencyInfo_Step_MAX = ChromeLatencyInfo_Step::STEP_FINISHED_SWAP_BUFFERS; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* ChromeLatencyInfo_Step_Name(::perfetto::protos::pbzero::ChromeLatencyInfo_Step value) { + switch (value) { + case ::perfetto::protos::pbzero::ChromeLatencyInfo_Step::STEP_UNSPECIFIED: + return "STEP_UNSPECIFIED"; + + case ::perfetto::protos::pbzero::ChromeLatencyInfo_Step::STEP_SEND_INPUT_EVENT_UI: + return "STEP_SEND_INPUT_EVENT_UI"; + + case ::perfetto::protos::pbzero::ChromeLatencyInfo_Step::STEP_HANDLE_INPUT_EVENT_IMPL: + return "STEP_HANDLE_INPUT_EVENT_IMPL"; + + case ::perfetto::protos::pbzero::ChromeLatencyInfo_Step::STEP_DID_HANDLE_INPUT_AND_OVERSCROLL: + return "STEP_DID_HANDLE_INPUT_AND_OVERSCROLL"; + + case ::perfetto::protos::pbzero::ChromeLatencyInfo_Step::STEP_HANDLE_INPUT_EVENT_MAIN: + return "STEP_HANDLE_INPUT_EVENT_MAIN"; + + case ::perfetto::protos::pbzero::ChromeLatencyInfo_Step::STEP_MAIN_THREAD_SCROLL_UPDATE: + return "STEP_MAIN_THREAD_SCROLL_UPDATE"; + + case ::perfetto::protos::pbzero::ChromeLatencyInfo_Step::STEP_HANDLE_INPUT_EVENT_MAIN_COMMIT: + return "STEP_HANDLE_INPUT_EVENT_MAIN_COMMIT"; + + case ::perfetto::protos::pbzero::ChromeLatencyInfo_Step::STEP_HANDLED_INPUT_EVENT_MAIN_OR_IMPL: + return "STEP_HANDLED_INPUT_EVENT_MAIN_OR_IMPL"; + + case ::perfetto::protos::pbzero::ChromeLatencyInfo_Step::STEP_HANDLED_INPUT_EVENT_IMPL: + return "STEP_HANDLED_INPUT_EVENT_IMPL"; + + case ::perfetto::protos::pbzero::ChromeLatencyInfo_Step::STEP_SWAP_BUFFERS: + return "STEP_SWAP_BUFFERS"; + + case ::perfetto::protos::pbzero::ChromeLatencyInfo_Step::STEP_DRAW_AND_SWAP: + return "STEP_DRAW_AND_SWAP"; + + case ::perfetto::protos::pbzero::ChromeLatencyInfo_Step::STEP_FINISHED_SWAP_BUFFERS: + return "STEP_FINISHED_SWAP_BUFFERS"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_ChromeLatencyInfo { +enum LatencyComponentType : int32_t { + COMPONENT_UNSPECIFIED = 0, + COMPONENT_INPUT_EVENT_LATENCY_BEGIN_RWH = 1, + COMPONENT_INPUT_EVENT_LATENCY_SCROLL_UPDATE_ORIGINAL = 2, + COMPONENT_INPUT_EVENT_LATENCY_FIRST_SCROLL_UPDATE_ORIGINAL = 3, + COMPONENT_INPUT_EVENT_LATENCY_ORIGINAL = 4, + COMPONENT_INPUT_EVENT_LATENCY_UI = 5, + COMPONENT_INPUT_EVENT_LATENCY_RENDERER_MAIN = 6, + COMPONENT_INPUT_EVENT_LATENCY_RENDERING_SCHEDULED_MAIN = 7, + COMPONENT_INPUT_EVENT_LATENCY_RENDERING_SCHEDULED_IMPL = 8, + COMPONENT_INPUT_EVENT_LATENCY_SCROLL_UPDATE_LAST_EVENT = 9, + COMPONENT_INPUT_EVENT_LATENCY_ACK_RWH = 10, + COMPONENT_INPUT_EVENT_LATENCY_RENDERER_SWAP = 11, + COMPONENT_DISPLAY_COMPOSITOR_RECEIVED_FRAME = 12, + COMPONENT_INPUT_EVENT_GPU_SWAP_BUFFER = 13, + COMPONENT_INPUT_EVENT_LATENCY_FRAME_SWAP = 14, +}; +} // namespace perfetto_pbzero_enum_ChromeLatencyInfo +using ChromeLatencyInfo_LatencyComponentType = perfetto_pbzero_enum_ChromeLatencyInfo::LatencyComponentType; + + +constexpr ChromeLatencyInfo_LatencyComponentType ChromeLatencyInfo_LatencyComponentType_MIN = ChromeLatencyInfo_LatencyComponentType::COMPONENT_UNSPECIFIED; +constexpr ChromeLatencyInfo_LatencyComponentType ChromeLatencyInfo_LatencyComponentType_MAX = ChromeLatencyInfo_LatencyComponentType::COMPONENT_INPUT_EVENT_LATENCY_FRAME_SWAP; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* ChromeLatencyInfo_LatencyComponentType_Name(::perfetto::protos::pbzero::ChromeLatencyInfo_LatencyComponentType value) { + switch (value) { + case ::perfetto::protos::pbzero::ChromeLatencyInfo_LatencyComponentType::COMPONENT_UNSPECIFIED: + return "COMPONENT_UNSPECIFIED"; + + case ::perfetto::protos::pbzero::ChromeLatencyInfo_LatencyComponentType::COMPONENT_INPUT_EVENT_LATENCY_BEGIN_RWH: + return "COMPONENT_INPUT_EVENT_LATENCY_BEGIN_RWH"; + + case ::perfetto::protos::pbzero::ChromeLatencyInfo_LatencyComponentType::COMPONENT_INPUT_EVENT_LATENCY_SCROLL_UPDATE_ORIGINAL: + return "COMPONENT_INPUT_EVENT_LATENCY_SCROLL_UPDATE_ORIGINAL"; + + case ::perfetto::protos::pbzero::ChromeLatencyInfo_LatencyComponentType::COMPONENT_INPUT_EVENT_LATENCY_FIRST_SCROLL_UPDATE_ORIGINAL: + return "COMPONENT_INPUT_EVENT_LATENCY_FIRST_SCROLL_UPDATE_ORIGINAL"; + + case ::perfetto::protos::pbzero::ChromeLatencyInfo_LatencyComponentType::COMPONENT_INPUT_EVENT_LATENCY_ORIGINAL: + return "COMPONENT_INPUT_EVENT_LATENCY_ORIGINAL"; + + case ::perfetto::protos::pbzero::ChromeLatencyInfo_LatencyComponentType::COMPONENT_INPUT_EVENT_LATENCY_UI: + return "COMPONENT_INPUT_EVENT_LATENCY_UI"; + + case ::perfetto::protos::pbzero::ChromeLatencyInfo_LatencyComponentType::COMPONENT_INPUT_EVENT_LATENCY_RENDERER_MAIN: + return "COMPONENT_INPUT_EVENT_LATENCY_RENDERER_MAIN"; + + case ::perfetto::protos::pbzero::ChromeLatencyInfo_LatencyComponentType::COMPONENT_INPUT_EVENT_LATENCY_RENDERING_SCHEDULED_MAIN: + return "COMPONENT_INPUT_EVENT_LATENCY_RENDERING_SCHEDULED_MAIN"; + + case ::perfetto::protos::pbzero::ChromeLatencyInfo_LatencyComponentType::COMPONENT_INPUT_EVENT_LATENCY_RENDERING_SCHEDULED_IMPL: + return "COMPONENT_INPUT_EVENT_LATENCY_RENDERING_SCHEDULED_IMPL"; + + case ::perfetto::protos::pbzero::ChromeLatencyInfo_LatencyComponentType::COMPONENT_INPUT_EVENT_LATENCY_SCROLL_UPDATE_LAST_EVENT: + return "COMPONENT_INPUT_EVENT_LATENCY_SCROLL_UPDATE_LAST_EVENT"; + + case ::perfetto::protos::pbzero::ChromeLatencyInfo_LatencyComponentType::COMPONENT_INPUT_EVENT_LATENCY_ACK_RWH: + return "COMPONENT_INPUT_EVENT_LATENCY_ACK_RWH"; + + case ::perfetto::protos::pbzero::ChromeLatencyInfo_LatencyComponentType::COMPONENT_INPUT_EVENT_LATENCY_RENDERER_SWAP: + return "COMPONENT_INPUT_EVENT_LATENCY_RENDERER_SWAP"; + + case ::perfetto::protos::pbzero::ChromeLatencyInfo_LatencyComponentType::COMPONENT_DISPLAY_COMPOSITOR_RECEIVED_FRAME: + return "COMPONENT_DISPLAY_COMPOSITOR_RECEIVED_FRAME"; + + case ::perfetto::protos::pbzero::ChromeLatencyInfo_LatencyComponentType::COMPONENT_INPUT_EVENT_GPU_SWAP_BUFFER: + return "COMPONENT_INPUT_EVENT_GPU_SWAP_BUFFER"; + + case ::perfetto::protos::pbzero::ChromeLatencyInfo_LatencyComponentType::COMPONENT_INPUT_EVENT_LATENCY_FRAME_SWAP: + return "COMPONENT_INPUT_EVENT_LATENCY_FRAME_SWAP"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_ChromeFrameReporter { +enum State : int32_t { + STATE_NO_UPDATE_DESIRED = 0, + STATE_PRESENTED_ALL = 1, + STATE_PRESENTED_PARTIAL = 2, + STATE_DROPPED = 3, +}; +} // namespace perfetto_pbzero_enum_ChromeFrameReporter +using ChromeFrameReporter_State = perfetto_pbzero_enum_ChromeFrameReporter::State; + + +constexpr ChromeFrameReporter_State ChromeFrameReporter_State_MIN = ChromeFrameReporter_State::STATE_NO_UPDATE_DESIRED; +constexpr ChromeFrameReporter_State ChromeFrameReporter_State_MAX = ChromeFrameReporter_State::STATE_DROPPED; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* ChromeFrameReporter_State_Name(::perfetto::protos::pbzero::ChromeFrameReporter_State value) { + switch (value) { + case ::perfetto::protos::pbzero::ChromeFrameReporter_State::STATE_NO_UPDATE_DESIRED: + return "STATE_NO_UPDATE_DESIRED"; + + case ::perfetto::protos::pbzero::ChromeFrameReporter_State::STATE_PRESENTED_ALL: + return "STATE_PRESENTED_ALL"; + + case ::perfetto::protos::pbzero::ChromeFrameReporter_State::STATE_PRESENTED_PARTIAL: + return "STATE_PRESENTED_PARTIAL"; + + case ::perfetto::protos::pbzero::ChromeFrameReporter_State::STATE_DROPPED: + return "STATE_DROPPED"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_ChromeFrameReporter { +enum FrameDropReason : int32_t { + REASON_UNSPECIFIED = 0, + REASON_DISPLAY_COMPOSITOR = 1, + REASON_MAIN_THREAD = 2, + REASON_CLIENT_COMPOSITOR = 3, +}; +} // namespace perfetto_pbzero_enum_ChromeFrameReporter +using ChromeFrameReporter_FrameDropReason = perfetto_pbzero_enum_ChromeFrameReporter::FrameDropReason; + + +constexpr ChromeFrameReporter_FrameDropReason ChromeFrameReporter_FrameDropReason_MIN = ChromeFrameReporter_FrameDropReason::REASON_UNSPECIFIED; +constexpr ChromeFrameReporter_FrameDropReason ChromeFrameReporter_FrameDropReason_MAX = ChromeFrameReporter_FrameDropReason::REASON_CLIENT_COMPOSITOR; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* ChromeFrameReporter_FrameDropReason_Name(::perfetto::protos::pbzero::ChromeFrameReporter_FrameDropReason value) { + switch (value) { + case ::perfetto::protos::pbzero::ChromeFrameReporter_FrameDropReason::REASON_UNSPECIFIED: + return "REASON_UNSPECIFIED"; + + case ::perfetto::protos::pbzero::ChromeFrameReporter_FrameDropReason::REASON_DISPLAY_COMPOSITOR: + return "REASON_DISPLAY_COMPOSITOR"; + + case ::perfetto::protos::pbzero::ChromeFrameReporter_FrameDropReason::REASON_MAIN_THREAD: + return "REASON_MAIN_THREAD"; + + case ::perfetto::protos::pbzero::ChromeFrameReporter_FrameDropReason::REASON_CLIENT_COMPOSITOR: + return "REASON_CLIENT_COMPOSITOR"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_ChromeFrameReporter { +enum ScrollState : int32_t { + SCROLL_NONE = 0, + SCROLL_MAIN_THREAD = 1, + SCROLL_COMPOSITOR_THREAD = 2, + SCROLL_UNKNOWN = 3, +}; +} // namespace perfetto_pbzero_enum_ChromeFrameReporter +using ChromeFrameReporter_ScrollState = perfetto_pbzero_enum_ChromeFrameReporter::ScrollState; + + +constexpr ChromeFrameReporter_ScrollState ChromeFrameReporter_ScrollState_MIN = ChromeFrameReporter_ScrollState::SCROLL_NONE; +constexpr ChromeFrameReporter_ScrollState ChromeFrameReporter_ScrollState_MAX = ChromeFrameReporter_ScrollState::SCROLL_UNKNOWN; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* ChromeFrameReporter_ScrollState_Name(::perfetto::protos::pbzero::ChromeFrameReporter_ScrollState value) { + switch (value) { + case ::perfetto::protos::pbzero::ChromeFrameReporter_ScrollState::SCROLL_NONE: + return "SCROLL_NONE"; + + case ::perfetto::protos::pbzero::ChromeFrameReporter_ScrollState::SCROLL_MAIN_THREAD: + return "SCROLL_MAIN_THREAD"; + + case ::perfetto::protos::pbzero::ChromeFrameReporter_ScrollState::SCROLL_COMPOSITOR_THREAD: + return "SCROLL_COMPOSITOR_THREAD"; + + case ::perfetto::protos::pbzero::ChromeFrameReporter_ScrollState::SCROLL_UNKNOWN: + return "SCROLL_UNKNOWN"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_ChromeFrameReporter { +enum FrameType : int32_t { + FORKED = 0, + BACKFILL = 1, +}; +} // namespace perfetto_pbzero_enum_ChromeFrameReporter +using ChromeFrameReporter_FrameType = perfetto_pbzero_enum_ChromeFrameReporter::FrameType; + + +constexpr ChromeFrameReporter_FrameType ChromeFrameReporter_FrameType_MIN = ChromeFrameReporter_FrameType::FORKED; +constexpr ChromeFrameReporter_FrameType ChromeFrameReporter_FrameType_MAX = ChromeFrameReporter_FrameType::BACKFILL; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* ChromeFrameReporter_FrameType_Name(::perfetto::protos::pbzero::ChromeFrameReporter_FrameType value) { + switch (value) { + case ::perfetto::protos::pbzero::ChromeFrameReporter_FrameType::FORKED: + return "FORKED"; + + case ::perfetto::protos::pbzero::ChromeFrameReporter_FrameType::BACKFILL: + return "BACKFILL"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_BeginImplFrameArgs { +enum State : int32_t { + BEGIN_FRAME_FINISHED = 0, + BEGIN_FRAME_USING = 1, +}; +} // namespace perfetto_pbzero_enum_BeginImplFrameArgs +using BeginImplFrameArgs_State = perfetto_pbzero_enum_BeginImplFrameArgs::State; + + +constexpr BeginImplFrameArgs_State BeginImplFrameArgs_State_MIN = BeginImplFrameArgs_State::BEGIN_FRAME_FINISHED; +constexpr BeginImplFrameArgs_State BeginImplFrameArgs_State_MAX = BeginImplFrameArgs_State::BEGIN_FRAME_USING; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* BeginImplFrameArgs_State_Name(::perfetto::protos::pbzero::BeginImplFrameArgs_State value) { + switch (value) { + case ::perfetto::protos::pbzero::BeginImplFrameArgs_State::BEGIN_FRAME_FINISHED: + return "BEGIN_FRAME_FINISHED"; + + case ::perfetto::protos::pbzero::BeginImplFrameArgs_State::BEGIN_FRAME_USING: + return "BEGIN_FRAME_USING"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_BeginFrameArgs { +enum BeginFrameArgsType : int32_t { + BEGIN_FRAME_ARGS_TYPE_UNSPECIFIED = 0, + BEGIN_FRAME_ARGS_TYPE_INVALID = 1, + BEGIN_FRAME_ARGS_TYPE_NORMAL = 2, + BEGIN_FRAME_ARGS_TYPE_MISSED = 3, +}; +} // namespace perfetto_pbzero_enum_BeginFrameArgs +using BeginFrameArgs_BeginFrameArgsType = perfetto_pbzero_enum_BeginFrameArgs::BeginFrameArgsType; + + +constexpr BeginFrameArgs_BeginFrameArgsType BeginFrameArgs_BeginFrameArgsType_MIN = BeginFrameArgs_BeginFrameArgsType::BEGIN_FRAME_ARGS_TYPE_UNSPECIFIED; +constexpr BeginFrameArgs_BeginFrameArgsType BeginFrameArgs_BeginFrameArgsType_MAX = BeginFrameArgs_BeginFrameArgsType::BEGIN_FRAME_ARGS_TYPE_MISSED; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* BeginFrameArgs_BeginFrameArgsType_Name(::perfetto::protos::pbzero::BeginFrameArgs_BeginFrameArgsType value) { + switch (value) { + case ::perfetto::protos::pbzero::BeginFrameArgs_BeginFrameArgsType::BEGIN_FRAME_ARGS_TYPE_UNSPECIFIED: + return "BEGIN_FRAME_ARGS_TYPE_UNSPECIFIED"; + + case ::perfetto::protos::pbzero::BeginFrameArgs_BeginFrameArgsType::BEGIN_FRAME_ARGS_TYPE_INVALID: + return "BEGIN_FRAME_ARGS_TYPE_INVALID"; + + case ::perfetto::protos::pbzero::BeginFrameArgs_BeginFrameArgsType::BEGIN_FRAME_ARGS_TYPE_NORMAL: + return "BEGIN_FRAME_ARGS_TYPE_NORMAL"; + + case ::perfetto::protos::pbzero::BeginFrameArgs_BeginFrameArgsType::BEGIN_FRAME_ARGS_TYPE_MISSED: + return "BEGIN_FRAME_ARGS_TYPE_MISSED"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_ChromeCompositorStateMachine_MinorState { +enum TreePriority : int32_t { + TREE_PRIORITY_UNSPECIFIED = 0, + TREE_PRIORITY_SAME_PRIORITY_FOR_BOTH_TREES = 1, + TREE_PRIORITY_SMOOTHNESS_TAKES_PRIORITY = 2, + TREE_PRIORITY_NEW_CONTENT_TAKES_PRIORITY = 3, +}; +} // namespace perfetto_pbzero_enum_ChromeCompositorStateMachine_MinorState +using ChromeCompositorStateMachine_MinorState_TreePriority = perfetto_pbzero_enum_ChromeCompositorStateMachine_MinorState::TreePriority; + + +constexpr ChromeCompositorStateMachine_MinorState_TreePriority ChromeCompositorStateMachine_MinorState_TreePriority_MIN = ChromeCompositorStateMachine_MinorState_TreePriority::TREE_PRIORITY_UNSPECIFIED; +constexpr ChromeCompositorStateMachine_MinorState_TreePriority ChromeCompositorStateMachine_MinorState_TreePriority_MAX = ChromeCompositorStateMachine_MinorState_TreePriority::TREE_PRIORITY_NEW_CONTENT_TAKES_PRIORITY; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* ChromeCompositorStateMachine_MinorState_TreePriority_Name(::perfetto::protos::pbzero::ChromeCompositorStateMachine_MinorState_TreePriority value) { + switch (value) { + case ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MinorState_TreePriority::TREE_PRIORITY_UNSPECIFIED: + return "TREE_PRIORITY_UNSPECIFIED"; + + case ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MinorState_TreePriority::TREE_PRIORITY_SAME_PRIORITY_FOR_BOTH_TREES: + return "TREE_PRIORITY_SAME_PRIORITY_FOR_BOTH_TREES"; + + case ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MinorState_TreePriority::TREE_PRIORITY_SMOOTHNESS_TAKES_PRIORITY: + return "TREE_PRIORITY_SMOOTHNESS_TAKES_PRIORITY"; + + case ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MinorState_TreePriority::TREE_PRIORITY_NEW_CONTENT_TAKES_PRIORITY: + return "TREE_PRIORITY_NEW_CONTENT_TAKES_PRIORITY"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_ChromeCompositorStateMachine_MinorState { +enum ScrollHandlerState : int32_t { + SCROLL_HANDLER_UNSPECIFIED = 0, + SCROLL_AFFECTS_SCROLL_HANDLER = 1, + SCROLL_DOES_NOT_AFFECT_SCROLL_HANDLER = 2, +}; +} // namespace perfetto_pbzero_enum_ChromeCompositorStateMachine_MinorState +using ChromeCompositorStateMachine_MinorState_ScrollHandlerState = perfetto_pbzero_enum_ChromeCompositorStateMachine_MinorState::ScrollHandlerState; + + +constexpr ChromeCompositorStateMachine_MinorState_ScrollHandlerState ChromeCompositorStateMachine_MinorState_ScrollHandlerState_MIN = ChromeCompositorStateMachine_MinorState_ScrollHandlerState::SCROLL_HANDLER_UNSPECIFIED; +constexpr ChromeCompositorStateMachine_MinorState_ScrollHandlerState ChromeCompositorStateMachine_MinorState_ScrollHandlerState_MAX = ChromeCompositorStateMachine_MinorState_ScrollHandlerState::SCROLL_DOES_NOT_AFFECT_SCROLL_HANDLER; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* ChromeCompositorStateMachine_MinorState_ScrollHandlerState_Name(::perfetto::protos::pbzero::ChromeCompositorStateMachine_MinorState_ScrollHandlerState value) { + switch (value) { + case ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MinorState_ScrollHandlerState::SCROLL_HANDLER_UNSPECIFIED: + return "SCROLL_HANDLER_UNSPECIFIED"; + + case ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MinorState_ScrollHandlerState::SCROLL_AFFECTS_SCROLL_HANDLER: + return "SCROLL_AFFECTS_SCROLL_HANDLER"; + + case ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MinorState_ScrollHandlerState::SCROLL_DOES_NOT_AFFECT_SCROLL_HANDLER: + return "SCROLL_DOES_NOT_AFFECT_SCROLL_HANDLER"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_ChromeCompositorStateMachine_MajorState { +enum BeginImplFrameState : int32_t { + BEGIN_IMPL_FRAME_UNSPECIFIED = 0, + BEGIN_IMPL_FRAME_IDLE = 1, + BEGIN_IMPL_FRAME_INSIDE_BEGIN_FRAME = 2, + BEGIN_IMPL_FRAME_INSIDE_DEADLINE = 3, +}; +} // namespace perfetto_pbzero_enum_ChromeCompositorStateMachine_MajorState +using ChromeCompositorStateMachine_MajorState_BeginImplFrameState = perfetto_pbzero_enum_ChromeCompositorStateMachine_MajorState::BeginImplFrameState; + + +constexpr ChromeCompositorStateMachine_MajorState_BeginImplFrameState ChromeCompositorStateMachine_MajorState_BeginImplFrameState_MIN = ChromeCompositorStateMachine_MajorState_BeginImplFrameState::BEGIN_IMPL_FRAME_UNSPECIFIED; +constexpr ChromeCompositorStateMachine_MajorState_BeginImplFrameState ChromeCompositorStateMachine_MajorState_BeginImplFrameState_MAX = ChromeCompositorStateMachine_MajorState_BeginImplFrameState::BEGIN_IMPL_FRAME_INSIDE_DEADLINE; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* ChromeCompositorStateMachine_MajorState_BeginImplFrameState_Name(::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_BeginImplFrameState value) { + switch (value) { + case ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_BeginImplFrameState::BEGIN_IMPL_FRAME_UNSPECIFIED: + return "BEGIN_IMPL_FRAME_UNSPECIFIED"; + + case ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_BeginImplFrameState::BEGIN_IMPL_FRAME_IDLE: + return "BEGIN_IMPL_FRAME_IDLE"; + + case ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_BeginImplFrameState::BEGIN_IMPL_FRAME_INSIDE_BEGIN_FRAME: + return "BEGIN_IMPL_FRAME_INSIDE_BEGIN_FRAME"; + + case ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_BeginImplFrameState::BEGIN_IMPL_FRAME_INSIDE_DEADLINE: + return "BEGIN_IMPL_FRAME_INSIDE_DEADLINE"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_ChromeCompositorStateMachine_MajorState { +enum BeginMainFrameState : int32_t { + BEGIN_MAIN_FRAME_UNSPECIFIED = 0, + BEGIN_MAIN_FRAME_IDLE = 1, + BEGIN_MAIN_FRAME_SENT = 2, + BEGIN_MAIN_FRAME_READY_TO_COMMIT = 3, +}; +} // namespace perfetto_pbzero_enum_ChromeCompositorStateMachine_MajorState +using ChromeCompositorStateMachine_MajorState_BeginMainFrameState = perfetto_pbzero_enum_ChromeCompositorStateMachine_MajorState::BeginMainFrameState; + + +constexpr ChromeCompositorStateMachine_MajorState_BeginMainFrameState ChromeCompositorStateMachine_MajorState_BeginMainFrameState_MIN = ChromeCompositorStateMachine_MajorState_BeginMainFrameState::BEGIN_MAIN_FRAME_UNSPECIFIED; +constexpr ChromeCompositorStateMachine_MajorState_BeginMainFrameState ChromeCompositorStateMachine_MajorState_BeginMainFrameState_MAX = ChromeCompositorStateMachine_MajorState_BeginMainFrameState::BEGIN_MAIN_FRAME_READY_TO_COMMIT; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* ChromeCompositorStateMachine_MajorState_BeginMainFrameState_Name(::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_BeginMainFrameState value) { + switch (value) { + case ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_BeginMainFrameState::BEGIN_MAIN_FRAME_UNSPECIFIED: + return "BEGIN_MAIN_FRAME_UNSPECIFIED"; + + case ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_BeginMainFrameState::BEGIN_MAIN_FRAME_IDLE: + return "BEGIN_MAIN_FRAME_IDLE"; + + case ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_BeginMainFrameState::BEGIN_MAIN_FRAME_SENT: + return "BEGIN_MAIN_FRAME_SENT"; + + case ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_BeginMainFrameState::BEGIN_MAIN_FRAME_READY_TO_COMMIT: + return "BEGIN_MAIN_FRAME_READY_TO_COMMIT"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_ChromeCompositorStateMachine_MajorState { +enum LayerTreeFrameSinkState : int32_t { + LAYER_TREE_FRAME_UNSPECIFIED = 0, + LAYER_TREE_FRAME_NONE = 1, + LAYER_TREE_FRAME_ACTIVE = 2, + LAYER_TREE_FRAME_CREATING = 3, + LAYER_TREE_FRAME_WAITING_FOR_FIRST_COMMIT = 4, + LAYER_TREE_FRAME_WAITING_FOR_FIRST_ACTIVATION = 5, +}; +} // namespace perfetto_pbzero_enum_ChromeCompositorStateMachine_MajorState +using ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState = perfetto_pbzero_enum_ChromeCompositorStateMachine_MajorState::LayerTreeFrameSinkState; + + +constexpr ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_MIN = ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState::LAYER_TREE_FRAME_UNSPECIFIED; +constexpr ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_MAX = ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState::LAYER_TREE_FRAME_WAITING_FOR_FIRST_ACTIVATION; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_Name(::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState value) { + switch (value) { + case ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState::LAYER_TREE_FRAME_UNSPECIFIED: + return "LAYER_TREE_FRAME_UNSPECIFIED"; + + case ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState::LAYER_TREE_FRAME_NONE: + return "LAYER_TREE_FRAME_NONE"; + + case ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState::LAYER_TREE_FRAME_ACTIVE: + return "LAYER_TREE_FRAME_ACTIVE"; + + case ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState::LAYER_TREE_FRAME_CREATING: + return "LAYER_TREE_FRAME_CREATING"; + + case ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState::LAYER_TREE_FRAME_WAITING_FOR_FIRST_COMMIT: + return "LAYER_TREE_FRAME_WAITING_FOR_FIRST_COMMIT"; + + case ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState::LAYER_TREE_FRAME_WAITING_FOR_FIRST_ACTIVATION: + return "LAYER_TREE_FRAME_WAITING_FOR_FIRST_ACTIVATION"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_ChromeCompositorStateMachine_MajorState { +enum ForcedRedrawOnTimeoutState : int32_t { + FORCED_REDRAW_UNSPECIFIED = 0, + FORCED_REDRAW_IDLE = 1, + FORCED_REDRAW_WAITING_FOR_COMMIT = 2, + FORCED_REDRAW_WAITING_FOR_ACTIVATION = 3, + FORCED_REDRAW_WAITING_FOR_DRAW = 4, +}; +} // namespace perfetto_pbzero_enum_ChromeCompositorStateMachine_MajorState +using ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState = perfetto_pbzero_enum_ChromeCompositorStateMachine_MajorState::ForcedRedrawOnTimeoutState; + + +constexpr ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState_MIN = ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState::FORCED_REDRAW_UNSPECIFIED; +constexpr ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState_MAX = ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState::FORCED_REDRAW_WAITING_FOR_DRAW; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState_Name(::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState value) { + switch (value) { + case ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState::FORCED_REDRAW_UNSPECIFIED: + return "FORCED_REDRAW_UNSPECIFIED"; + + case ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState::FORCED_REDRAW_IDLE: + return "FORCED_REDRAW_IDLE"; + + case ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState::FORCED_REDRAW_WAITING_FOR_COMMIT: + return "FORCED_REDRAW_WAITING_FOR_COMMIT"; + + case ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState::FORCED_REDRAW_WAITING_FOR_ACTIVATION: + return "FORCED_REDRAW_WAITING_FOR_ACTIVATION"; + + case ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState::FORCED_REDRAW_WAITING_FOR_DRAW: + return "FORCED_REDRAW_WAITING_FOR_DRAW"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_ChromeCompositorSchedulerState { +enum BeginImplFrameDeadlineMode : int32_t { + DEADLINE_MODE_UNSPECIFIED = 0, + DEADLINE_MODE_NONE = 1, + DEADLINE_MODE_IMMEDIATE = 2, + DEADLINE_MODE_REGULAR = 3, + DEADLINE_MODE_LATE = 4, + DEADLINE_MODE_BLOCKED = 5, +}; +} // namespace perfetto_pbzero_enum_ChromeCompositorSchedulerState +using ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode = perfetto_pbzero_enum_ChromeCompositorSchedulerState::BeginImplFrameDeadlineMode; + + +constexpr ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_MIN = ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode::DEADLINE_MODE_UNSPECIFIED; +constexpr ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_MAX = ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode::DEADLINE_MODE_BLOCKED; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_Name(::perfetto::protos::pbzero::ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode value) { + switch (value) { + case ::perfetto::protos::pbzero::ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode::DEADLINE_MODE_UNSPECIFIED: + return "DEADLINE_MODE_UNSPECIFIED"; + + case ::perfetto::protos::pbzero::ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode::DEADLINE_MODE_NONE: + return "DEADLINE_MODE_NONE"; + + case ::perfetto::protos::pbzero::ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode::DEADLINE_MODE_IMMEDIATE: + return "DEADLINE_MODE_IMMEDIATE"; + + case ::perfetto::protos::pbzero::ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode::DEADLINE_MODE_REGULAR: + return "DEADLINE_MODE_REGULAR"; + + case ::perfetto::protos::pbzero::ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode::DEADLINE_MODE_LATE: + return "DEADLINE_MODE_LATE"; + + case ::perfetto::protos::pbzero::ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode::DEADLINE_MODE_BLOCKED: + return "DEADLINE_MODE_BLOCKED"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_ChromeApplicationStateInfo { +enum ChromeApplicationState : int32_t { + APPLICATION_STATE_UNKNOWN = 0, + APPLICATION_STATE_HAS_RUNNING_ACTIVITIES = 1, + APPLICATION_STATE_HAS_PAUSED_ACTIVITIES = 2, + APPLICATION_STATE_HAS_STOPPED_ACTIVITIES = 3, + APPLICATION_STATE_HAS_DESTROYED_ACTIVITIES = 4, +}; +} // namespace perfetto_pbzero_enum_ChromeApplicationStateInfo +using ChromeApplicationStateInfo_ChromeApplicationState = perfetto_pbzero_enum_ChromeApplicationStateInfo::ChromeApplicationState; + + +constexpr ChromeApplicationStateInfo_ChromeApplicationState ChromeApplicationStateInfo_ChromeApplicationState_MIN = ChromeApplicationStateInfo_ChromeApplicationState::APPLICATION_STATE_UNKNOWN; +constexpr ChromeApplicationStateInfo_ChromeApplicationState ChromeApplicationStateInfo_ChromeApplicationState_MAX = ChromeApplicationStateInfo_ChromeApplicationState::APPLICATION_STATE_HAS_DESTROYED_ACTIVITIES; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* ChromeApplicationStateInfo_ChromeApplicationState_Name(::perfetto::protos::pbzero::ChromeApplicationStateInfo_ChromeApplicationState value) { + switch (value) { + case ::perfetto::protos::pbzero::ChromeApplicationStateInfo_ChromeApplicationState::APPLICATION_STATE_UNKNOWN: + return "APPLICATION_STATE_UNKNOWN"; + + case ::perfetto::protos::pbzero::ChromeApplicationStateInfo_ChromeApplicationState::APPLICATION_STATE_HAS_RUNNING_ACTIVITIES: + return "APPLICATION_STATE_HAS_RUNNING_ACTIVITIES"; + + case ::perfetto::protos::pbzero::ChromeApplicationStateInfo_ChromeApplicationState::APPLICATION_STATE_HAS_PAUSED_ACTIVITIES: + return "APPLICATION_STATE_HAS_PAUSED_ACTIVITIES"; + + case ::perfetto::protos::pbzero::ChromeApplicationStateInfo_ChromeApplicationState::APPLICATION_STATE_HAS_STOPPED_ACTIVITIES: + return "APPLICATION_STATE_HAS_STOPPED_ACTIVITIES"; + + case ::perfetto::protos::pbzero::ChromeApplicationStateInfo_ChromeApplicationState::APPLICATION_STATE_HAS_DESTROYED_ACTIVITIES: + return "APPLICATION_STATE_HAS_DESTROYED_ACTIVITIES"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_LogMessage { +enum Priority : int32_t { + PRIO_UNSPECIFIED = 0, + PRIO_UNUSED = 1, + PRIO_VERBOSE = 2, + PRIO_DEBUG = 3, + PRIO_INFO = 4, + PRIO_WARN = 5, + PRIO_ERROR = 6, + PRIO_FATAL = 7, +}; +} // namespace perfetto_pbzero_enum_LogMessage +using LogMessage_Priority = perfetto_pbzero_enum_LogMessage::Priority; + + +constexpr LogMessage_Priority LogMessage_Priority_MIN = LogMessage_Priority::PRIO_UNSPECIFIED; +constexpr LogMessage_Priority LogMessage_Priority_MAX = LogMessage_Priority::PRIO_FATAL; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* LogMessage_Priority_Name(::perfetto::protos::pbzero::LogMessage_Priority value) { + switch (value) { + case ::perfetto::protos::pbzero::LogMessage_Priority::PRIO_UNSPECIFIED: + return "PRIO_UNSPECIFIED"; + + case ::perfetto::protos::pbzero::LogMessage_Priority::PRIO_UNUSED: + return "PRIO_UNUSED"; + + case ::perfetto::protos::pbzero::LogMessage_Priority::PRIO_VERBOSE: + return "PRIO_VERBOSE"; + + case ::perfetto::protos::pbzero::LogMessage_Priority::PRIO_DEBUG: + return "PRIO_DEBUG"; + + case ::perfetto::protos::pbzero::LogMessage_Priority::PRIO_INFO: + return "PRIO_INFO"; + + case ::perfetto::protos::pbzero::LogMessage_Priority::PRIO_WARN: + return "PRIO_WARN"; + + case ::perfetto::protos::pbzero::LogMessage_Priority::PRIO_ERROR: + return "PRIO_ERROR"; + + case ::perfetto::protos::pbzero::LogMessage_Priority::PRIO_FATAL: + return "PRIO_FATAL"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_DebugAnnotation_NestedValue { +enum NestedType : int32_t { + UNSPECIFIED = 0, + DICT = 1, + ARRAY = 2, +}; +} // namespace perfetto_pbzero_enum_DebugAnnotation_NestedValue +using DebugAnnotation_NestedValue_NestedType = perfetto_pbzero_enum_DebugAnnotation_NestedValue::NestedType; + + +constexpr DebugAnnotation_NestedValue_NestedType DebugAnnotation_NestedValue_NestedType_MIN = DebugAnnotation_NestedValue_NestedType::UNSPECIFIED; +constexpr DebugAnnotation_NestedValue_NestedType DebugAnnotation_NestedValue_NestedType_MAX = DebugAnnotation_NestedValue_NestedType::ARRAY; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* DebugAnnotation_NestedValue_NestedType_Name(::perfetto::protos::pbzero::DebugAnnotation_NestedValue_NestedType value) { + switch (value) { + case ::perfetto::protos::pbzero::DebugAnnotation_NestedValue_NestedType::UNSPECIFIED: + return "UNSPECIFIED"; + + case ::perfetto::protos::pbzero::DebugAnnotation_NestedValue_NestedType::DICT: + return "DICT"; + + case ::perfetto::protos::pbzero::DebugAnnotation_NestedValue_NestedType::ARRAY: + return "ARRAY"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_VulkanMemoryEvent { +enum Source : int32_t { + SOURCE_UNSPECIFIED = 0, + SOURCE_DRIVER = 1, + SOURCE_DEVICE = 2, + SOURCE_DEVICE_MEMORY = 3, + SOURCE_BUFFER = 4, + SOURCE_IMAGE = 5, +}; +} // namespace perfetto_pbzero_enum_VulkanMemoryEvent +using VulkanMemoryEvent_Source = perfetto_pbzero_enum_VulkanMemoryEvent::Source; + + +constexpr VulkanMemoryEvent_Source VulkanMemoryEvent_Source_MIN = VulkanMemoryEvent_Source::SOURCE_UNSPECIFIED; +constexpr VulkanMemoryEvent_Source VulkanMemoryEvent_Source_MAX = VulkanMemoryEvent_Source::SOURCE_IMAGE; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* VulkanMemoryEvent_Source_Name(::perfetto::protos::pbzero::VulkanMemoryEvent_Source value) { + switch (value) { + case ::perfetto::protos::pbzero::VulkanMemoryEvent_Source::SOURCE_UNSPECIFIED: + return "SOURCE_UNSPECIFIED"; + + case ::perfetto::protos::pbzero::VulkanMemoryEvent_Source::SOURCE_DRIVER: + return "SOURCE_DRIVER"; + + case ::perfetto::protos::pbzero::VulkanMemoryEvent_Source::SOURCE_DEVICE: + return "SOURCE_DEVICE"; + + case ::perfetto::protos::pbzero::VulkanMemoryEvent_Source::SOURCE_DEVICE_MEMORY: + return "SOURCE_DEVICE_MEMORY"; + + case ::perfetto::protos::pbzero::VulkanMemoryEvent_Source::SOURCE_BUFFER: + return "SOURCE_BUFFER"; + + case ::perfetto::protos::pbzero::VulkanMemoryEvent_Source::SOURCE_IMAGE: + return "SOURCE_IMAGE"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_VulkanMemoryEvent { +enum Operation : int32_t { + OP_UNSPECIFIED = 0, + OP_CREATE = 1, + OP_DESTROY = 2, + OP_BIND = 3, + OP_DESTROY_BOUND = 4, + OP_ANNOTATIONS = 5, +}; +} // namespace perfetto_pbzero_enum_VulkanMemoryEvent +using VulkanMemoryEvent_Operation = perfetto_pbzero_enum_VulkanMemoryEvent::Operation; + + +constexpr VulkanMemoryEvent_Operation VulkanMemoryEvent_Operation_MIN = VulkanMemoryEvent_Operation::OP_UNSPECIFIED; +constexpr VulkanMemoryEvent_Operation VulkanMemoryEvent_Operation_MAX = VulkanMemoryEvent_Operation::OP_ANNOTATIONS; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* VulkanMemoryEvent_Operation_Name(::perfetto::protos::pbzero::VulkanMemoryEvent_Operation value) { + switch (value) { + case ::perfetto::protos::pbzero::VulkanMemoryEvent_Operation::OP_UNSPECIFIED: + return "OP_UNSPECIFIED"; + + case ::perfetto::protos::pbzero::VulkanMemoryEvent_Operation::OP_CREATE: + return "OP_CREATE"; + + case ::perfetto::protos::pbzero::VulkanMemoryEvent_Operation::OP_DESTROY: + return "OP_DESTROY"; + + case ::perfetto::protos::pbzero::VulkanMemoryEvent_Operation::OP_BIND: + return "OP_BIND"; + + case ::perfetto::protos::pbzero::VulkanMemoryEvent_Operation::OP_DESTROY_BOUND: + return "OP_DESTROY_BOUND"; + + case ::perfetto::protos::pbzero::VulkanMemoryEvent_Operation::OP_ANNOTATIONS: + return "OP_ANNOTATIONS"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_VulkanMemoryEvent { +enum AllocationScope : int32_t { + SCOPE_UNSPECIFIED = 0, + SCOPE_COMMAND = 1, + SCOPE_OBJECT = 2, + SCOPE_CACHE = 3, + SCOPE_DEVICE = 4, + SCOPE_INSTANCE = 5, +}; +} // namespace perfetto_pbzero_enum_VulkanMemoryEvent +using VulkanMemoryEvent_AllocationScope = perfetto_pbzero_enum_VulkanMemoryEvent::AllocationScope; + + +constexpr VulkanMemoryEvent_AllocationScope VulkanMemoryEvent_AllocationScope_MIN = VulkanMemoryEvent_AllocationScope::SCOPE_UNSPECIFIED; +constexpr VulkanMemoryEvent_AllocationScope VulkanMemoryEvent_AllocationScope_MAX = VulkanMemoryEvent_AllocationScope::SCOPE_INSTANCE; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* VulkanMemoryEvent_AllocationScope_Name(::perfetto::protos::pbzero::VulkanMemoryEvent_AllocationScope value) { + switch (value) { + case ::perfetto::protos::pbzero::VulkanMemoryEvent_AllocationScope::SCOPE_UNSPECIFIED: + return "SCOPE_UNSPECIFIED"; + + case ::perfetto::protos::pbzero::VulkanMemoryEvent_AllocationScope::SCOPE_COMMAND: + return "SCOPE_COMMAND"; + + case ::perfetto::protos::pbzero::VulkanMemoryEvent_AllocationScope::SCOPE_OBJECT: + return "SCOPE_OBJECT"; + + case ::perfetto::protos::pbzero::VulkanMemoryEvent_AllocationScope::SCOPE_CACHE: + return "SCOPE_CACHE"; + + case ::perfetto::protos::pbzero::VulkanMemoryEvent_AllocationScope::SCOPE_DEVICE: + return "SCOPE_DEVICE"; + + case ::perfetto::protos::pbzero::VulkanMemoryEvent_AllocationScope::SCOPE_INSTANCE: + return "SCOPE_INSTANCE"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_InternedGpuRenderStageSpecification { +enum RenderStageCategory : int32_t { + OTHER = 0, + GRAPHICS = 1, + COMPUTE = 2, +}; +} // namespace perfetto_pbzero_enum_InternedGpuRenderStageSpecification +using InternedGpuRenderStageSpecification_RenderStageCategory = perfetto_pbzero_enum_InternedGpuRenderStageSpecification::RenderStageCategory; + + +constexpr InternedGpuRenderStageSpecification_RenderStageCategory InternedGpuRenderStageSpecification_RenderStageCategory_MIN = InternedGpuRenderStageSpecification_RenderStageCategory::OTHER; +constexpr InternedGpuRenderStageSpecification_RenderStageCategory InternedGpuRenderStageSpecification_RenderStageCategory_MAX = InternedGpuRenderStageSpecification_RenderStageCategory::COMPUTE; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* InternedGpuRenderStageSpecification_RenderStageCategory_Name(::perfetto::protos::pbzero::InternedGpuRenderStageSpecification_RenderStageCategory value) { + switch (value) { + case ::perfetto::protos::pbzero::InternedGpuRenderStageSpecification_RenderStageCategory::OTHER: + return "OTHER"; + + case ::perfetto::protos::pbzero::InternedGpuRenderStageSpecification_RenderStageCategory::GRAPHICS: + return "GRAPHICS"; + + case ::perfetto::protos::pbzero::InternedGpuRenderStageSpecification_RenderStageCategory::COMPUTE: + return "COMPUTE"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_InternedGraphicsContext { +enum Api : int32_t { + UNDEFINED = 0, + OPEN_GL = 1, + VULKAN = 2, + OPEN_CL = 3, +}; +} // namespace perfetto_pbzero_enum_InternedGraphicsContext +using InternedGraphicsContext_Api = perfetto_pbzero_enum_InternedGraphicsContext::Api; + + +constexpr InternedGraphicsContext_Api InternedGraphicsContext_Api_MIN = InternedGraphicsContext_Api::UNDEFINED; +constexpr InternedGraphicsContext_Api InternedGraphicsContext_Api_MAX = InternedGraphicsContext_Api::OPEN_CL; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* InternedGraphicsContext_Api_Name(::perfetto::protos::pbzero::InternedGraphicsContext_Api value) { + switch (value) { + case ::perfetto::protos::pbzero::InternedGraphicsContext_Api::UNDEFINED: + return "UNDEFINED"; + + case ::perfetto::protos::pbzero::InternedGraphicsContext_Api::OPEN_GL: + return "OPEN_GL"; + + case ::perfetto::protos::pbzero::InternedGraphicsContext_Api::VULKAN: + return "VULKAN"; + + case ::perfetto::protos::pbzero::InternedGraphicsContext_Api::OPEN_CL: + return "OPEN_CL"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_GpuLog { +enum Severity : int32_t { + LOG_SEVERITY_UNSPECIFIED = 0, + LOG_SEVERITY_VERBOSE = 1, + LOG_SEVERITY_DEBUG = 2, + LOG_SEVERITY_INFO = 3, + LOG_SEVERITY_WARNING = 4, + LOG_SEVERITY_ERROR = 5, +}; +} // namespace perfetto_pbzero_enum_GpuLog +using GpuLog_Severity = perfetto_pbzero_enum_GpuLog::Severity; + + +constexpr GpuLog_Severity GpuLog_Severity_MIN = GpuLog_Severity::LOG_SEVERITY_UNSPECIFIED; +constexpr GpuLog_Severity GpuLog_Severity_MAX = GpuLog_Severity::LOG_SEVERITY_ERROR; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* GpuLog_Severity_Name(::perfetto::protos::pbzero::GpuLog_Severity value) { + switch (value) { + case ::perfetto::protos::pbzero::GpuLog_Severity::LOG_SEVERITY_UNSPECIFIED: + return "LOG_SEVERITY_UNSPECIFIED"; + + case ::perfetto::protos::pbzero::GpuLog_Severity::LOG_SEVERITY_VERBOSE: + return "LOG_SEVERITY_VERBOSE"; + + case ::perfetto::protos::pbzero::GpuLog_Severity::LOG_SEVERITY_DEBUG: + return "LOG_SEVERITY_DEBUG"; + + case ::perfetto::protos::pbzero::GpuLog_Severity::LOG_SEVERITY_INFO: + return "LOG_SEVERITY_INFO"; + + case ::perfetto::protos::pbzero::GpuLog_Severity::LOG_SEVERITY_WARNING: + return "LOG_SEVERITY_WARNING"; + + case ::perfetto::protos::pbzero::GpuLog_Severity::LOG_SEVERITY_ERROR: + return "LOG_SEVERITY_ERROR"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_FtraceStats { +enum Phase : int32_t { + UNSPECIFIED = 0, + START_OF_TRACE = 1, + END_OF_TRACE = 2, +}; +} // namespace perfetto_pbzero_enum_FtraceStats +using FtraceStats_Phase = perfetto_pbzero_enum_FtraceStats::Phase; + + +constexpr FtraceStats_Phase FtraceStats_Phase_MIN = FtraceStats_Phase::UNSPECIFIED; +constexpr FtraceStats_Phase FtraceStats_Phase_MAX = FtraceStats_Phase::END_OF_TRACE; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* FtraceStats_Phase_Name(::perfetto::protos::pbzero::FtraceStats_Phase value) { + switch (value) { + case ::perfetto::protos::pbzero::FtraceStats_Phase::UNSPECIFIED: + return "UNSPECIFIED"; + + case ::perfetto::protos::pbzero::FtraceStats_Phase::START_OF_TRACE: + return "START_OF_TRACE"; + + case ::perfetto::protos::pbzero::FtraceStats_Phase::END_OF_TRACE: + return "END_OF_TRACE"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_InodeFileMap_Entry { +enum Type : int32_t { + UNKNOWN = 0, + FILE = 1, + DIRECTORY = 2, +}; +} // namespace perfetto_pbzero_enum_InodeFileMap_Entry +using InodeFileMap_Entry_Type = perfetto_pbzero_enum_InodeFileMap_Entry::Type; + + +constexpr InodeFileMap_Entry_Type InodeFileMap_Entry_Type_MIN = InodeFileMap_Entry_Type::UNKNOWN; +constexpr InodeFileMap_Entry_Type InodeFileMap_Entry_Type_MAX = InodeFileMap_Entry_Type::DIRECTORY; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* InodeFileMap_Entry_Type_Name(::perfetto::protos::pbzero::InodeFileMap_Entry_Type value) { + switch (value) { + case ::perfetto::protos::pbzero::InodeFileMap_Entry_Type::UNKNOWN: + return "UNKNOWN"; + + case ::perfetto::protos::pbzero::InodeFileMap_Entry_Type::FILE: + return "FILE"; + + case ::perfetto::protos::pbzero::InodeFileMap_Entry_Type::DIRECTORY: + return "DIRECTORY"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_FieldDescriptorProto { +enum Type : int32_t { + TYPE_DOUBLE = 1, + TYPE_FLOAT = 2, + TYPE_INT64 = 3, + TYPE_UINT64 = 4, + TYPE_INT32 = 5, + TYPE_FIXED64 = 6, + TYPE_FIXED32 = 7, + TYPE_BOOL = 8, + TYPE_STRING = 9, + TYPE_GROUP = 10, + TYPE_MESSAGE = 11, + TYPE_BYTES = 12, + TYPE_UINT32 = 13, + TYPE_ENUM = 14, + TYPE_SFIXED32 = 15, + TYPE_SFIXED64 = 16, + TYPE_SINT32 = 17, + TYPE_SINT64 = 18, +}; +} // namespace perfetto_pbzero_enum_FieldDescriptorProto +using FieldDescriptorProto_Type = perfetto_pbzero_enum_FieldDescriptorProto::Type; + + +constexpr FieldDescriptorProto_Type FieldDescriptorProto_Type_MIN = FieldDescriptorProto_Type::TYPE_DOUBLE; +constexpr FieldDescriptorProto_Type FieldDescriptorProto_Type_MAX = FieldDescriptorProto_Type::TYPE_SINT64; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* FieldDescriptorProto_Type_Name(::perfetto::protos::pbzero::FieldDescriptorProto_Type value) { + switch (value) { + case ::perfetto::protos::pbzero::FieldDescriptorProto_Type::TYPE_DOUBLE: + return "TYPE_DOUBLE"; + + case ::perfetto::protos::pbzero::FieldDescriptorProto_Type::TYPE_FLOAT: + return "TYPE_FLOAT"; + + case ::perfetto::protos::pbzero::FieldDescriptorProto_Type::TYPE_INT64: + return "TYPE_INT64"; + + case ::perfetto::protos::pbzero::FieldDescriptorProto_Type::TYPE_UINT64: + return "TYPE_UINT64"; + + case ::perfetto::protos::pbzero::FieldDescriptorProto_Type::TYPE_INT32: + return "TYPE_INT32"; + + case ::perfetto::protos::pbzero::FieldDescriptorProto_Type::TYPE_FIXED64: + return "TYPE_FIXED64"; + + case ::perfetto::protos::pbzero::FieldDescriptorProto_Type::TYPE_FIXED32: + return "TYPE_FIXED32"; + + case ::perfetto::protos::pbzero::FieldDescriptorProto_Type::TYPE_BOOL: + return "TYPE_BOOL"; + + case ::perfetto::protos::pbzero::FieldDescriptorProto_Type::TYPE_STRING: + return "TYPE_STRING"; + + case ::perfetto::protos::pbzero::FieldDescriptorProto_Type::TYPE_GROUP: + return "TYPE_GROUP"; + + case ::perfetto::protos::pbzero::FieldDescriptorProto_Type::TYPE_MESSAGE: + return "TYPE_MESSAGE"; + + case ::perfetto::protos::pbzero::FieldDescriptorProto_Type::TYPE_BYTES: + return "TYPE_BYTES"; + + case ::perfetto::protos::pbzero::FieldDescriptorProto_Type::TYPE_UINT32: + return "TYPE_UINT32"; + + case ::perfetto::protos::pbzero::FieldDescriptorProto_Type::TYPE_ENUM: + return "TYPE_ENUM"; + + case ::perfetto::protos::pbzero::FieldDescriptorProto_Type::TYPE_SFIXED32: + return "TYPE_SFIXED32"; + + case ::perfetto::protos::pbzero::FieldDescriptorProto_Type::TYPE_SFIXED64: + return "TYPE_SFIXED64"; + + case ::perfetto::protos::pbzero::FieldDescriptorProto_Type::TYPE_SINT32: + return "TYPE_SINT32"; + + case ::perfetto::protos::pbzero::FieldDescriptorProto_Type::TYPE_SINT64: + return "TYPE_SINT64"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_FieldDescriptorProto { +enum Label : int32_t { + LABEL_OPTIONAL = 1, + LABEL_REQUIRED = 2, + LABEL_REPEATED = 3, +}; +} // namespace perfetto_pbzero_enum_FieldDescriptorProto +using FieldDescriptorProto_Label = perfetto_pbzero_enum_FieldDescriptorProto::Label; + + +constexpr FieldDescriptorProto_Label FieldDescriptorProto_Label_MIN = FieldDescriptorProto_Label::LABEL_OPTIONAL; +constexpr FieldDescriptorProto_Label FieldDescriptorProto_Label_MAX = FieldDescriptorProto_Label::LABEL_REPEATED; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* FieldDescriptorProto_Label_Name(::perfetto::protos::pbzero::FieldDescriptorProto_Label value) { + switch (value) { + case ::perfetto::protos::pbzero::FieldDescriptorProto_Label::LABEL_OPTIONAL: + return "LABEL_OPTIONAL"; + + case ::perfetto::protos::pbzero::FieldDescriptorProto_Label::LABEL_REQUIRED: + return "LABEL_REQUIRED"; + + case ::perfetto::protos::pbzero::FieldDescriptorProto_Label::LABEL_REPEATED: + return "LABEL_REPEATED"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_ReadyThreadEtwEvent { +enum AdjustReason : int32_t { + IGNORE_THE_INCREMENT = 0, + APPLY_INCREMENT = 1, + APPLY_INCREMENT_BOOST = 2, +}; +} // namespace perfetto_pbzero_enum_ReadyThreadEtwEvent +using ReadyThreadEtwEvent_AdjustReason = perfetto_pbzero_enum_ReadyThreadEtwEvent::AdjustReason; + + +constexpr ReadyThreadEtwEvent_AdjustReason ReadyThreadEtwEvent_AdjustReason_MIN = ReadyThreadEtwEvent_AdjustReason::IGNORE_THE_INCREMENT; +constexpr ReadyThreadEtwEvent_AdjustReason ReadyThreadEtwEvent_AdjustReason_MAX = ReadyThreadEtwEvent_AdjustReason::APPLY_INCREMENT_BOOST; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* ReadyThreadEtwEvent_AdjustReason_Name(::perfetto::protos::pbzero::ReadyThreadEtwEvent_AdjustReason value) { + switch (value) { + case ::perfetto::protos::pbzero::ReadyThreadEtwEvent_AdjustReason::IGNORE_THE_INCREMENT: + return "IGNORE_THE_INCREMENT"; + + case ::perfetto::protos::pbzero::ReadyThreadEtwEvent_AdjustReason::APPLY_INCREMENT: + return "APPLY_INCREMENT"; + + case ::perfetto::protos::pbzero::ReadyThreadEtwEvent_AdjustReason::APPLY_INCREMENT_BOOST: + return "APPLY_INCREMENT_BOOST"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_ReadyThreadEtwEvent { +enum TraceFlag : int32_t { + TRACE_FLAG_UNSPECIFIED = 0, + THREAD_READIED = 1, + KERNEL_STACK_SWAPPED_OUT = 2, + PROCESS_ADDRESS_SWAPPED_OUT = 4, +}; +} // namespace perfetto_pbzero_enum_ReadyThreadEtwEvent +using ReadyThreadEtwEvent_TraceFlag = perfetto_pbzero_enum_ReadyThreadEtwEvent::TraceFlag; + + +constexpr ReadyThreadEtwEvent_TraceFlag ReadyThreadEtwEvent_TraceFlag_MIN = ReadyThreadEtwEvent_TraceFlag::TRACE_FLAG_UNSPECIFIED; +constexpr ReadyThreadEtwEvent_TraceFlag ReadyThreadEtwEvent_TraceFlag_MAX = ReadyThreadEtwEvent_TraceFlag::PROCESS_ADDRESS_SWAPPED_OUT; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* ReadyThreadEtwEvent_TraceFlag_Name(::perfetto::protos::pbzero::ReadyThreadEtwEvent_TraceFlag value) { + switch (value) { + case ::perfetto::protos::pbzero::ReadyThreadEtwEvent_TraceFlag::TRACE_FLAG_UNSPECIFIED: + return "TRACE_FLAG_UNSPECIFIED"; + + case ::perfetto::protos::pbzero::ReadyThreadEtwEvent_TraceFlag::THREAD_READIED: + return "THREAD_READIED"; + + case ::perfetto::protos::pbzero::ReadyThreadEtwEvent_TraceFlag::KERNEL_STACK_SWAPPED_OUT: + return "KERNEL_STACK_SWAPPED_OUT"; + + case ::perfetto::protos::pbzero::ReadyThreadEtwEvent_TraceFlag::PROCESS_ADDRESS_SWAPPED_OUT: + return "PROCESS_ADDRESS_SWAPPED_OUT"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_CSwitchEtwEvent { +enum OldThreadWaitReason : int32_t { + EXECUTIVE = 0, + FREE_PAGE = 1, + PAGE_IN = 2, + POOL_ALLOCATION = 3, + DELAY_EXECUTION = 4, + SUSPEND = 5, + USER_REQUEST = 6, + WR_EXECUTIVE = 7, + WR_FREE_PAGE = 8, + WR_PAGE_IN = 9, + WR_POOL_ALLOCATION = 10, + WR_DELAY_EXECUTION = 11, + WR_SUSPENDED = 12, + WR_USER_REQUEST = 13, + WR_EVENT_PAIR = 14, + WR_QUEUE = 15, + WR_LPC_RECEIVER = 16, + WR_LPC_REPLY = 17, + WR_VIRTUAL_MEMORY = 18, + WR_PAGE_OUT = 19, + WR_RENDEZ_VOUS = 20, + WR_KEYED_EVENT = 21, + WR_TERMINATED = 22, + WR_PROCESS_IN_SWAP = 23, + WR_CPU_RATE_CONTROL = 24, + WR_CALLOUT_STACK = 25, + WR_KERNEL = 26, + WR_RESOURCE = 27, + WR_PUSH_LOCK = 28, + WR_MUTEX = 29, + WR_QUANTUM_END = 30, + WR_DISPATCH_INT = 31, + WR_PREEMPTED = 32, + WR_YIELD_EXECUTION = 33, + WR_FAST_MUTEX = 34, + WR_GUARD_MUTEX = 35, + WR_RUNDOWN = 36, + MAXIMUM_WAIT_REASON = 37, +}; +} // namespace perfetto_pbzero_enum_CSwitchEtwEvent +using CSwitchEtwEvent_OldThreadWaitReason = perfetto_pbzero_enum_CSwitchEtwEvent::OldThreadWaitReason; + + +constexpr CSwitchEtwEvent_OldThreadWaitReason CSwitchEtwEvent_OldThreadWaitReason_MIN = CSwitchEtwEvent_OldThreadWaitReason::EXECUTIVE; +constexpr CSwitchEtwEvent_OldThreadWaitReason CSwitchEtwEvent_OldThreadWaitReason_MAX = CSwitchEtwEvent_OldThreadWaitReason::MAXIMUM_WAIT_REASON; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* CSwitchEtwEvent_OldThreadWaitReason_Name(::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitReason value) { + switch (value) { + case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitReason::EXECUTIVE: + return "EXECUTIVE"; + + case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitReason::FREE_PAGE: + return "FREE_PAGE"; + + case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitReason::PAGE_IN: + return "PAGE_IN"; + + case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitReason::POOL_ALLOCATION: + return "POOL_ALLOCATION"; + + case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitReason::DELAY_EXECUTION: + return "DELAY_EXECUTION"; + + case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitReason::SUSPEND: + return "SUSPEND"; + + case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitReason::USER_REQUEST: + return "USER_REQUEST"; + + case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitReason::WR_EXECUTIVE: + return "WR_EXECUTIVE"; + + case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitReason::WR_FREE_PAGE: + return "WR_FREE_PAGE"; + + case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitReason::WR_PAGE_IN: + return "WR_PAGE_IN"; + + case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitReason::WR_POOL_ALLOCATION: + return "WR_POOL_ALLOCATION"; + + case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitReason::WR_DELAY_EXECUTION: + return "WR_DELAY_EXECUTION"; + + case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitReason::WR_SUSPENDED: + return "WR_SUSPENDED"; + + case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitReason::WR_USER_REQUEST: + return "WR_USER_REQUEST"; + + case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitReason::WR_EVENT_PAIR: + return "WR_EVENT_PAIR"; + + case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitReason::WR_QUEUE: + return "WR_QUEUE"; + + case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitReason::WR_LPC_RECEIVER: + return "WR_LPC_RECEIVER"; + + case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitReason::WR_LPC_REPLY: + return "WR_LPC_REPLY"; + + case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitReason::WR_VIRTUAL_MEMORY: + return "WR_VIRTUAL_MEMORY"; + + case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitReason::WR_PAGE_OUT: + return "WR_PAGE_OUT"; + + case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitReason::WR_RENDEZ_VOUS: + return "WR_RENDEZ_VOUS"; + + case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitReason::WR_KEYED_EVENT: + return "WR_KEYED_EVENT"; + + case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitReason::WR_TERMINATED: + return "WR_TERMINATED"; + + case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitReason::WR_PROCESS_IN_SWAP: + return "WR_PROCESS_IN_SWAP"; + + case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitReason::WR_CPU_RATE_CONTROL: + return "WR_CPU_RATE_CONTROL"; + + case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitReason::WR_CALLOUT_STACK: + return "WR_CALLOUT_STACK"; + + case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitReason::WR_KERNEL: + return "WR_KERNEL"; + + case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitReason::WR_RESOURCE: + return "WR_RESOURCE"; + + case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitReason::WR_PUSH_LOCK: + return "WR_PUSH_LOCK"; + + case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitReason::WR_MUTEX: + return "WR_MUTEX"; + + case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitReason::WR_QUANTUM_END: + return "WR_QUANTUM_END"; + + case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitReason::WR_DISPATCH_INT: + return "WR_DISPATCH_INT"; + + case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitReason::WR_PREEMPTED: + return "WR_PREEMPTED"; + + case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitReason::WR_YIELD_EXECUTION: + return "WR_YIELD_EXECUTION"; + + case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitReason::WR_FAST_MUTEX: + return "WR_FAST_MUTEX"; + + case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitReason::WR_GUARD_MUTEX: + return "WR_GUARD_MUTEX"; + + case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitReason::WR_RUNDOWN: + return "WR_RUNDOWN"; + + case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitReason::MAXIMUM_WAIT_REASON: + return "MAXIMUM_WAIT_REASON"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_CSwitchEtwEvent { +enum OldThreadWaitMode : int32_t { + KERNEL_MODE = 0, + USER_MODE = 1, +}; +} // namespace perfetto_pbzero_enum_CSwitchEtwEvent +using CSwitchEtwEvent_OldThreadWaitMode = perfetto_pbzero_enum_CSwitchEtwEvent::OldThreadWaitMode; + + +constexpr CSwitchEtwEvent_OldThreadWaitMode CSwitchEtwEvent_OldThreadWaitMode_MIN = CSwitchEtwEvent_OldThreadWaitMode::KERNEL_MODE; +constexpr CSwitchEtwEvent_OldThreadWaitMode CSwitchEtwEvent_OldThreadWaitMode_MAX = CSwitchEtwEvent_OldThreadWaitMode::USER_MODE; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* CSwitchEtwEvent_OldThreadWaitMode_Name(::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitMode value) { + switch (value) { + case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitMode::KERNEL_MODE: + return "KERNEL_MODE"; + + case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitMode::USER_MODE: + return "USER_MODE"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_CSwitchEtwEvent { +enum OldThreadState : int32_t { + INITIALIZED = 0, + READY = 1, + RUNNING = 2, + STANDBY = 3, + TERMINATED = 4, + WAITING = 5, + TRANSITION = 6, + DEFERRED_READY = 7, +}; +} // namespace perfetto_pbzero_enum_CSwitchEtwEvent +using CSwitchEtwEvent_OldThreadState = perfetto_pbzero_enum_CSwitchEtwEvent::OldThreadState; + + +constexpr CSwitchEtwEvent_OldThreadState CSwitchEtwEvent_OldThreadState_MIN = CSwitchEtwEvent_OldThreadState::INITIALIZED; +constexpr CSwitchEtwEvent_OldThreadState CSwitchEtwEvent_OldThreadState_MAX = CSwitchEtwEvent_OldThreadState::DEFERRED_READY; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* CSwitchEtwEvent_OldThreadState_Name(::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadState value) { + switch (value) { + case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadState::INITIALIZED: + return "INITIALIZED"; + + case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadState::READY: + return "READY"; + + case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadState::RUNNING: + return "RUNNING"; + + case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadState::STANDBY: + return "STANDBY"; + + case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadState::TERMINATED: + return "TERMINATED"; + + case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadState::WAITING: + return "WAITING"; + + case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadState::TRANSITION: + return "TRANSITION"; + + case ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadState::DEFERRED_READY: + return "DEFERRED_READY"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_ClockSnapshot_Clock { +enum BuiltinClocks : int32_t { + UNKNOWN = 0, + REALTIME = 1, + REALTIME_COARSE = 2, + MONOTONIC = 3, + MONOTONIC_COARSE = 4, + MONOTONIC_RAW = 5, + BOOTTIME = 6, + BUILTIN_CLOCK_MAX_ID = 63, +}; +} // namespace perfetto_pbzero_enum_ClockSnapshot_Clock +using ClockSnapshot_Clock_BuiltinClocks = perfetto_pbzero_enum_ClockSnapshot_Clock::BuiltinClocks; + + +constexpr ClockSnapshot_Clock_BuiltinClocks ClockSnapshot_Clock_BuiltinClocks_MIN = ClockSnapshot_Clock_BuiltinClocks::UNKNOWN; +constexpr ClockSnapshot_Clock_BuiltinClocks ClockSnapshot_Clock_BuiltinClocks_MAX = ClockSnapshot_Clock_BuiltinClocks::BUILTIN_CLOCK_MAX_ID; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* ClockSnapshot_Clock_BuiltinClocks_Name(::perfetto::protos::pbzero::ClockSnapshot_Clock_BuiltinClocks value) { + switch (value) { + case ::perfetto::protos::pbzero::ClockSnapshot_Clock_BuiltinClocks::UNKNOWN: + return "UNKNOWN"; + + case ::perfetto::protos::pbzero::ClockSnapshot_Clock_BuiltinClocks::REALTIME: + return "REALTIME"; + + case ::perfetto::protos::pbzero::ClockSnapshot_Clock_BuiltinClocks::REALTIME_COARSE: + return "REALTIME_COARSE"; + + case ::perfetto::protos::pbzero::ClockSnapshot_Clock_BuiltinClocks::MONOTONIC: + return "MONOTONIC"; + + case ::perfetto::protos::pbzero::ClockSnapshot_Clock_BuiltinClocks::MONOTONIC_COARSE: + return "MONOTONIC_COARSE"; + + case ::perfetto::protos::pbzero::ClockSnapshot_Clock_BuiltinClocks::MONOTONIC_RAW: + return "MONOTONIC_RAW"; + + case ::perfetto::protos::pbzero::ClockSnapshot_Clock_BuiltinClocks::BOOTTIME: + return "BOOTTIME"; + + case ::perfetto::protos::pbzero::ClockSnapshot_Clock_BuiltinClocks::BUILTIN_CLOCK_MAX_ID: + return "BUILTIN_CLOCK_MAX_ID"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_V8WasmCode { +enum Tier : int32_t { + TIER_UNKNOWN = 0, + TIER_LIFTOFF = 1, + TIER_TURBOFAN = 2, +}; +} // namespace perfetto_pbzero_enum_V8WasmCode +using V8WasmCode_Tier = perfetto_pbzero_enum_V8WasmCode::Tier; + + +constexpr V8WasmCode_Tier V8WasmCode_Tier_MIN = V8WasmCode_Tier::TIER_UNKNOWN; +constexpr V8WasmCode_Tier V8WasmCode_Tier_MAX = V8WasmCode_Tier::TIER_TURBOFAN; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* V8WasmCode_Tier_Name(::perfetto::protos::pbzero::V8WasmCode_Tier value) { + switch (value) { + case ::perfetto::protos::pbzero::V8WasmCode_Tier::TIER_UNKNOWN: + return "TIER_UNKNOWN"; + + case ::perfetto::protos::pbzero::V8WasmCode_Tier::TIER_LIFTOFF: + return "TIER_LIFTOFF"; + + case ::perfetto::protos::pbzero::V8WasmCode_Tier::TIER_TURBOFAN: + return "TIER_TURBOFAN"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_V8InternalCode { +enum Type : int32_t { + TYPE_UNKNOWN = 0, + TYPE_BYTECODE_HANDLER = 1, + TYPE_FOR_TESTING = 2, + TYPE_BUILTIN = 3, + TYPE_WASM_FUNCTION = 4, + TYPE_WASM_TO_CAPI_FUNCTION = 5, + TYPE_WASM_TO_JS_FUNCTION = 6, + TYPE_JS_TO_WASM_FUNCTION = 7, + TYPE_JS_TO_JS_FUNCTION = 8, + TYPE_C_WASM_ENTRY = 9, +}; +} // namespace perfetto_pbzero_enum_V8InternalCode +using V8InternalCode_Type = perfetto_pbzero_enum_V8InternalCode::Type; + + +constexpr V8InternalCode_Type V8InternalCode_Type_MIN = V8InternalCode_Type::TYPE_UNKNOWN; +constexpr V8InternalCode_Type V8InternalCode_Type_MAX = V8InternalCode_Type::TYPE_C_WASM_ENTRY; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* V8InternalCode_Type_Name(::perfetto::protos::pbzero::V8InternalCode_Type value) { + switch (value) { + case ::perfetto::protos::pbzero::V8InternalCode_Type::TYPE_UNKNOWN: + return "TYPE_UNKNOWN"; + + case ::perfetto::protos::pbzero::V8InternalCode_Type::TYPE_BYTECODE_HANDLER: + return "TYPE_BYTECODE_HANDLER"; + + case ::perfetto::protos::pbzero::V8InternalCode_Type::TYPE_FOR_TESTING: + return "TYPE_FOR_TESTING"; + + case ::perfetto::protos::pbzero::V8InternalCode_Type::TYPE_BUILTIN: + return "TYPE_BUILTIN"; + + case ::perfetto::protos::pbzero::V8InternalCode_Type::TYPE_WASM_FUNCTION: + return "TYPE_WASM_FUNCTION"; + + case ::perfetto::protos::pbzero::V8InternalCode_Type::TYPE_WASM_TO_CAPI_FUNCTION: + return "TYPE_WASM_TO_CAPI_FUNCTION"; + + case ::perfetto::protos::pbzero::V8InternalCode_Type::TYPE_WASM_TO_JS_FUNCTION: + return "TYPE_WASM_TO_JS_FUNCTION"; + + case ::perfetto::protos::pbzero::V8InternalCode_Type::TYPE_JS_TO_WASM_FUNCTION: + return "TYPE_JS_TO_WASM_FUNCTION"; + + case ::perfetto::protos::pbzero::V8InternalCode_Type::TYPE_JS_TO_JS_FUNCTION: + return "TYPE_JS_TO_JS_FUNCTION"; + + case ::perfetto::protos::pbzero::V8InternalCode_Type::TYPE_C_WASM_ENTRY: + return "TYPE_C_WASM_ENTRY"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_V8JsCode { +enum Tier : int32_t { + TIER_UNKNOWN = 0, + TIER_IGNITION = 1, + TIER_SPARKPLUG = 2, + TIER_MAGLEV = 3, + TIER_TURBOSHAFT = 4, + TIER_TURBOFAN = 5, +}; +} // namespace perfetto_pbzero_enum_V8JsCode +using V8JsCode_Tier = perfetto_pbzero_enum_V8JsCode::Tier; + + +constexpr V8JsCode_Tier V8JsCode_Tier_MIN = V8JsCode_Tier::TIER_UNKNOWN; +constexpr V8JsCode_Tier V8JsCode_Tier_MAX = V8JsCode_Tier::TIER_TURBOFAN; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* V8JsCode_Tier_Name(::perfetto::protos::pbzero::V8JsCode_Tier value) { + switch (value) { + case ::perfetto::protos::pbzero::V8JsCode_Tier::TIER_UNKNOWN: + return "TIER_UNKNOWN"; + + case ::perfetto::protos::pbzero::V8JsCode_Tier::TIER_IGNITION: + return "TIER_IGNITION"; + + case ::perfetto::protos::pbzero::V8JsCode_Tier::TIER_SPARKPLUG: + return "TIER_SPARKPLUG"; + + case ::perfetto::protos::pbzero::V8JsCode_Tier::TIER_MAGLEV: + return "TIER_MAGLEV"; + + case ::perfetto::protos::pbzero::V8JsCode_Tier::TIER_TURBOSHAFT: + return "TIER_TURBOSHAFT"; + + case ::perfetto::protos::pbzero::V8JsCode_Tier::TIER_TURBOFAN: + return "TIER_TURBOFAN"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_InternedV8JsFunction { +enum Kind : int32_t { + KIND_UNKNOWN = 0, + KIND_NORMAL_FUNCTION = 1, + KIND_MODULE = 2, + KIND_ASYNC_MODULE = 3, + KIND_BASE_CONSTRUCTOR = 4, + KIND_DEFAULT_BASE_CONSTRUCTOR = 5, + KIND_DEFAULT_DERIVED_CONSTRUCTOR = 6, + KIND_DERIVED_CONSTRUCTOR = 7, + KIND_GETTER_FUNCTION = 8, + KIND_STATIC_GETTER_FUNCTION = 9, + KIND_SETTER_FUNCTION = 10, + KIND_STATIC_SETTER_FUNCTION = 11, + KIND_ARROW_FUNCTION = 12, + KIND_ASYNC_ARROW_FUNCTION = 13, + KIND_ASYNC_FUNCTION = 14, + KIND_ASYNC_CONCISE_METHOD = 15, + KIND_STATIC_ASYNC_CONCISE_METHOD = 16, + KIND_ASYNC_CONCISE_GENERATOR_METHOD = 17, + KIND_STATIC_ASYNC_CONCISE_GENERATOR_METHOD = 18, + KIND_ASYNC_GENERATOR_FUNCTION = 19, + KIND_GENERATOR_FUNCTION = 20, + KIND_CONCISE_GENERATOR_METHOD = 21, + KIND_STATIC_CONCISE_GENERATOR_METHOD = 22, + KIND_CONCISE_METHOD = 23, + KIND_STATIC_CONCISE_METHOD = 24, + KIND_CLASS_MEMBERS_INITIALIZER_FUNCTION = 25, + KIND_CLASS_STATIC_INITIALIZER_FUNCTION = 26, + KIND_INVALID = 27, +}; +} // namespace perfetto_pbzero_enum_InternedV8JsFunction +using InternedV8JsFunction_Kind = perfetto_pbzero_enum_InternedV8JsFunction::Kind; + + +constexpr InternedV8JsFunction_Kind InternedV8JsFunction_Kind_MIN = InternedV8JsFunction_Kind::KIND_UNKNOWN; +constexpr InternedV8JsFunction_Kind InternedV8JsFunction_Kind_MAX = InternedV8JsFunction_Kind::KIND_INVALID; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* InternedV8JsFunction_Kind_Name(::perfetto::protos::pbzero::InternedV8JsFunction_Kind value) { + switch (value) { + case ::perfetto::protos::pbzero::InternedV8JsFunction_Kind::KIND_UNKNOWN: + return "KIND_UNKNOWN"; + + case ::perfetto::protos::pbzero::InternedV8JsFunction_Kind::KIND_NORMAL_FUNCTION: + return "KIND_NORMAL_FUNCTION"; + + case ::perfetto::protos::pbzero::InternedV8JsFunction_Kind::KIND_MODULE: + return "KIND_MODULE"; + + case ::perfetto::protos::pbzero::InternedV8JsFunction_Kind::KIND_ASYNC_MODULE: + return "KIND_ASYNC_MODULE"; + + case ::perfetto::protos::pbzero::InternedV8JsFunction_Kind::KIND_BASE_CONSTRUCTOR: + return "KIND_BASE_CONSTRUCTOR"; + + case ::perfetto::protos::pbzero::InternedV8JsFunction_Kind::KIND_DEFAULT_BASE_CONSTRUCTOR: + return "KIND_DEFAULT_BASE_CONSTRUCTOR"; + + case ::perfetto::protos::pbzero::InternedV8JsFunction_Kind::KIND_DEFAULT_DERIVED_CONSTRUCTOR: + return "KIND_DEFAULT_DERIVED_CONSTRUCTOR"; + + case ::perfetto::protos::pbzero::InternedV8JsFunction_Kind::KIND_DERIVED_CONSTRUCTOR: + return "KIND_DERIVED_CONSTRUCTOR"; + + case ::perfetto::protos::pbzero::InternedV8JsFunction_Kind::KIND_GETTER_FUNCTION: + return "KIND_GETTER_FUNCTION"; + + case ::perfetto::protos::pbzero::InternedV8JsFunction_Kind::KIND_STATIC_GETTER_FUNCTION: + return "KIND_STATIC_GETTER_FUNCTION"; + + case ::perfetto::protos::pbzero::InternedV8JsFunction_Kind::KIND_SETTER_FUNCTION: + return "KIND_SETTER_FUNCTION"; + + case ::perfetto::protos::pbzero::InternedV8JsFunction_Kind::KIND_STATIC_SETTER_FUNCTION: + return "KIND_STATIC_SETTER_FUNCTION"; + + case ::perfetto::protos::pbzero::InternedV8JsFunction_Kind::KIND_ARROW_FUNCTION: + return "KIND_ARROW_FUNCTION"; + + case ::perfetto::protos::pbzero::InternedV8JsFunction_Kind::KIND_ASYNC_ARROW_FUNCTION: + return "KIND_ASYNC_ARROW_FUNCTION"; + + case ::perfetto::protos::pbzero::InternedV8JsFunction_Kind::KIND_ASYNC_FUNCTION: + return "KIND_ASYNC_FUNCTION"; + + case ::perfetto::protos::pbzero::InternedV8JsFunction_Kind::KIND_ASYNC_CONCISE_METHOD: + return "KIND_ASYNC_CONCISE_METHOD"; + + case ::perfetto::protos::pbzero::InternedV8JsFunction_Kind::KIND_STATIC_ASYNC_CONCISE_METHOD: + return "KIND_STATIC_ASYNC_CONCISE_METHOD"; + + case ::perfetto::protos::pbzero::InternedV8JsFunction_Kind::KIND_ASYNC_CONCISE_GENERATOR_METHOD: + return "KIND_ASYNC_CONCISE_GENERATOR_METHOD"; + + case ::perfetto::protos::pbzero::InternedV8JsFunction_Kind::KIND_STATIC_ASYNC_CONCISE_GENERATOR_METHOD: + return "KIND_STATIC_ASYNC_CONCISE_GENERATOR_METHOD"; + + case ::perfetto::protos::pbzero::InternedV8JsFunction_Kind::KIND_ASYNC_GENERATOR_FUNCTION: + return "KIND_ASYNC_GENERATOR_FUNCTION"; + + case ::perfetto::protos::pbzero::InternedV8JsFunction_Kind::KIND_GENERATOR_FUNCTION: + return "KIND_GENERATOR_FUNCTION"; + + case ::perfetto::protos::pbzero::InternedV8JsFunction_Kind::KIND_CONCISE_GENERATOR_METHOD: + return "KIND_CONCISE_GENERATOR_METHOD"; + + case ::perfetto::protos::pbzero::InternedV8JsFunction_Kind::KIND_STATIC_CONCISE_GENERATOR_METHOD: + return "KIND_STATIC_CONCISE_GENERATOR_METHOD"; + + case ::perfetto::protos::pbzero::InternedV8JsFunction_Kind::KIND_CONCISE_METHOD: + return "KIND_CONCISE_METHOD"; + + case ::perfetto::protos::pbzero::InternedV8JsFunction_Kind::KIND_STATIC_CONCISE_METHOD: + return "KIND_STATIC_CONCISE_METHOD"; + + case ::perfetto::protos::pbzero::InternedV8JsFunction_Kind::KIND_CLASS_MEMBERS_INITIALIZER_FUNCTION: + return "KIND_CLASS_MEMBERS_INITIALIZER_FUNCTION"; + + case ::perfetto::protos::pbzero::InternedV8JsFunction_Kind::KIND_CLASS_STATIC_INITIALIZER_FUNCTION: + return "KIND_CLASS_STATIC_INITIALIZER_FUNCTION"; + + case ::perfetto::protos::pbzero::InternedV8JsFunction_Kind::KIND_INVALID: + return "KIND_INVALID"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_InternedV8JsScript { +enum Type : int32_t { + TYPE_UNKNOWN = 0, + TYPE_NORMAL = 1, + TYPE_EVAL = 2, + TYPE_MODULE = 3, + TYPE_NATIVE = 4, + TYPE_EXTENSION = 5, + TYPE_INSPECTOR = 6, +}; +} // namespace perfetto_pbzero_enum_InternedV8JsScript +using InternedV8JsScript_Type = perfetto_pbzero_enum_InternedV8JsScript::Type; + + +constexpr InternedV8JsScript_Type InternedV8JsScript_Type_MIN = InternedV8JsScript_Type::TYPE_UNKNOWN; +constexpr InternedV8JsScript_Type InternedV8JsScript_Type_MAX = InternedV8JsScript_Type::TYPE_INSPECTOR; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* InternedV8JsScript_Type_Name(::perfetto::protos::pbzero::InternedV8JsScript_Type value) { + switch (value) { + case ::perfetto::protos::pbzero::InternedV8JsScript_Type::TYPE_UNKNOWN: + return "TYPE_UNKNOWN"; + + case ::perfetto::protos::pbzero::InternedV8JsScript_Type::TYPE_NORMAL: + return "TYPE_NORMAL"; + + case ::perfetto::protos::pbzero::InternedV8JsScript_Type::TYPE_EVAL: + return "TYPE_EVAL"; + + case ::perfetto::protos::pbzero::InternedV8JsScript_Type::TYPE_MODULE: + return "TYPE_MODULE"; + + case ::perfetto::protos::pbzero::InternedV8JsScript_Type::TYPE_NATIVE: + return "TYPE_NATIVE"; + + case ::perfetto::protos::pbzero::InternedV8JsScript_Type::TYPE_EXTENSION: + return "TYPE_EXTENSION"; + + case ::perfetto::protos::pbzero::InternedV8JsScript_Type::TYPE_INSPECTOR: + return "TYPE_INSPECTOR"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_ChromeLegacyJsonTrace { +enum TraceType : int32_t { + USER_TRACE = 0, + SYSTEM_TRACE = 1, +}; +} // namespace perfetto_pbzero_enum_ChromeLegacyJsonTrace +using ChromeLegacyJsonTrace_TraceType = perfetto_pbzero_enum_ChromeLegacyJsonTrace::TraceType; + + +constexpr ChromeLegacyJsonTrace_TraceType ChromeLegacyJsonTrace_TraceType_MIN = ChromeLegacyJsonTrace_TraceType::USER_TRACE; +constexpr ChromeLegacyJsonTrace_TraceType ChromeLegacyJsonTrace_TraceType_MAX = ChromeLegacyJsonTrace_TraceType::SYSTEM_TRACE; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* ChromeLegacyJsonTrace_TraceType_Name(::perfetto::protos::pbzero::ChromeLegacyJsonTrace_TraceType value) { + switch (value) { + case ::perfetto::protos::pbzero::ChromeLegacyJsonTrace_TraceType::USER_TRACE: + return "USER_TRACE"; + + case ::perfetto::protos::pbzero::ChromeLegacyJsonTrace_TraceType::SYSTEM_TRACE: + return "SYSTEM_TRACE"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_ChromeTracedValue { +enum NestedType : int32_t { + DICT = 0, + ARRAY = 1, +}; +} // namespace perfetto_pbzero_enum_ChromeTracedValue +using ChromeTracedValue_NestedType = perfetto_pbzero_enum_ChromeTracedValue::NestedType; + + +constexpr ChromeTracedValue_NestedType ChromeTracedValue_NestedType_MIN = ChromeTracedValue_NestedType::DICT; +constexpr ChromeTracedValue_NestedType ChromeTracedValue_NestedType_MAX = ChromeTracedValue_NestedType::ARRAY; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* ChromeTracedValue_NestedType_Name(::perfetto::protos::pbzero::ChromeTracedValue_NestedType value) { + switch (value) { + case ::perfetto::protos::pbzero::ChromeTracedValue_NestedType::DICT: + return "DICT"; + + case ::perfetto::protos::pbzero::ChromeTracedValue_NestedType::ARRAY: + return "ARRAY"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_BackgroundTracingMetadata_TriggerRule { +enum TriggerType : int32_t { + TRIGGER_UNSPECIFIED = 0, + MONITOR_AND_DUMP_WHEN_SPECIFIC_HISTOGRAM_AND_VALUE = 1, + MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED = 2, +}; +} // namespace perfetto_pbzero_enum_BackgroundTracingMetadata_TriggerRule +using BackgroundTracingMetadata_TriggerRule_TriggerType = perfetto_pbzero_enum_BackgroundTracingMetadata_TriggerRule::TriggerType; + + +constexpr BackgroundTracingMetadata_TriggerRule_TriggerType BackgroundTracingMetadata_TriggerRule_TriggerType_MIN = BackgroundTracingMetadata_TriggerRule_TriggerType::TRIGGER_UNSPECIFIED; +constexpr BackgroundTracingMetadata_TriggerRule_TriggerType BackgroundTracingMetadata_TriggerRule_TriggerType_MAX = BackgroundTracingMetadata_TriggerRule_TriggerType::MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* BackgroundTracingMetadata_TriggerRule_TriggerType_Name(::perfetto::protos::pbzero::BackgroundTracingMetadata_TriggerRule_TriggerType value) { + switch (value) { + case ::perfetto::protos::pbzero::BackgroundTracingMetadata_TriggerRule_TriggerType::TRIGGER_UNSPECIFIED: + return "TRIGGER_UNSPECIFIED"; + + case ::perfetto::protos::pbzero::BackgroundTracingMetadata_TriggerRule_TriggerType::MONITOR_AND_DUMP_WHEN_SPECIFIC_HISTOGRAM_AND_VALUE: + return "MONITOR_AND_DUMP_WHEN_SPECIFIC_HISTOGRAM_AND_VALUE"; + + case ::perfetto::protos::pbzero::BackgroundTracingMetadata_TriggerRule_TriggerType::MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED: + return "MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_BackgroundTracingMetadata_TriggerRule_NamedRule { +enum EventType : int32_t { + UNSPECIFIED = 0, + SESSION_RESTORE = 1, + NAVIGATION = 2, + STARTUP = 3, + REACHED_CODE = 4, + CONTENT_TRIGGER = 5, + TEST_RULE = 1000, +}; +} // namespace perfetto_pbzero_enum_BackgroundTracingMetadata_TriggerRule_NamedRule +using BackgroundTracingMetadata_TriggerRule_NamedRule_EventType = perfetto_pbzero_enum_BackgroundTracingMetadata_TriggerRule_NamedRule::EventType; + + +constexpr BackgroundTracingMetadata_TriggerRule_NamedRule_EventType BackgroundTracingMetadata_TriggerRule_NamedRule_EventType_MIN = BackgroundTracingMetadata_TriggerRule_NamedRule_EventType::UNSPECIFIED; +constexpr BackgroundTracingMetadata_TriggerRule_NamedRule_EventType BackgroundTracingMetadata_TriggerRule_NamedRule_EventType_MAX = BackgroundTracingMetadata_TriggerRule_NamedRule_EventType::TEST_RULE; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* BackgroundTracingMetadata_TriggerRule_NamedRule_EventType_Name(::perfetto::protos::pbzero::BackgroundTracingMetadata_TriggerRule_NamedRule_EventType value) { + switch (value) { + case ::perfetto::protos::pbzero::BackgroundTracingMetadata_TriggerRule_NamedRule_EventType::UNSPECIFIED: + return "UNSPECIFIED"; + + case ::perfetto::protos::pbzero::BackgroundTracingMetadata_TriggerRule_NamedRule_EventType::SESSION_RESTORE: + return "SESSION_RESTORE"; + + case ::perfetto::protos::pbzero::BackgroundTracingMetadata_TriggerRule_NamedRule_EventType::NAVIGATION: + return "NAVIGATION"; + + case ::perfetto::protos::pbzero::BackgroundTracingMetadata_TriggerRule_NamedRule_EventType::STARTUP: + return "STARTUP"; + + case ::perfetto::protos::pbzero::BackgroundTracingMetadata_TriggerRule_NamedRule_EventType::REACHED_CODE: + return "REACHED_CODE"; + + case ::perfetto::protos::pbzero::BackgroundTracingMetadata_TriggerRule_NamedRule_EventType::CONTENT_TRIGGER: + return "CONTENT_TRIGGER"; + + case ::perfetto::protos::pbzero::BackgroundTracingMetadata_TriggerRule_NamedRule_EventType::TEST_RULE: + return "TEST_RULE"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_DisplayState { +enum Changes : int32_t { + eChangesNone = 0, + eSurfaceChanged = 1, + eLayerStackChanged = 2, + eDisplayProjectionChanged = 4, + eDisplaySizeChanged = 8, + eFlagsChanged = 16, +}; +} // namespace perfetto_pbzero_enum_DisplayState +using DisplayState_Changes = perfetto_pbzero_enum_DisplayState::Changes; + + +constexpr DisplayState_Changes DisplayState_Changes_MIN = DisplayState_Changes::eChangesNone; +constexpr DisplayState_Changes DisplayState_Changes_MAX = DisplayState_Changes::eFlagsChanged; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* DisplayState_Changes_Name(::perfetto::protos::pbzero::DisplayState_Changes value) { + switch (value) { + case ::perfetto::protos::pbzero::DisplayState_Changes::eChangesNone: + return "eChangesNone"; + + case ::perfetto::protos::pbzero::DisplayState_Changes::eSurfaceChanged: + return "eSurfaceChanged"; + + case ::perfetto::protos::pbzero::DisplayState_Changes::eLayerStackChanged: + return "eLayerStackChanged"; + + case ::perfetto::protos::pbzero::DisplayState_Changes::eDisplayProjectionChanged: + return "eDisplayProjectionChanged"; + + case ::perfetto::protos::pbzero::DisplayState_Changes::eDisplaySizeChanged: + return "eDisplaySizeChanged"; + + case ::perfetto::protos::pbzero::DisplayState_Changes::eFlagsChanged: + return "eFlagsChanged"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_LayerState { +enum ChangesLsb : int32_t { + eChangesLsbNone = 0, + ePositionChanged = 1, + eLayerChanged = 2, + eAlphaChanged = 8, + eMatrixChanged = 16, + eTransparentRegionChanged = 32, + eFlagsChanged = 64, + eLayerStackChanged = 128, + eReleaseBufferListenerChanged = 1024, + eShadowRadiusChanged = 2048, + eBufferCropChanged = 8192, + eRelativeLayerChanged = 16384, + eReparent = 32768, + eColorChanged = 65536, + eBufferTransformChanged = 262144, + eTransformToDisplayInverseChanged = 524288, + eCropChanged = 1048576, + eBufferChanged = 2097152, + eAcquireFenceChanged = 4194304, + eDataspaceChanged = 8388608, + eHdrMetadataChanged = 16777216, + eSurfaceDamageRegionChanged = 33554432, + eApiChanged = 67108864, + eSidebandStreamChanged = 134217728, + eColorTransformChanged = 268435456, + eHasListenerCallbacksChanged = 536870912, + eInputInfoChanged = 1073741824, + eCornerRadiusChanged = -2147483648, +}; +} // namespace perfetto_pbzero_enum_LayerState +using LayerState_ChangesLsb = perfetto_pbzero_enum_LayerState::ChangesLsb; + + +constexpr LayerState_ChangesLsb LayerState_ChangesLsb_MIN = LayerState_ChangesLsb::eCornerRadiusChanged; +constexpr LayerState_ChangesLsb LayerState_ChangesLsb_MAX = LayerState_ChangesLsb::eInputInfoChanged; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* LayerState_ChangesLsb_Name(::perfetto::protos::pbzero::LayerState_ChangesLsb value) { + switch (value) { + case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eChangesLsbNone: + return "eChangesLsbNone"; + + case ::perfetto::protos::pbzero::LayerState_ChangesLsb::ePositionChanged: + return "ePositionChanged"; + + case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eLayerChanged: + return "eLayerChanged"; + + case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eAlphaChanged: + return "eAlphaChanged"; + + case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eMatrixChanged: + return "eMatrixChanged"; + + case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eTransparentRegionChanged: + return "eTransparentRegionChanged"; + + case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eFlagsChanged: + return "eFlagsChanged"; + + case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eLayerStackChanged: + return "eLayerStackChanged"; + + case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eReleaseBufferListenerChanged: + return "eReleaseBufferListenerChanged"; + + case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eShadowRadiusChanged: + return "eShadowRadiusChanged"; + + case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eBufferCropChanged: + return "eBufferCropChanged"; + + case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eRelativeLayerChanged: + return "eRelativeLayerChanged"; + + case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eReparent: + return "eReparent"; + + case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eColorChanged: + return "eColorChanged"; + + case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eBufferTransformChanged: + return "eBufferTransformChanged"; + + case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eTransformToDisplayInverseChanged: + return "eTransformToDisplayInverseChanged"; + + case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eCropChanged: + return "eCropChanged"; + + case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eBufferChanged: + return "eBufferChanged"; + + case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eAcquireFenceChanged: + return "eAcquireFenceChanged"; + + case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eDataspaceChanged: + return "eDataspaceChanged"; + + case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eHdrMetadataChanged: + return "eHdrMetadataChanged"; + + case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eSurfaceDamageRegionChanged: + return "eSurfaceDamageRegionChanged"; + + case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eApiChanged: + return "eApiChanged"; + + case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eSidebandStreamChanged: + return "eSidebandStreamChanged"; + + case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eColorTransformChanged: + return "eColorTransformChanged"; + + case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eHasListenerCallbacksChanged: + return "eHasListenerCallbacksChanged"; + + case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eInputInfoChanged: + return "eInputInfoChanged"; + + case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eCornerRadiusChanged: + return "eCornerRadiusChanged"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_LayerState { +enum ChangesMsb : int32_t { + eChangesMsbNone = 0, + eDestinationFrameChanged = 1, + eCachedBufferChanged = 2, + eBackgroundColorChanged = 4, + eMetadataChanged = 8, + eColorSpaceAgnosticChanged = 16, + eFrameRateSelectionPriority = 32, + eFrameRateChanged = 64, + eBackgroundBlurRadiusChanged = 128, + eProducerDisconnect = 256, + eFixedTransformHintChanged = 512, + eFrameNumberChanged = 1024, + eBlurRegionsChanged = 2048, + eAutoRefreshChanged = 4096, + eStretchChanged = 8192, + eTrustedOverlayChanged = 16384, + eDropInputModeChanged = 32768, +}; +} // namespace perfetto_pbzero_enum_LayerState +using LayerState_ChangesMsb = perfetto_pbzero_enum_LayerState::ChangesMsb; + + +constexpr LayerState_ChangesMsb LayerState_ChangesMsb_MIN = LayerState_ChangesMsb::eChangesMsbNone; +constexpr LayerState_ChangesMsb LayerState_ChangesMsb_MAX = LayerState_ChangesMsb::eDropInputModeChanged; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* LayerState_ChangesMsb_Name(::perfetto::protos::pbzero::LayerState_ChangesMsb value) { + switch (value) { + case ::perfetto::protos::pbzero::LayerState_ChangesMsb::eChangesMsbNone: + return "eChangesMsbNone"; + + case ::perfetto::protos::pbzero::LayerState_ChangesMsb::eDestinationFrameChanged: + return "eDestinationFrameChanged"; + + case ::perfetto::protos::pbzero::LayerState_ChangesMsb::eCachedBufferChanged: + return "eCachedBufferChanged"; + + case ::perfetto::protos::pbzero::LayerState_ChangesMsb::eBackgroundColorChanged: + return "eBackgroundColorChanged"; + + case ::perfetto::protos::pbzero::LayerState_ChangesMsb::eMetadataChanged: + return "eMetadataChanged"; + + case ::perfetto::protos::pbzero::LayerState_ChangesMsb::eColorSpaceAgnosticChanged: + return "eColorSpaceAgnosticChanged"; + + case ::perfetto::protos::pbzero::LayerState_ChangesMsb::eFrameRateSelectionPriority: + return "eFrameRateSelectionPriority"; + + case ::perfetto::protos::pbzero::LayerState_ChangesMsb::eFrameRateChanged: + return "eFrameRateChanged"; + + case ::perfetto::protos::pbzero::LayerState_ChangesMsb::eBackgroundBlurRadiusChanged: + return "eBackgroundBlurRadiusChanged"; + + case ::perfetto::protos::pbzero::LayerState_ChangesMsb::eProducerDisconnect: + return "eProducerDisconnect"; + + case ::perfetto::protos::pbzero::LayerState_ChangesMsb::eFixedTransformHintChanged: + return "eFixedTransformHintChanged"; + + case ::perfetto::protos::pbzero::LayerState_ChangesMsb::eFrameNumberChanged: + return "eFrameNumberChanged"; + + case ::perfetto::protos::pbzero::LayerState_ChangesMsb::eBlurRegionsChanged: + return "eBlurRegionsChanged"; + + case ::perfetto::protos::pbzero::LayerState_ChangesMsb::eAutoRefreshChanged: + return "eAutoRefreshChanged"; + + case ::perfetto::protos::pbzero::LayerState_ChangesMsb::eStretchChanged: + return "eStretchChanged"; + + case ::perfetto::protos::pbzero::LayerState_ChangesMsb::eTrustedOverlayChanged: + return "eTrustedOverlayChanged"; + + case ::perfetto::protos::pbzero::LayerState_ChangesMsb::eDropInputModeChanged: + return "eDropInputModeChanged"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_LayerState { +enum Flags : int32_t { + eFlagsNone = 0, + eLayerHidden = 1, + eLayerOpaque = 2, + eLayerSkipScreenshot = 64, + eLayerSecure = 128, + eEnableBackpressure = 256, + eLayerIsDisplayDecoration = 512, +}; +} // namespace perfetto_pbzero_enum_LayerState +using LayerState_Flags = perfetto_pbzero_enum_LayerState::Flags; + + +constexpr LayerState_Flags LayerState_Flags_MIN = LayerState_Flags::eFlagsNone; +constexpr LayerState_Flags LayerState_Flags_MAX = LayerState_Flags::eLayerIsDisplayDecoration; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* LayerState_Flags_Name(::perfetto::protos::pbzero::LayerState_Flags value) { + switch (value) { + case ::perfetto::protos::pbzero::LayerState_Flags::eFlagsNone: + return "eFlagsNone"; + + case ::perfetto::protos::pbzero::LayerState_Flags::eLayerHidden: + return "eLayerHidden"; + + case ::perfetto::protos::pbzero::LayerState_Flags::eLayerOpaque: + return "eLayerOpaque"; + + case ::perfetto::protos::pbzero::LayerState_Flags::eLayerSkipScreenshot: + return "eLayerSkipScreenshot"; + + case ::perfetto::protos::pbzero::LayerState_Flags::eLayerSecure: + return "eLayerSecure"; + + case ::perfetto::protos::pbzero::LayerState_Flags::eEnableBackpressure: + return "eEnableBackpressure"; + + case ::perfetto::protos::pbzero::LayerState_Flags::eLayerIsDisplayDecoration: + return "eLayerIsDisplayDecoration"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_LayerState { +enum DropInputMode : int32_t { + NONE = 0, + ALL = 1, + OBSCURED = 2, +}; +} // namespace perfetto_pbzero_enum_LayerState +using LayerState_DropInputMode = perfetto_pbzero_enum_LayerState::DropInputMode; + + +constexpr LayerState_DropInputMode LayerState_DropInputMode_MIN = LayerState_DropInputMode::NONE; +constexpr LayerState_DropInputMode LayerState_DropInputMode_MAX = LayerState_DropInputMode::OBSCURED; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* LayerState_DropInputMode_Name(::perfetto::protos::pbzero::LayerState_DropInputMode value) { + switch (value) { + case ::perfetto::protos::pbzero::LayerState_DropInputMode::NONE: + return "NONE"; + + case ::perfetto::protos::pbzero::LayerState_DropInputMode::ALL: + return "ALL"; + + case ::perfetto::protos::pbzero::LayerState_DropInputMode::OBSCURED: + return "OBSCURED"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_LayerState_BufferData { +enum BufferDataChange : int32_t { + BufferDataChangeNone = 0, + fenceChanged = 1, + frameNumberChanged = 2, + cachedBufferChanged = 4, +}; +} // namespace perfetto_pbzero_enum_LayerState_BufferData +using LayerState_BufferData_BufferDataChange = perfetto_pbzero_enum_LayerState_BufferData::BufferDataChange; + + +constexpr LayerState_BufferData_BufferDataChange LayerState_BufferData_BufferDataChange_MIN = LayerState_BufferData_BufferDataChange::BufferDataChangeNone; +constexpr LayerState_BufferData_BufferDataChange LayerState_BufferData_BufferDataChange_MAX = LayerState_BufferData_BufferDataChange::cachedBufferChanged; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* LayerState_BufferData_BufferDataChange_Name(::perfetto::protos::pbzero::LayerState_BufferData_BufferDataChange value) { + switch (value) { + case ::perfetto::protos::pbzero::LayerState_BufferData_BufferDataChange::BufferDataChangeNone: + return "BufferDataChangeNone"; + + case ::perfetto::protos::pbzero::LayerState_BufferData_BufferDataChange::fenceChanged: + return "fenceChanged"; + + case ::perfetto::protos::pbzero::LayerState_BufferData_BufferDataChange::frameNumberChanged: + return "frameNumberChanged"; + + case ::perfetto::protos::pbzero::LayerState_BufferData_BufferDataChange::cachedBufferChanged: + return "cachedBufferChanged"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_LayerState_BufferData { +enum PixelFormat : int32_t { + PIXEL_FORMAT_UNKNOWN = 0, + PIXEL_FORMAT_CUSTOM = -4, + PIXEL_FORMAT_TRANSLUCENT = -3, + PIXEL_FORMAT_TRANSPARENT = -2, + PIXEL_FORMAT_OPAQUE = -1, + PIXEL_FORMAT_RGBA_8888 = 1, + PIXEL_FORMAT_RGBX_8888 = 2, + PIXEL_FORMAT_RGB_888 = 3, + PIXEL_FORMAT_RGB_565 = 4, + PIXEL_FORMAT_BGRA_8888 = 5, + PIXEL_FORMAT_RGBA_5551 = 6, + PIXEL_FORMAT_RGBA_4444 = 7, + PIXEL_FORMAT_RGBA_FP16 = 22, + PIXEL_FORMAT_RGBA_1010102 = 43, + PIXEL_FORMAT_R_8 = 56, +}; +} // namespace perfetto_pbzero_enum_LayerState_BufferData +using LayerState_BufferData_PixelFormat = perfetto_pbzero_enum_LayerState_BufferData::PixelFormat; + + +constexpr LayerState_BufferData_PixelFormat LayerState_BufferData_PixelFormat_MIN = LayerState_BufferData_PixelFormat::PIXEL_FORMAT_CUSTOM; +constexpr LayerState_BufferData_PixelFormat LayerState_BufferData_PixelFormat_MAX = LayerState_BufferData_PixelFormat::PIXEL_FORMAT_R_8; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* LayerState_BufferData_PixelFormat_Name(::perfetto::protos::pbzero::LayerState_BufferData_PixelFormat value) { + switch (value) { + case ::perfetto::protos::pbzero::LayerState_BufferData_PixelFormat::PIXEL_FORMAT_UNKNOWN: + return "PIXEL_FORMAT_UNKNOWN"; + + case ::perfetto::protos::pbzero::LayerState_BufferData_PixelFormat::PIXEL_FORMAT_CUSTOM: + return "PIXEL_FORMAT_CUSTOM"; + + case ::perfetto::protos::pbzero::LayerState_BufferData_PixelFormat::PIXEL_FORMAT_TRANSLUCENT: + return "PIXEL_FORMAT_TRANSLUCENT"; + + case ::perfetto::protos::pbzero::LayerState_BufferData_PixelFormat::PIXEL_FORMAT_TRANSPARENT: + return "PIXEL_FORMAT_TRANSPARENT"; + + case ::perfetto::protos::pbzero::LayerState_BufferData_PixelFormat::PIXEL_FORMAT_OPAQUE: + return "PIXEL_FORMAT_OPAQUE"; + + case ::perfetto::protos::pbzero::LayerState_BufferData_PixelFormat::PIXEL_FORMAT_RGBA_8888: + return "PIXEL_FORMAT_RGBA_8888"; + + case ::perfetto::protos::pbzero::LayerState_BufferData_PixelFormat::PIXEL_FORMAT_RGBX_8888: + return "PIXEL_FORMAT_RGBX_8888"; + + case ::perfetto::protos::pbzero::LayerState_BufferData_PixelFormat::PIXEL_FORMAT_RGB_888: + return "PIXEL_FORMAT_RGB_888"; + + case ::perfetto::protos::pbzero::LayerState_BufferData_PixelFormat::PIXEL_FORMAT_RGB_565: + return "PIXEL_FORMAT_RGB_565"; + + case ::perfetto::protos::pbzero::LayerState_BufferData_PixelFormat::PIXEL_FORMAT_BGRA_8888: + return "PIXEL_FORMAT_BGRA_8888"; + + case ::perfetto::protos::pbzero::LayerState_BufferData_PixelFormat::PIXEL_FORMAT_RGBA_5551: + return "PIXEL_FORMAT_RGBA_5551"; + + case ::perfetto::protos::pbzero::LayerState_BufferData_PixelFormat::PIXEL_FORMAT_RGBA_4444: + return "PIXEL_FORMAT_RGBA_4444"; + + case ::perfetto::protos::pbzero::LayerState_BufferData_PixelFormat::PIXEL_FORMAT_RGBA_FP16: + return "PIXEL_FORMAT_RGBA_FP16"; + + case ::perfetto::protos::pbzero::LayerState_BufferData_PixelFormat::PIXEL_FORMAT_RGBA_1010102: + return "PIXEL_FORMAT_RGBA_1010102"; + + case ::perfetto::protos::pbzero::LayerState_BufferData_PixelFormat::PIXEL_FORMAT_R_8: + return "PIXEL_FORMAT_R_8"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_TransactionTraceFile { +enum MagicNumber : int32_t { + INVALID = 0, + MAGIC_NUMBER_L = 1415073364, + MAGIC_NUMBER_H = 1162035538, +}; +} // namespace perfetto_pbzero_enum_TransactionTraceFile +using TransactionTraceFile_MagicNumber = perfetto_pbzero_enum_TransactionTraceFile::MagicNumber; + + +constexpr TransactionTraceFile_MagicNumber TransactionTraceFile_MagicNumber_MIN = TransactionTraceFile_MagicNumber::INVALID; +constexpr TransactionTraceFile_MagicNumber TransactionTraceFile_MagicNumber_MAX = TransactionTraceFile_MagicNumber::MAGIC_NUMBER_L; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* TransactionTraceFile_MagicNumber_Name(::perfetto::protos::pbzero::TransactionTraceFile_MagicNumber value) { + switch (value) { + case ::perfetto::protos::pbzero::TransactionTraceFile_MagicNumber::INVALID: + return "INVALID"; + + case ::perfetto::protos::pbzero::TransactionTraceFile_MagicNumber::MAGIC_NUMBER_L: + return "MAGIC_NUMBER_L"; + + case ::perfetto::protos::pbzero::TransactionTraceFile_MagicNumber::MAGIC_NUMBER_H: + return "MAGIC_NUMBER_H"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_LayersTraceFileProto { +enum MagicNumber : int32_t { + INVALID = 0, + MAGIC_NUMBER_L = 1414682956, + MAGIC_NUMBER_H = 1162035538, +}; +} // namespace perfetto_pbzero_enum_LayersTraceFileProto +using LayersTraceFileProto_MagicNumber = perfetto_pbzero_enum_LayersTraceFileProto::MagicNumber; + + +constexpr LayersTraceFileProto_MagicNumber LayersTraceFileProto_MagicNumber_MIN = LayersTraceFileProto_MagicNumber::INVALID; +constexpr LayersTraceFileProto_MagicNumber LayersTraceFileProto_MagicNumber_MAX = LayersTraceFileProto_MagicNumber::MAGIC_NUMBER_L; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* LayersTraceFileProto_MagicNumber_Name(::perfetto::protos::pbzero::LayersTraceFileProto_MagicNumber value) { + switch (value) { + case ::perfetto::protos::pbzero::LayersTraceFileProto_MagicNumber::INVALID: + return "INVALID"; + + case ::perfetto::protos::pbzero::LayersTraceFileProto_MagicNumber::MAGIC_NUMBER_L: + return "MAGIC_NUMBER_L"; + + case ::perfetto::protos::pbzero::LayersTraceFileProto_MagicNumber::MAGIC_NUMBER_H: + return "MAGIC_NUMBER_H"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_GraphicsFrameEvent { +enum BufferEventType : int32_t { + UNSPECIFIED = 0, + DEQUEUE = 1, + QUEUE = 2, + POST = 3, + ACQUIRE_FENCE = 4, + LATCH = 5, + HWC_COMPOSITION_QUEUED = 6, + FALLBACK_COMPOSITION = 7, + PRESENT_FENCE = 8, + RELEASE_FENCE = 9, + MODIFY = 10, + DETACH = 11, + ATTACH = 12, + CANCEL = 13, +}; +} // namespace perfetto_pbzero_enum_GraphicsFrameEvent +using GraphicsFrameEvent_BufferEventType = perfetto_pbzero_enum_GraphicsFrameEvent::BufferEventType; + + +constexpr GraphicsFrameEvent_BufferEventType GraphicsFrameEvent_BufferEventType_MIN = GraphicsFrameEvent_BufferEventType::UNSPECIFIED; +constexpr GraphicsFrameEvent_BufferEventType GraphicsFrameEvent_BufferEventType_MAX = GraphicsFrameEvent_BufferEventType::CANCEL; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* GraphicsFrameEvent_BufferEventType_Name(::perfetto::protos::pbzero::GraphicsFrameEvent_BufferEventType value) { + switch (value) { + case ::perfetto::protos::pbzero::GraphicsFrameEvent_BufferEventType::UNSPECIFIED: + return "UNSPECIFIED"; + + case ::perfetto::protos::pbzero::GraphicsFrameEvent_BufferEventType::DEQUEUE: + return "DEQUEUE"; + + case ::perfetto::protos::pbzero::GraphicsFrameEvent_BufferEventType::QUEUE: + return "QUEUE"; + + case ::perfetto::protos::pbzero::GraphicsFrameEvent_BufferEventType::POST: + return "POST"; + + case ::perfetto::protos::pbzero::GraphicsFrameEvent_BufferEventType::ACQUIRE_FENCE: + return "ACQUIRE_FENCE"; + + case ::perfetto::protos::pbzero::GraphicsFrameEvent_BufferEventType::LATCH: + return "LATCH"; + + case ::perfetto::protos::pbzero::GraphicsFrameEvent_BufferEventType::HWC_COMPOSITION_QUEUED: + return "HWC_COMPOSITION_QUEUED"; + + case ::perfetto::protos::pbzero::GraphicsFrameEvent_BufferEventType::FALLBACK_COMPOSITION: + return "FALLBACK_COMPOSITION"; + + case ::perfetto::protos::pbzero::GraphicsFrameEvent_BufferEventType::PRESENT_FENCE: + return "PRESENT_FENCE"; + + case ::perfetto::protos::pbzero::GraphicsFrameEvent_BufferEventType::RELEASE_FENCE: + return "RELEASE_FENCE"; + + case ::perfetto::protos::pbzero::GraphicsFrameEvent_BufferEventType::MODIFY: + return "MODIFY"; + + case ::perfetto::protos::pbzero::GraphicsFrameEvent_BufferEventType::DETACH: + return "DETACH"; + + case ::perfetto::protos::pbzero::GraphicsFrameEvent_BufferEventType::ATTACH: + return "ATTACH"; + + case ::perfetto::protos::pbzero::GraphicsFrameEvent_BufferEventType::CANCEL: + return "CANCEL"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_FrameTimelineEvent { +enum JankType : int32_t { + JANK_UNSPECIFIED = 0, + JANK_NONE = 1, + JANK_SF_SCHEDULING = 2, + JANK_PREDICTION_ERROR = 4, + JANK_DISPLAY_HAL = 8, + JANK_SF_CPU_DEADLINE_MISSED = 16, + JANK_SF_GPU_DEADLINE_MISSED = 32, + JANK_APP_DEADLINE_MISSED = 64, + JANK_BUFFER_STUFFING = 128, + JANK_UNKNOWN = 256, + JANK_SF_STUFFING = 512, + JANK_DROPPED = 1024, +}; +} // namespace perfetto_pbzero_enum_FrameTimelineEvent +using FrameTimelineEvent_JankType = perfetto_pbzero_enum_FrameTimelineEvent::JankType; + + +constexpr FrameTimelineEvent_JankType FrameTimelineEvent_JankType_MIN = FrameTimelineEvent_JankType::JANK_UNSPECIFIED; +constexpr FrameTimelineEvent_JankType FrameTimelineEvent_JankType_MAX = FrameTimelineEvent_JankType::JANK_DROPPED; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* FrameTimelineEvent_JankType_Name(::perfetto::protos::pbzero::FrameTimelineEvent_JankType value) { + switch (value) { + case ::perfetto::protos::pbzero::FrameTimelineEvent_JankType::JANK_UNSPECIFIED: + return "JANK_UNSPECIFIED"; + + case ::perfetto::protos::pbzero::FrameTimelineEvent_JankType::JANK_NONE: + return "JANK_NONE"; + + case ::perfetto::protos::pbzero::FrameTimelineEvent_JankType::JANK_SF_SCHEDULING: + return "JANK_SF_SCHEDULING"; + + case ::perfetto::protos::pbzero::FrameTimelineEvent_JankType::JANK_PREDICTION_ERROR: + return "JANK_PREDICTION_ERROR"; + + case ::perfetto::protos::pbzero::FrameTimelineEvent_JankType::JANK_DISPLAY_HAL: + return "JANK_DISPLAY_HAL"; + + case ::perfetto::protos::pbzero::FrameTimelineEvent_JankType::JANK_SF_CPU_DEADLINE_MISSED: + return "JANK_SF_CPU_DEADLINE_MISSED"; + + case ::perfetto::protos::pbzero::FrameTimelineEvent_JankType::JANK_SF_GPU_DEADLINE_MISSED: + return "JANK_SF_GPU_DEADLINE_MISSED"; + + case ::perfetto::protos::pbzero::FrameTimelineEvent_JankType::JANK_APP_DEADLINE_MISSED: + return "JANK_APP_DEADLINE_MISSED"; + + case ::perfetto::protos::pbzero::FrameTimelineEvent_JankType::JANK_BUFFER_STUFFING: + return "JANK_BUFFER_STUFFING"; + + case ::perfetto::protos::pbzero::FrameTimelineEvent_JankType::JANK_UNKNOWN: + return "JANK_UNKNOWN"; + + case ::perfetto::protos::pbzero::FrameTimelineEvent_JankType::JANK_SF_STUFFING: + return "JANK_SF_STUFFING"; + + case ::perfetto::protos::pbzero::FrameTimelineEvent_JankType::JANK_DROPPED: + return "JANK_DROPPED"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_FrameTimelineEvent { +enum JankSeverityType : int32_t { + SEVERITY_UNKNOWN = 0, + SEVERITY_NONE = 1, + SEVERITY_PARTIAL = 2, + SEVERITY_FULL = 3, +}; +} // namespace perfetto_pbzero_enum_FrameTimelineEvent +using FrameTimelineEvent_JankSeverityType = perfetto_pbzero_enum_FrameTimelineEvent::JankSeverityType; + + +constexpr FrameTimelineEvent_JankSeverityType FrameTimelineEvent_JankSeverityType_MIN = FrameTimelineEvent_JankSeverityType::SEVERITY_UNKNOWN; +constexpr FrameTimelineEvent_JankSeverityType FrameTimelineEvent_JankSeverityType_MAX = FrameTimelineEvent_JankSeverityType::SEVERITY_FULL; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* FrameTimelineEvent_JankSeverityType_Name(::perfetto::protos::pbzero::FrameTimelineEvent_JankSeverityType value) { + switch (value) { + case ::perfetto::protos::pbzero::FrameTimelineEvent_JankSeverityType::SEVERITY_UNKNOWN: + return "SEVERITY_UNKNOWN"; + + case ::perfetto::protos::pbzero::FrameTimelineEvent_JankSeverityType::SEVERITY_NONE: + return "SEVERITY_NONE"; + + case ::perfetto::protos::pbzero::FrameTimelineEvent_JankSeverityType::SEVERITY_PARTIAL: + return "SEVERITY_PARTIAL"; + + case ::perfetto::protos::pbzero::FrameTimelineEvent_JankSeverityType::SEVERITY_FULL: + return "SEVERITY_FULL"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_FrameTimelineEvent { +enum PresentType : int32_t { + PRESENT_UNSPECIFIED = 0, + PRESENT_ON_TIME = 1, + PRESENT_LATE = 2, + PRESENT_EARLY = 3, + PRESENT_DROPPED = 4, + PRESENT_UNKNOWN = 5, +}; +} // namespace perfetto_pbzero_enum_FrameTimelineEvent +using FrameTimelineEvent_PresentType = perfetto_pbzero_enum_FrameTimelineEvent::PresentType; + + +constexpr FrameTimelineEvent_PresentType FrameTimelineEvent_PresentType_MIN = FrameTimelineEvent_PresentType::PRESENT_UNSPECIFIED; +constexpr FrameTimelineEvent_PresentType FrameTimelineEvent_PresentType_MAX = FrameTimelineEvent_PresentType::PRESENT_UNKNOWN; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* FrameTimelineEvent_PresentType_Name(::perfetto::protos::pbzero::FrameTimelineEvent_PresentType value) { + switch (value) { + case ::perfetto::protos::pbzero::FrameTimelineEvent_PresentType::PRESENT_UNSPECIFIED: + return "PRESENT_UNSPECIFIED"; + + case ::perfetto::protos::pbzero::FrameTimelineEvent_PresentType::PRESENT_ON_TIME: + return "PRESENT_ON_TIME"; + + case ::perfetto::protos::pbzero::FrameTimelineEvent_PresentType::PRESENT_LATE: + return "PRESENT_LATE"; + + case ::perfetto::protos::pbzero::FrameTimelineEvent_PresentType::PRESENT_EARLY: + return "PRESENT_EARLY"; + + case ::perfetto::protos::pbzero::FrameTimelineEvent_PresentType::PRESENT_DROPPED: + return "PRESENT_DROPPED"; + + case ::perfetto::protos::pbzero::FrameTimelineEvent_PresentType::PRESENT_UNKNOWN: + return "PRESENT_UNKNOWN"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_FrameTimelineEvent { +enum PredictionType : int32_t { + PREDICTION_UNSPECIFIED = 0, + PREDICTION_VALID = 1, + PREDICTION_EXPIRED = 2, + PREDICTION_UNKNOWN = 3, +}; +} // namespace perfetto_pbzero_enum_FrameTimelineEvent +using FrameTimelineEvent_PredictionType = perfetto_pbzero_enum_FrameTimelineEvent::PredictionType; + + +constexpr FrameTimelineEvent_PredictionType FrameTimelineEvent_PredictionType_MIN = FrameTimelineEvent_PredictionType::PREDICTION_UNSPECIFIED; +constexpr FrameTimelineEvent_PredictionType FrameTimelineEvent_PredictionType_MAX = FrameTimelineEvent_PredictionType::PREDICTION_UNKNOWN; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* FrameTimelineEvent_PredictionType_Name(::perfetto::protos::pbzero::FrameTimelineEvent_PredictionType value) { + switch (value) { + case ::perfetto::protos::pbzero::FrameTimelineEvent_PredictionType::PREDICTION_UNSPECIFIED: + return "PREDICTION_UNSPECIFIED"; + + case ::perfetto::protos::pbzero::FrameTimelineEvent_PredictionType::PREDICTION_VALID: + return "PREDICTION_VALID"; + + case ::perfetto::protos::pbzero::FrameTimelineEvent_PredictionType::PREDICTION_EXPIRED: + return "PREDICTION_EXPIRED"; + + case ::perfetto::protos::pbzero::FrameTimelineEvent_PredictionType::PREDICTION_UNKNOWN: + return "PREDICTION_UNKNOWN"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_AndroidCameraFrameEvent { +enum CaptureResultStatus : int32_t { + STATUS_UNSPECIFIED = 0, + STATUS_OK = 1, + STATUS_EARLY_METADATA_ERROR = 2, + STATUS_FINAL_METADATA_ERROR = 3, + STATUS_BUFFER_ERROR = 4, + STATUS_FLUSH_ERROR = 5, +}; +} // namespace perfetto_pbzero_enum_AndroidCameraFrameEvent +using AndroidCameraFrameEvent_CaptureResultStatus = perfetto_pbzero_enum_AndroidCameraFrameEvent::CaptureResultStatus; + + +constexpr AndroidCameraFrameEvent_CaptureResultStatus AndroidCameraFrameEvent_CaptureResultStatus_MIN = AndroidCameraFrameEvent_CaptureResultStatus::STATUS_UNSPECIFIED; +constexpr AndroidCameraFrameEvent_CaptureResultStatus AndroidCameraFrameEvent_CaptureResultStatus_MAX = AndroidCameraFrameEvent_CaptureResultStatus::STATUS_FLUSH_ERROR; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* AndroidCameraFrameEvent_CaptureResultStatus_Name(::perfetto::protos::pbzero::AndroidCameraFrameEvent_CaptureResultStatus value) { + switch (value) { + case ::perfetto::protos::pbzero::AndroidCameraFrameEvent_CaptureResultStatus::STATUS_UNSPECIFIED: + return "STATUS_UNSPECIFIED"; + + case ::perfetto::protos::pbzero::AndroidCameraFrameEvent_CaptureResultStatus::STATUS_OK: + return "STATUS_OK"; + + case ::perfetto::protos::pbzero::AndroidCameraFrameEvent_CaptureResultStatus::STATUS_EARLY_METADATA_ERROR: + return "STATUS_EARLY_METADATA_ERROR"; + + case ::perfetto::protos::pbzero::AndroidCameraFrameEvent_CaptureResultStatus::STATUS_FINAL_METADATA_ERROR: + return "STATUS_FINAL_METADATA_ERROR"; + + case ::perfetto::protos::pbzero::AndroidCameraFrameEvent_CaptureResultStatus::STATUS_BUFFER_ERROR: + return "STATUS_BUFFER_ERROR"; + + case ::perfetto::protos::pbzero::AndroidCameraFrameEvent_CaptureResultStatus::STATUS_FLUSH_ERROR: + return "STATUS_FLUSH_ERROR"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_TraceStats { +enum FinalFlushOutcome : int32_t { + FINAL_FLUSH_UNSPECIFIED = 0, + FINAL_FLUSH_SUCCEEDED = 1, + FINAL_FLUSH_FAILED = 2, +}; +} // namespace perfetto_pbzero_enum_TraceStats +using TraceStats_FinalFlushOutcome = perfetto_pbzero_enum_TraceStats::FinalFlushOutcome; + + +constexpr TraceStats_FinalFlushOutcome TraceStats_FinalFlushOutcome_MIN = TraceStats_FinalFlushOutcome::FINAL_FLUSH_UNSPECIFIED; +constexpr TraceStats_FinalFlushOutcome TraceStats_FinalFlushOutcome_MAX = TraceStats_FinalFlushOutcome::FINAL_FLUSH_FAILED; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* TraceStats_FinalFlushOutcome_Name(::perfetto::protos::pbzero::TraceStats_FinalFlushOutcome value) { + switch (value) { + case ::perfetto::protos::pbzero::TraceStats_FinalFlushOutcome::FINAL_FLUSH_UNSPECIFIED: + return "FINAL_FLUSH_UNSPECIFIED"; + + case ::perfetto::protos::pbzero::TraceStats_FinalFlushOutcome::FINAL_FLUSH_SUCCEEDED: + return "FINAL_FLUSH_SUCCEEDED"; + + case ::perfetto::protos::pbzero::TraceStats_FinalFlushOutcome::FINAL_FLUSH_FAILED: + return "FINAL_FLUSH_FAILED"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_TraceConfig { +enum LockdownModeOperation : int32_t { + LOCKDOWN_UNCHANGED = 0, + LOCKDOWN_CLEAR = 1, + LOCKDOWN_SET = 2, +}; +} // namespace perfetto_pbzero_enum_TraceConfig +using TraceConfig_LockdownModeOperation = perfetto_pbzero_enum_TraceConfig::LockdownModeOperation; + + +constexpr TraceConfig_LockdownModeOperation TraceConfig_LockdownModeOperation_MIN = TraceConfig_LockdownModeOperation::LOCKDOWN_UNCHANGED; +constexpr TraceConfig_LockdownModeOperation TraceConfig_LockdownModeOperation_MAX = TraceConfig_LockdownModeOperation::LOCKDOWN_SET; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* TraceConfig_LockdownModeOperation_Name(::perfetto::protos::pbzero::TraceConfig_LockdownModeOperation value) { + switch (value) { + case ::perfetto::protos::pbzero::TraceConfig_LockdownModeOperation::LOCKDOWN_UNCHANGED: + return "LOCKDOWN_UNCHANGED"; + + case ::perfetto::protos::pbzero::TraceConfig_LockdownModeOperation::LOCKDOWN_CLEAR: + return "LOCKDOWN_CLEAR"; + + case ::perfetto::protos::pbzero::TraceConfig_LockdownModeOperation::LOCKDOWN_SET: + return "LOCKDOWN_SET"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_TraceConfig { +enum CompressionType : int32_t { + COMPRESSION_TYPE_UNSPECIFIED = 0, + COMPRESSION_TYPE_DEFLATE = 1, +}; +} // namespace perfetto_pbzero_enum_TraceConfig +using TraceConfig_CompressionType = perfetto_pbzero_enum_TraceConfig::CompressionType; + + +constexpr TraceConfig_CompressionType TraceConfig_CompressionType_MIN = TraceConfig_CompressionType::COMPRESSION_TYPE_UNSPECIFIED; +constexpr TraceConfig_CompressionType TraceConfig_CompressionType_MAX = TraceConfig_CompressionType::COMPRESSION_TYPE_DEFLATE; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* TraceConfig_CompressionType_Name(::perfetto::protos::pbzero::TraceConfig_CompressionType value) { + switch (value) { + case ::perfetto::protos::pbzero::TraceConfig_CompressionType::COMPRESSION_TYPE_UNSPECIFIED: + return "COMPRESSION_TYPE_UNSPECIFIED"; + + case ::perfetto::protos::pbzero::TraceConfig_CompressionType::COMPRESSION_TYPE_DEFLATE: + return "COMPRESSION_TYPE_DEFLATE"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_TraceConfig { +enum StatsdLogging : int32_t { + STATSD_LOGGING_UNSPECIFIED = 0, + STATSD_LOGGING_ENABLED = 1, + STATSD_LOGGING_DISABLED = 2, +}; +} // namespace perfetto_pbzero_enum_TraceConfig +using TraceConfig_StatsdLogging = perfetto_pbzero_enum_TraceConfig::StatsdLogging; + + +constexpr TraceConfig_StatsdLogging TraceConfig_StatsdLogging_MIN = TraceConfig_StatsdLogging::STATSD_LOGGING_UNSPECIFIED; +constexpr TraceConfig_StatsdLogging TraceConfig_StatsdLogging_MAX = TraceConfig_StatsdLogging::STATSD_LOGGING_DISABLED; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* TraceConfig_StatsdLogging_Name(::perfetto::protos::pbzero::TraceConfig_StatsdLogging value) { + switch (value) { + case ::perfetto::protos::pbzero::TraceConfig_StatsdLogging::STATSD_LOGGING_UNSPECIFIED: + return "STATSD_LOGGING_UNSPECIFIED"; + + case ::perfetto::protos::pbzero::TraceConfig_StatsdLogging::STATSD_LOGGING_ENABLED: + return "STATSD_LOGGING_ENABLED"; + + case ::perfetto::protos::pbzero::TraceConfig_StatsdLogging::STATSD_LOGGING_DISABLED: + return "STATSD_LOGGING_DISABLED"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_TraceConfig_TraceFilter { +enum StringFilterPolicy : int32_t { + SFP_UNSPECIFIED = 0, + SFP_MATCH_REDACT_GROUPS = 1, + SFP_ATRACE_MATCH_REDACT_GROUPS = 2, + SFP_MATCH_BREAK = 3, + SFP_ATRACE_MATCH_BREAK = 4, + SFP_ATRACE_REPEATED_SEARCH_REDACT_GROUPS = 5, +}; +} // namespace perfetto_pbzero_enum_TraceConfig_TraceFilter +using TraceConfig_TraceFilter_StringFilterPolicy = perfetto_pbzero_enum_TraceConfig_TraceFilter::StringFilterPolicy; + + +constexpr TraceConfig_TraceFilter_StringFilterPolicy TraceConfig_TraceFilter_StringFilterPolicy_MIN = TraceConfig_TraceFilter_StringFilterPolicy::SFP_UNSPECIFIED; +constexpr TraceConfig_TraceFilter_StringFilterPolicy TraceConfig_TraceFilter_StringFilterPolicy_MAX = TraceConfig_TraceFilter_StringFilterPolicy::SFP_ATRACE_REPEATED_SEARCH_REDACT_GROUPS; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* TraceConfig_TraceFilter_StringFilterPolicy_Name(::perfetto::protos::pbzero::TraceConfig_TraceFilter_StringFilterPolicy value) { + switch (value) { + case ::perfetto::protos::pbzero::TraceConfig_TraceFilter_StringFilterPolicy::SFP_UNSPECIFIED: + return "SFP_UNSPECIFIED"; + + case ::perfetto::protos::pbzero::TraceConfig_TraceFilter_StringFilterPolicy::SFP_MATCH_REDACT_GROUPS: + return "SFP_MATCH_REDACT_GROUPS"; + + case ::perfetto::protos::pbzero::TraceConfig_TraceFilter_StringFilterPolicy::SFP_ATRACE_MATCH_REDACT_GROUPS: + return "SFP_ATRACE_MATCH_REDACT_GROUPS"; + + case ::perfetto::protos::pbzero::TraceConfig_TraceFilter_StringFilterPolicy::SFP_MATCH_BREAK: + return "SFP_MATCH_BREAK"; + + case ::perfetto::protos::pbzero::TraceConfig_TraceFilter_StringFilterPolicy::SFP_ATRACE_MATCH_BREAK: + return "SFP_ATRACE_MATCH_BREAK"; + + case ::perfetto::protos::pbzero::TraceConfig_TraceFilter_StringFilterPolicy::SFP_ATRACE_REPEATED_SEARCH_REDACT_GROUPS: + return "SFP_ATRACE_REPEATED_SEARCH_REDACT_GROUPS"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_TraceConfig_TriggerConfig { +enum TriggerMode : int32_t { + UNSPECIFIED = 0, + START_TRACING = 1, + STOP_TRACING = 2, + CLONE_SNAPSHOT = 4, +}; +} // namespace perfetto_pbzero_enum_TraceConfig_TriggerConfig +using TraceConfig_TriggerConfig_TriggerMode = perfetto_pbzero_enum_TraceConfig_TriggerConfig::TriggerMode; + + +constexpr TraceConfig_TriggerConfig_TriggerMode TraceConfig_TriggerConfig_TriggerMode_MIN = TraceConfig_TriggerConfig_TriggerMode::UNSPECIFIED; +constexpr TraceConfig_TriggerConfig_TriggerMode TraceConfig_TriggerConfig_TriggerMode_MAX = TraceConfig_TriggerConfig_TriggerMode::CLONE_SNAPSHOT; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* TraceConfig_TriggerConfig_TriggerMode_Name(::perfetto::protos::pbzero::TraceConfig_TriggerConfig_TriggerMode value) { + switch (value) { + case ::perfetto::protos::pbzero::TraceConfig_TriggerConfig_TriggerMode::UNSPECIFIED: + return "UNSPECIFIED"; + + case ::perfetto::protos::pbzero::TraceConfig_TriggerConfig_TriggerMode::START_TRACING: + return "START_TRACING"; + + case ::perfetto::protos::pbzero::TraceConfig_TriggerConfig_TriggerMode::STOP_TRACING: + return "STOP_TRACING"; + + case ::perfetto::protos::pbzero::TraceConfig_TriggerConfig_TriggerMode::CLONE_SNAPSHOT: + return "CLONE_SNAPSHOT"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_TraceConfig_BufferConfig { +enum FillPolicy : int32_t { + UNSPECIFIED = 0, + RING_BUFFER = 1, + DISCARD = 2, +}; +} // namespace perfetto_pbzero_enum_TraceConfig_BufferConfig +using TraceConfig_BufferConfig_FillPolicy = perfetto_pbzero_enum_TraceConfig_BufferConfig::FillPolicy; + + +constexpr TraceConfig_BufferConfig_FillPolicy TraceConfig_BufferConfig_FillPolicy_MIN = TraceConfig_BufferConfig_FillPolicy::UNSPECIFIED; +constexpr TraceConfig_BufferConfig_FillPolicy TraceConfig_BufferConfig_FillPolicy_MAX = TraceConfig_BufferConfig_FillPolicy::DISCARD; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* TraceConfig_BufferConfig_FillPolicy_Name(::perfetto::protos::pbzero::TraceConfig_BufferConfig_FillPolicy value) { + switch (value) { + case ::perfetto::protos::pbzero::TraceConfig_BufferConfig_FillPolicy::UNSPECIFIED: + return "UNSPECIFIED"; + + case ::perfetto::protos::pbzero::TraceConfig_BufferConfig_FillPolicy::RING_BUFFER: + return "RING_BUFFER"; + + case ::perfetto::protos::pbzero::TraceConfig_BufferConfig_FillPolicy::DISCARD: + return "DISCARD"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_DataSourceConfig { +enum SessionInitiator : int32_t { + SESSION_INITIATOR_UNSPECIFIED = 0, + SESSION_INITIATOR_TRUSTED_SYSTEM = 1, +}; +} // namespace perfetto_pbzero_enum_DataSourceConfig +using DataSourceConfig_SessionInitiator = perfetto_pbzero_enum_DataSourceConfig::SessionInitiator; + + +constexpr DataSourceConfig_SessionInitiator DataSourceConfig_SessionInitiator_MIN = DataSourceConfig_SessionInitiator::SESSION_INITIATOR_UNSPECIFIED; +constexpr DataSourceConfig_SessionInitiator DataSourceConfig_SessionInitiator_MAX = DataSourceConfig_SessionInitiator::SESSION_INITIATOR_TRUSTED_SYSTEM; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* DataSourceConfig_SessionInitiator_Name(::perfetto::protos::pbzero::DataSourceConfig_SessionInitiator value) { + switch (value) { + case ::perfetto::protos::pbzero::DataSourceConfig_SessionInitiator::SESSION_INITIATOR_UNSPECIFIED: + return "SESSION_INITIATOR_UNSPECIFIED"; + + case ::perfetto::protos::pbzero::DataSourceConfig_SessionInitiator::SESSION_INITIATOR_TRUSTED_SYSTEM: + return "SESSION_INITIATOR_TRUSTED_SYSTEM"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_SysStatsConfig { +enum StatCounters : int32_t { + STAT_UNSPECIFIED = 0, + STAT_CPU_TIMES = 1, + STAT_IRQ_COUNTS = 2, + STAT_SOFTIRQ_COUNTS = 3, + STAT_FORK_COUNT = 4, +}; +} // namespace perfetto_pbzero_enum_SysStatsConfig +using SysStatsConfig_StatCounters = perfetto_pbzero_enum_SysStatsConfig::StatCounters; + + +constexpr SysStatsConfig_StatCounters SysStatsConfig_StatCounters_MIN = SysStatsConfig_StatCounters::STAT_UNSPECIFIED; +constexpr SysStatsConfig_StatCounters SysStatsConfig_StatCounters_MAX = SysStatsConfig_StatCounters::STAT_FORK_COUNT; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* SysStatsConfig_StatCounters_Name(::perfetto::protos::pbzero::SysStatsConfig_StatCounters value) { + switch (value) { + case ::perfetto::protos::pbzero::SysStatsConfig_StatCounters::STAT_UNSPECIFIED: + return "STAT_UNSPECIFIED"; + + case ::perfetto::protos::pbzero::SysStatsConfig_StatCounters::STAT_CPU_TIMES: + return "STAT_CPU_TIMES"; + + case ::perfetto::protos::pbzero::SysStatsConfig_StatCounters::STAT_IRQ_COUNTS: + return "STAT_IRQ_COUNTS"; + + case ::perfetto::protos::pbzero::SysStatsConfig_StatCounters::STAT_SOFTIRQ_COUNTS: + return "STAT_SOFTIRQ_COUNTS"; + + case ::perfetto::protos::pbzero::SysStatsConfig_StatCounters::STAT_FORK_COUNT: + return "STAT_FORK_COUNT"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_PerfEventConfig { +enum UnwindMode : int32_t { + UNWIND_UNKNOWN = 0, + UNWIND_SKIP = 1, + UNWIND_DWARF = 2, +}; +} // namespace perfetto_pbzero_enum_PerfEventConfig +using PerfEventConfig_UnwindMode = perfetto_pbzero_enum_PerfEventConfig::UnwindMode; + + +constexpr PerfEventConfig_UnwindMode PerfEventConfig_UnwindMode_MIN = PerfEventConfig_UnwindMode::UNWIND_UNKNOWN; +constexpr PerfEventConfig_UnwindMode PerfEventConfig_UnwindMode_MAX = PerfEventConfig_UnwindMode::UNWIND_DWARF; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* PerfEventConfig_UnwindMode_Name(::perfetto::protos::pbzero::PerfEventConfig_UnwindMode value) { + switch (value) { + case ::perfetto::protos::pbzero::PerfEventConfig_UnwindMode::UNWIND_UNKNOWN: + return "UNWIND_UNKNOWN"; + + case ::perfetto::protos::pbzero::PerfEventConfig_UnwindMode::UNWIND_SKIP: + return "UNWIND_SKIP"; + + case ::perfetto::protos::pbzero::PerfEventConfig_UnwindMode::UNWIND_DWARF: + return "UNWIND_DWARF"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_PerfEvents { +enum Counter : int32_t { + UNKNOWN_COUNTER = 0, + SW_CPU_CLOCK = 1, + SW_PAGE_FAULTS = 2, + SW_TASK_CLOCK = 3, + SW_CONTEXT_SWITCHES = 4, + SW_CPU_MIGRATIONS = 5, + SW_PAGE_FAULTS_MIN = 6, + SW_PAGE_FAULTS_MAJ = 7, + SW_ALIGNMENT_FAULTS = 8, + SW_EMULATION_FAULTS = 9, + SW_DUMMY = 20, + HW_CPU_CYCLES = 10, + HW_INSTRUCTIONS = 11, + HW_CACHE_REFERENCES = 12, + HW_CACHE_MISSES = 13, + HW_BRANCH_INSTRUCTIONS = 14, + HW_BRANCH_MISSES = 15, + HW_BUS_CYCLES = 16, + HW_STALLED_CYCLES_FRONTEND = 17, + HW_STALLED_CYCLES_BACKEND = 18, + HW_REF_CPU_CYCLES = 19, +}; +} // namespace perfetto_pbzero_enum_PerfEvents +using PerfEvents_Counter = perfetto_pbzero_enum_PerfEvents::Counter; + + +constexpr PerfEvents_Counter PerfEvents_Counter_MIN = PerfEvents_Counter::UNKNOWN_COUNTER; +constexpr PerfEvents_Counter PerfEvents_Counter_MAX = PerfEvents_Counter::SW_DUMMY; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* PerfEvents_Counter_Name(::perfetto::protos::pbzero::PerfEvents_Counter value) { + switch (value) { + case ::perfetto::protos::pbzero::PerfEvents_Counter::UNKNOWN_COUNTER: + return "UNKNOWN_COUNTER"; + + case ::perfetto::protos::pbzero::PerfEvents_Counter::SW_CPU_CLOCK: + return "SW_CPU_CLOCK"; + + case ::perfetto::protos::pbzero::PerfEvents_Counter::SW_PAGE_FAULTS: + return "SW_PAGE_FAULTS"; + + case ::perfetto::protos::pbzero::PerfEvents_Counter::SW_TASK_CLOCK: + return "SW_TASK_CLOCK"; + + case ::perfetto::protos::pbzero::PerfEvents_Counter::SW_CONTEXT_SWITCHES: + return "SW_CONTEXT_SWITCHES"; + + case ::perfetto::protos::pbzero::PerfEvents_Counter::SW_CPU_MIGRATIONS: + return "SW_CPU_MIGRATIONS"; + + case ::perfetto::protos::pbzero::PerfEvents_Counter::SW_PAGE_FAULTS_MIN: + return "SW_PAGE_FAULTS_MIN"; + + case ::perfetto::protos::pbzero::PerfEvents_Counter::SW_PAGE_FAULTS_MAJ: + return "SW_PAGE_FAULTS_MAJ"; + + case ::perfetto::protos::pbzero::PerfEvents_Counter::SW_ALIGNMENT_FAULTS: + return "SW_ALIGNMENT_FAULTS"; + + case ::perfetto::protos::pbzero::PerfEvents_Counter::SW_EMULATION_FAULTS: + return "SW_EMULATION_FAULTS"; + + case ::perfetto::protos::pbzero::PerfEvents_Counter::SW_DUMMY: + return "SW_DUMMY"; + + case ::perfetto::protos::pbzero::PerfEvents_Counter::HW_CPU_CYCLES: + return "HW_CPU_CYCLES"; + + case ::perfetto::protos::pbzero::PerfEvents_Counter::HW_INSTRUCTIONS: + return "HW_INSTRUCTIONS"; + + case ::perfetto::protos::pbzero::PerfEvents_Counter::HW_CACHE_REFERENCES: + return "HW_CACHE_REFERENCES"; + + case ::perfetto::protos::pbzero::PerfEvents_Counter::HW_CACHE_MISSES: + return "HW_CACHE_MISSES"; + + case ::perfetto::protos::pbzero::PerfEvents_Counter::HW_BRANCH_INSTRUCTIONS: + return "HW_BRANCH_INSTRUCTIONS"; + + case ::perfetto::protos::pbzero::PerfEvents_Counter::HW_BRANCH_MISSES: + return "HW_BRANCH_MISSES"; + + case ::perfetto::protos::pbzero::PerfEvents_Counter::HW_BUS_CYCLES: + return "HW_BUS_CYCLES"; + + case ::perfetto::protos::pbzero::PerfEvents_Counter::HW_STALLED_CYCLES_FRONTEND: + return "HW_STALLED_CYCLES_FRONTEND"; + + case ::perfetto::protos::pbzero::PerfEvents_Counter::HW_STALLED_CYCLES_BACKEND: + return "HW_STALLED_CYCLES_BACKEND"; + + case ::perfetto::protos::pbzero::PerfEvents_Counter::HW_REF_CPU_CYCLES: + return "HW_REF_CPU_CYCLES"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_PerfEvents { +enum PerfClock : int32_t { + UNKNOWN_PERF_CLOCK = 0, + PERF_CLOCK_REALTIME = 1, + PERF_CLOCK_MONOTONIC = 2, + PERF_CLOCK_MONOTONIC_RAW = 3, + PERF_CLOCK_BOOTTIME = 4, +}; +} // namespace perfetto_pbzero_enum_PerfEvents +using PerfEvents_PerfClock = perfetto_pbzero_enum_PerfEvents::PerfClock; + + +constexpr PerfEvents_PerfClock PerfEvents_PerfClock_MIN = PerfEvents_PerfClock::UNKNOWN_PERF_CLOCK; +constexpr PerfEvents_PerfClock PerfEvents_PerfClock_MAX = PerfEvents_PerfClock::PERF_CLOCK_BOOTTIME; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* PerfEvents_PerfClock_Name(::perfetto::protos::pbzero::PerfEvents_PerfClock value) { + switch (value) { + case ::perfetto::protos::pbzero::PerfEvents_PerfClock::UNKNOWN_PERF_CLOCK: + return "UNKNOWN_PERF_CLOCK"; + + case ::perfetto::protos::pbzero::PerfEvents_PerfClock::PERF_CLOCK_REALTIME: + return "PERF_CLOCK_REALTIME"; + + case ::perfetto::protos::pbzero::PerfEvents_PerfClock::PERF_CLOCK_MONOTONIC: + return "PERF_CLOCK_MONOTONIC"; + + case ::perfetto::protos::pbzero::PerfEvents_PerfClock::PERF_CLOCK_MONOTONIC_RAW: + return "PERF_CLOCK_MONOTONIC_RAW"; + + case ::perfetto::protos::pbzero::PerfEvents_PerfClock::PERF_CLOCK_BOOTTIME: + return "PERF_CLOCK_BOOTTIME"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_ProcessStatsConfig { +enum Quirks : int32_t { + QUIRKS_UNSPECIFIED = 0, + DISABLE_INITIAL_DUMP = 1, + DISABLE_ON_DEMAND = 2, +}; +} // namespace perfetto_pbzero_enum_ProcessStatsConfig +using ProcessStatsConfig_Quirks = perfetto_pbzero_enum_ProcessStatsConfig::Quirks; + + +constexpr ProcessStatsConfig_Quirks ProcessStatsConfig_Quirks_MIN = ProcessStatsConfig_Quirks::QUIRKS_UNSPECIFIED; +constexpr ProcessStatsConfig_Quirks ProcessStatsConfig_Quirks_MAX = ProcessStatsConfig_Quirks::DISABLE_ON_DEMAND; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* ProcessStatsConfig_Quirks_Name(::perfetto::protos::pbzero::ProcessStatsConfig_Quirks value) { + switch (value) { + case ::perfetto::protos::pbzero::ProcessStatsConfig_Quirks::QUIRKS_UNSPECIFIED: + return "QUIRKS_UNSPECIFIED"; + + case ::perfetto::protos::pbzero::ProcessStatsConfig_Quirks::DISABLE_INITIAL_DUMP: + return "DISABLE_INITIAL_DUMP"; + + case ::perfetto::protos::pbzero::ProcessStatsConfig_Quirks::DISABLE_ON_DEMAND: + return "DISABLE_ON_DEMAND"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_AndroidPowerConfig { +enum BatteryCounters : int32_t { + BATTERY_COUNTER_UNSPECIFIED = 0, + BATTERY_COUNTER_CHARGE = 1, + BATTERY_COUNTER_CAPACITY_PERCENT = 2, + BATTERY_COUNTER_CURRENT = 3, + BATTERY_COUNTER_CURRENT_AVG = 4, + BATTERY_COUNTER_VOLTAGE = 5, +}; +} // namespace perfetto_pbzero_enum_AndroidPowerConfig +using AndroidPowerConfig_BatteryCounters = perfetto_pbzero_enum_AndroidPowerConfig::BatteryCounters; + + +constexpr AndroidPowerConfig_BatteryCounters AndroidPowerConfig_BatteryCounters_MIN = AndroidPowerConfig_BatteryCounters::BATTERY_COUNTER_UNSPECIFIED; +constexpr AndroidPowerConfig_BatteryCounters AndroidPowerConfig_BatteryCounters_MAX = AndroidPowerConfig_BatteryCounters::BATTERY_COUNTER_VOLTAGE; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* AndroidPowerConfig_BatteryCounters_Name(::perfetto::protos::pbzero::AndroidPowerConfig_BatteryCounters value) { + switch (value) { + case ::perfetto::protos::pbzero::AndroidPowerConfig_BatteryCounters::BATTERY_COUNTER_UNSPECIFIED: + return "BATTERY_COUNTER_UNSPECIFIED"; + + case ::perfetto::protos::pbzero::AndroidPowerConfig_BatteryCounters::BATTERY_COUNTER_CHARGE: + return "BATTERY_COUNTER_CHARGE"; + + case ::perfetto::protos::pbzero::AndroidPowerConfig_BatteryCounters::BATTERY_COUNTER_CAPACITY_PERCENT: + return "BATTERY_COUNTER_CAPACITY_PERCENT"; + + case ::perfetto::protos::pbzero::AndroidPowerConfig_BatteryCounters::BATTERY_COUNTER_CURRENT: + return "BATTERY_COUNTER_CURRENT"; + + case ::perfetto::protos::pbzero::AndroidPowerConfig_BatteryCounters::BATTERY_COUNTER_CURRENT_AVG: + return "BATTERY_COUNTER_CURRENT_AVG"; + + case ::perfetto::protos::pbzero::AndroidPowerConfig_BatteryCounters::BATTERY_COUNTER_VOLTAGE: + return "BATTERY_COUNTER_VOLTAGE"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_ConsoleConfig { +enum Output : int32_t { + OUTPUT_UNSPECIFIED = 0, + OUTPUT_STDOUT = 1, + OUTPUT_STDERR = 2, +}; +} // namespace perfetto_pbzero_enum_ConsoleConfig +using ConsoleConfig_Output = perfetto_pbzero_enum_ConsoleConfig::Output; + + +constexpr ConsoleConfig_Output ConsoleConfig_Output_MIN = ConsoleConfig_Output::OUTPUT_UNSPECIFIED; +constexpr ConsoleConfig_Output ConsoleConfig_Output_MAX = ConsoleConfig_Output::OUTPUT_STDERR; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* ConsoleConfig_Output_Name(::perfetto::protos::pbzero::ConsoleConfig_Output value) { + switch (value) { + case ::perfetto::protos::pbzero::ConsoleConfig_Output::OUTPUT_UNSPECIFIED: + return "OUTPUT_UNSPECIFIED"; + + case ::perfetto::protos::pbzero::ConsoleConfig_Output::OUTPUT_STDOUT: + return "OUTPUT_STDOUT"; + + case ::perfetto::protos::pbzero::ConsoleConfig_Output::OUTPUT_STDERR: + return "OUTPUT_STDERR"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_FtraceConfig { +enum KsymsMemPolicy : int32_t { + KSYMS_UNSPECIFIED = 0, + KSYMS_CLEANUP_ON_STOP = 1, + KSYMS_RETAIN = 2, +}; +} // namespace perfetto_pbzero_enum_FtraceConfig +using FtraceConfig_KsymsMemPolicy = perfetto_pbzero_enum_FtraceConfig::KsymsMemPolicy; + + +constexpr FtraceConfig_KsymsMemPolicy FtraceConfig_KsymsMemPolicy_MIN = FtraceConfig_KsymsMemPolicy::KSYMS_UNSPECIFIED; +constexpr FtraceConfig_KsymsMemPolicy FtraceConfig_KsymsMemPolicy_MAX = FtraceConfig_KsymsMemPolicy::KSYMS_RETAIN; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* FtraceConfig_KsymsMemPolicy_Name(::perfetto::protos::pbzero::FtraceConfig_KsymsMemPolicy value) { + switch (value) { + case ::perfetto::protos::pbzero::FtraceConfig_KsymsMemPolicy::KSYMS_UNSPECIFIED: + return "KSYMS_UNSPECIFIED"; + + case ::perfetto::protos::pbzero::FtraceConfig_KsymsMemPolicy::KSYMS_CLEANUP_ON_STOP: + return "KSYMS_CLEANUP_ON_STOP"; + + case ::perfetto::protos::pbzero::FtraceConfig_KsymsMemPolicy::KSYMS_RETAIN: + return "KSYMS_RETAIN"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_EtwConfig { +enum KernelFlag : int32_t { + CSWITCH = 0, + DISPATCHER = 1, +}; +} // namespace perfetto_pbzero_enum_EtwConfig +using EtwConfig_KernelFlag = perfetto_pbzero_enum_EtwConfig::KernelFlag; + + +constexpr EtwConfig_KernelFlag EtwConfig_KernelFlag_MIN = EtwConfig_KernelFlag::CSWITCH; +constexpr EtwConfig_KernelFlag EtwConfig_KernelFlag_MAX = EtwConfig_KernelFlag::DISPATCHER; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* EtwConfig_KernelFlag_Name(::perfetto::protos::pbzero::EtwConfig_KernelFlag value) { + switch (value) { + case ::perfetto::protos::pbzero::EtwConfig_KernelFlag::CSWITCH: + return "CSWITCH"; + + case ::perfetto::protos::pbzero::EtwConfig_KernelFlag::DISPATCHER: + return "DISPATCHER"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_ChromeConfig { +enum ClientPriority : int32_t { + UNKNOWN = 0, + BACKGROUND = 1, + USER_INITIATED = 2, +}; +} // namespace perfetto_pbzero_enum_ChromeConfig +using ChromeConfig_ClientPriority = perfetto_pbzero_enum_ChromeConfig::ClientPriority; + + +constexpr ChromeConfig_ClientPriority ChromeConfig_ClientPriority_MIN = ChromeConfig_ClientPriority::UNKNOWN; +constexpr ChromeConfig_ClientPriority ChromeConfig_ClientPriority_MAX = ChromeConfig_ClientPriority::USER_INITIATED; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* ChromeConfig_ClientPriority_Name(::perfetto::protos::pbzero::ChromeConfig_ClientPriority value) { + switch (value) { + case ::perfetto::protos::pbzero::ChromeConfig_ClientPriority::UNKNOWN: + return "UNKNOWN"; + + case ::perfetto::protos::pbzero::ChromeConfig_ClientPriority::BACKGROUND: + return "BACKGROUND"; + + case ::perfetto::protos::pbzero::ChromeConfig_ClientPriority::USER_INITIATED: + return "USER_INITIATED"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_SurfaceFlingerTransactionsConfig { +enum Mode : int32_t { + MODE_UNSPECIFIED = 0, + MODE_CONTINUOUS = 1, + MODE_ACTIVE = 2, +}; +} // namespace perfetto_pbzero_enum_SurfaceFlingerTransactionsConfig +using SurfaceFlingerTransactionsConfig_Mode = perfetto_pbzero_enum_SurfaceFlingerTransactionsConfig::Mode; + + +constexpr SurfaceFlingerTransactionsConfig_Mode SurfaceFlingerTransactionsConfig_Mode_MIN = SurfaceFlingerTransactionsConfig_Mode::MODE_UNSPECIFIED; +constexpr SurfaceFlingerTransactionsConfig_Mode SurfaceFlingerTransactionsConfig_Mode_MAX = SurfaceFlingerTransactionsConfig_Mode::MODE_ACTIVE; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* SurfaceFlingerTransactionsConfig_Mode_Name(::perfetto::protos::pbzero::SurfaceFlingerTransactionsConfig_Mode value) { + switch (value) { + case ::perfetto::protos::pbzero::SurfaceFlingerTransactionsConfig_Mode::MODE_UNSPECIFIED: + return "MODE_UNSPECIFIED"; + + case ::perfetto::protos::pbzero::SurfaceFlingerTransactionsConfig_Mode::MODE_CONTINUOUS: + return "MODE_CONTINUOUS"; + + case ::perfetto::protos::pbzero::SurfaceFlingerTransactionsConfig_Mode::MODE_ACTIVE: + return "MODE_ACTIVE"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_SurfaceFlingerLayersConfig { +enum Mode : int32_t { + MODE_UNSPECIFIED = 0, + MODE_ACTIVE = 1, + MODE_GENERATED = 2, + MODE_DUMP = 3, + MODE_GENERATED_BUGREPORT_ONLY = 4, +}; +} // namespace perfetto_pbzero_enum_SurfaceFlingerLayersConfig +using SurfaceFlingerLayersConfig_Mode = perfetto_pbzero_enum_SurfaceFlingerLayersConfig::Mode; + + +constexpr SurfaceFlingerLayersConfig_Mode SurfaceFlingerLayersConfig_Mode_MIN = SurfaceFlingerLayersConfig_Mode::MODE_UNSPECIFIED; +constexpr SurfaceFlingerLayersConfig_Mode SurfaceFlingerLayersConfig_Mode_MAX = SurfaceFlingerLayersConfig_Mode::MODE_GENERATED_BUGREPORT_ONLY; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* SurfaceFlingerLayersConfig_Mode_Name(::perfetto::protos::pbzero::SurfaceFlingerLayersConfig_Mode value) { + switch (value) { + case ::perfetto::protos::pbzero::SurfaceFlingerLayersConfig_Mode::MODE_UNSPECIFIED: + return "MODE_UNSPECIFIED"; + + case ::perfetto::protos::pbzero::SurfaceFlingerLayersConfig_Mode::MODE_ACTIVE: + return "MODE_ACTIVE"; + + case ::perfetto::protos::pbzero::SurfaceFlingerLayersConfig_Mode::MODE_GENERATED: + return "MODE_GENERATED"; + + case ::perfetto::protos::pbzero::SurfaceFlingerLayersConfig_Mode::MODE_DUMP: + return "MODE_DUMP"; + + case ::perfetto::protos::pbzero::SurfaceFlingerLayersConfig_Mode::MODE_GENERATED_BUGREPORT_ONLY: + return "MODE_GENERATED_BUGREPORT_ONLY"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_SurfaceFlingerLayersConfig { +enum TraceFlag : int32_t { + TRACE_FLAG_UNSPECIFIED = 0, + TRACE_FLAG_INPUT = 2, + TRACE_FLAG_COMPOSITION = 4, + TRACE_FLAG_EXTRA = 8, + TRACE_FLAG_HWC = 16, + TRACE_FLAG_BUFFERS = 32, + TRACE_FLAG_VIRTUAL_DISPLAYS = 64, + TRACE_FLAG_ALL = 14, +}; +} // namespace perfetto_pbzero_enum_SurfaceFlingerLayersConfig +using SurfaceFlingerLayersConfig_TraceFlag = perfetto_pbzero_enum_SurfaceFlingerLayersConfig::TraceFlag; + + +constexpr SurfaceFlingerLayersConfig_TraceFlag SurfaceFlingerLayersConfig_TraceFlag_MIN = SurfaceFlingerLayersConfig_TraceFlag::TRACE_FLAG_UNSPECIFIED; +constexpr SurfaceFlingerLayersConfig_TraceFlag SurfaceFlingerLayersConfig_TraceFlag_MAX = SurfaceFlingerLayersConfig_TraceFlag::TRACE_FLAG_VIRTUAL_DISPLAYS; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* SurfaceFlingerLayersConfig_TraceFlag_Name(::perfetto::protos::pbzero::SurfaceFlingerLayersConfig_TraceFlag value) { + switch (value) { + case ::perfetto::protos::pbzero::SurfaceFlingerLayersConfig_TraceFlag::TRACE_FLAG_UNSPECIFIED: + return "TRACE_FLAG_UNSPECIFIED"; + + case ::perfetto::protos::pbzero::SurfaceFlingerLayersConfig_TraceFlag::TRACE_FLAG_INPUT: + return "TRACE_FLAG_INPUT"; + + case ::perfetto::protos::pbzero::SurfaceFlingerLayersConfig_TraceFlag::TRACE_FLAG_COMPOSITION: + return "TRACE_FLAG_COMPOSITION"; + + case ::perfetto::protos::pbzero::SurfaceFlingerLayersConfig_TraceFlag::TRACE_FLAG_EXTRA: + return "TRACE_FLAG_EXTRA"; + + case ::perfetto::protos::pbzero::SurfaceFlingerLayersConfig_TraceFlag::TRACE_FLAG_HWC: + return "TRACE_FLAG_HWC"; + + case ::perfetto::protos::pbzero::SurfaceFlingerLayersConfig_TraceFlag::TRACE_FLAG_BUFFERS: + return "TRACE_FLAG_BUFFERS"; + + case ::perfetto::protos::pbzero::SurfaceFlingerLayersConfig_TraceFlag::TRACE_FLAG_VIRTUAL_DISPLAYS: + return "TRACE_FLAG_VIRTUAL_DISPLAYS"; + + case ::perfetto::protos::pbzero::SurfaceFlingerLayersConfig_TraceFlag::TRACE_FLAG_ALL: + return "TRACE_FLAG_ALL"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_ProtoLogConfig { +enum TracingMode : int32_t { + DEFAULT = 0, + ENABLE_ALL = 1, +}; +} // namespace perfetto_pbzero_enum_ProtoLogConfig +using ProtoLogConfig_TracingMode = perfetto_pbzero_enum_ProtoLogConfig::TracingMode; + + +constexpr ProtoLogConfig_TracingMode ProtoLogConfig_TracingMode_MIN = ProtoLogConfig_TracingMode::DEFAULT; +constexpr ProtoLogConfig_TracingMode ProtoLogConfig_TracingMode_MAX = ProtoLogConfig_TracingMode::ENABLE_ALL; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* ProtoLogConfig_TracingMode_Name(::perfetto::protos::pbzero::ProtoLogConfig_TracingMode value) { + switch (value) { + case ::perfetto::protos::pbzero::ProtoLogConfig_TracingMode::DEFAULT: + return "DEFAULT"; + + case ::perfetto::protos::pbzero::ProtoLogConfig_TracingMode::ENABLE_ALL: + return "ENABLE_ALL"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_AndroidInputEventConfig { +enum TraceMode : int32_t { + TRACE_MODE_TRACE_ALL = 0, + TRACE_MODE_USE_RULES = 1, +}; +} // namespace perfetto_pbzero_enum_AndroidInputEventConfig +using AndroidInputEventConfig_TraceMode = perfetto_pbzero_enum_AndroidInputEventConfig::TraceMode; + + +constexpr AndroidInputEventConfig_TraceMode AndroidInputEventConfig_TraceMode_MIN = AndroidInputEventConfig_TraceMode::TRACE_MODE_TRACE_ALL; +constexpr AndroidInputEventConfig_TraceMode AndroidInputEventConfig_TraceMode_MAX = AndroidInputEventConfig_TraceMode::TRACE_MODE_USE_RULES; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* AndroidInputEventConfig_TraceMode_Name(::perfetto::protos::pbzero::AndroidInputEventConfig_TraceMode value) { + switch (value) { + case ::perfetto::protos::pbzero::AndroidInputEventConfig_TraceMode::TRACE_MODE_TRACE_ALL: + return "TRACE_MODE_TRACE_ALL"; + + case ::perfetto::protos::pbzero::AndroidInputEventConfig_TraceMode::TRACE_MODE_USE_RULES: + return "TRACE_MODE_USE_RULES"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_AndroidInputEventConfig { +enum TraceLevel : int32_t { + TRACE_LEVEL_NONE = 0, + TRACE_LEVEL_REDACTED = 1, + TRACE_LEVEL_COMPLETE = 2, +}; +} // namespace perfetto_pbzero_enum_AndroidInputEventConfig +using AndroidInputEventConfig_TraceLevel = perfetto_pbzero_enum_AndroidInputEventConfig::TraceLevel; + + +constexpr AndroidInputEventConfig_TraceLevel AndroidInputEventConfig_TraceLevel_MIN = AndroidInputEventConfig_TraceLevel::TRACE_LEVEL_NONE; +constexpr AndroidInputEventConfig_TraceLevel AndroidInputEventConfig_TraceLevel_MAX = AndroidInputEventConfig_TraceLevel::TRACE_LEVEL_COMPLETE; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* AndroidInputEventConfig_TraceLevel_Name(::perfetto::protos::pbzero::AndroidInputEventConfig_TraceLevel value) { + switch (value) { + case ::perfetto::protos::pbzero::AndroidInputEventConfig_TraceLevel::TRACE_LEVEL_NONE: + return "TRACE_LEVEL_NONE"; + + case ::perfetto::protos::pbzero::AndroidInputEventConfig_TraceLevel::TRACE_LEVEL_REDACTED: + return "TRACE_LEVEL_REDACTED"; + + case ::perfetto::protos::pbzero::AndroidInputEventConfig_TraceLevel::TRACE_LEVEL_COMPLETE: + return "TRACE_LEVEL_COMPLETE"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +class Trace_Decoder : public ::protozero::TypedProtoDecoder { + public: + Trace_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Trace_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Trace_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_packet() const { return at<1>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> packet() const { return GetRepeated<::protozero::ConstBytes>(1); } +}; + +class Trace : public ::protozero::Message { + public: + using Decoder = Trace_Decoder; + enum : int32_t { + kPacketFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Trace"; } + + + using FieldMetadata_Packet = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TracePacket, + Trace>; + + static constexpr FieldMetadata_Packet kPacket{}; + template T* add_packet() { + return BeginNestedMessage(1); + } + +}; + +class TracePacket_Decoder : public ::protozero::TypedProtoDecoder { + public: + TracePacket_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TracePacket_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TracePacket_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_timestamp() const { return at<8>().valid(); } + uint64_t timestamp() const { return at<8>().as_uint64(); } + bool has_timestamp_clock_id() const { return at<58>().valid(); } + uint32_t timestamp_clock_id() const { return at<58>().as_uint32(); } + bool has_process_tree() const { return at<2>().valid(); } + ::protozero::ConstBytes process_tree() const { return at<2>().as_bytes(); } + bool has_process_stats() const { return at<9>().valid(); } + ::protozero::ConstBytes process_stats() const { return at<9>().as_bytes(); } + bool has_inode_file_map() const { return at<4>().valid(); } + ::protozero::ConstBytes inode_file_map() const { return at<4>().as_bytes(); } + bool has_chrome_events() const { return at<5>().valid(); } + ::protozero::ConstBytes chrome_events() const { return at<5>().as_bytes(); } + bool has_clock_snapshot() const { return at<6>().valid(); } + ::protozero::ConstBytes clock_snapshot() const { return at<6>().as_bytes(); } + bool has_sys_stats() const { return at<7>().valid(); } + ::protozero::ConstBytes sys_stats() const { return at<7>().as_bytes(); } + bool has_track_event() const { return at<11>().valid(); } + ::protozero::ConstBytes track_event() const { return at<11>().as_bytes(); } + bool has_trace_uuid() const { return at<89>().valid(); } + ::protozero::ConstBytes trace_uuid() const { return at<89>().as_bytes(); } + bool has_trace_config() const { return at<33>().valid(); } + ::protozero::ConstBytes trace_config() const { return at<33>().as_bytes(); } + bool has_ftrace_stats() const { return at<34>().valid(); } + ::protozero::ConstBytes ftrace_stats() const { return at<34>().as_bytes(); } + bool has_trace_stats() const { return at<35>().valid(); } + ::protozero::ConstBytes trace_stats() const { return at<35>().as_bytes(); } + bool has_profile_packet() const { return at<37>().valid(); } + ::protozero::ConstBytes profile_packet() const { return at<37>().as_bytes(); } + bool has_streaming_allocation() const { return at<74>().valid(); } + ::protozero::ConstBytes streaming_allocation() const { return at<74>().as_bytes(); } + bool has_streaming_free() const { return at<75>().valid(); } + ::protozero::ConstBytes streaming_free() const { return at<75>().as_bytes(); } + bool has_battery() const { return at<38>().valid(); } + ::protozero::ConstBytes battery() const { return at<38>().as_bytes(); } + bool has_power_rails() const { return at<40>().valid(); } + ::protozero::ConstBytes power_rails() const { return at<40>().as_bytes(); } + bool has_android_log() const { return at<39>().valid(); } + ::protozero::ConstBytes android_log() const { return at<39>().as_bytes(); } + bool has_system_info() const { return at<45>().valid(); } + ::protozero::ConstBytes system_info() const { return at<45>().as_bytes(); } + bool has_trigger() const { return at<46>().valid(); } + ::protozero::ConstBytes trigger() const { return at<46>().as_bytes(); } + bool has_chrome_trigger() const { return at<109>().valid(); } + ::protozero::ConstBytes chrome_trigger() const { return at<109>().as_bytes(); } + bool has_packages_list() const { return at<47>().valid(); } + ::protozero::ConstBytes packages_list() const { return at<47>().as_bytes(); } + bool has_chrome_benchmark_metadata() const { return at<48>().valid(); } + ::protozero::ConstBytes chrome_benchmark_metadata() const { return at<48>().as_bytes(); } + bool has_perfetto_metatrace() const { return at<49>().valid(); } + ::protozero::ConstBytes perfetto_metatrace() const { return at<49>().as_bytes(); } + bool has_chrome_metadata() const { return at<51>().valid(); } + ::protozero::ConstBytes chrome_metadata() const { return at<51>().as_bytes(); } + bool has_gpu_counter_event() const { return at<52>().valid(); } + ::protozero::ConstBytes gpu_counter_event() const { return at<52>().as_bytes(); } + bool has_gpu_render_stage_event() const { return at<53>().valid(); } + ::protozero::ConstBytes gpu_render_stage_event() const { return at<53>().as_bytes(); } + bool has_streaming_profile_packet() const { return at<54>().valid(); } + ::protozero::ConstBytes streaming_profile_packet() const { return at<54>().as_bytes(); } + bool has_heap_graph() const { return at<56>().valid(); } + ::protozero::ConstBytes heap_graph() const { return at<56>().as_bytes(); } + bool has_graphics_frame_event() const { return at<57>().valid(); } + ::protozero::ConstBytes graphics_frame_event() const { return at<57>().as_bytes(); } + bool has_vulkan_memory_event() const { return at<62>().valid(); } + ::protozero::ConstBytes vulkan_memory_event() const { return at<62>().as_bytes(); } + bool has_gpu_log() const { return at<63>().valid(); } + ::protozero::ConstBytes gpu_log() const { return at<63>().as_bytes(); } + bool has_vulkan_api_event() const { return at<65>().valid(); } + ::protozero::ConstBytes vulkan_api_event() const { return at<65>().as_bytes(); } + bool has_perf_sample() const { return at<66>().valid(); } + ::protozero::ConstBytes perf_sample() const { return at<66>().as_bytes(); } + bool has_cpu_info() const { return at<67>().valid(); } + ::protozero::ConstBytes cpu_info() const { return at<67>().as_bytes(); } + bool has_smaps_packet() const { return at<68>().valid(); } + ::protozero::ConstBytes smaps_packet() const { return at<68>().as_bytes(); } + bool has_service_event() const { return at<69>().valid(); } + ::protozero::ConstBytes service_event() const { return at<69>().as_bytes(); } + bool has_initial_display_state() const { return at<70>().valid(); } + ::protozero::ConstBytes initial_display_state() const { return at<70>().as_bytes(); } + bool has_gpu_mem_total_event() const { return at<71>().valid(); } + ::protozero::ConstBytes gpu_mem_total_event() const { return at<71>().as_bytes(); } + bool has_memory_tracker_snapshot() const { return at<73>().valid(); } + ::protozero::ConstBytes memory_tracker_snapshot() const { return at<73>().as_bytes(); } + bool has_frame_timeline_event() const { return at<76>().valid(); } + ::protozero::ConstBytes frame_timeline_event() const { return at<76>().as_bytes(); } + bool has_android_energy_estimation_breakdown() const { return at<77>().valid(); } + ::protozero::ConstBytes android_energy_estimation_breakdown() const { return at<77>().as_bytes(); } + bool has_ui_state() const { return at<78>().valid(); } + ::protozero::ConstBytes ui_state() const { return at<78>().as_bytes(); } + bool has_android_camera_frame_event() const { return at<80>().valid(); } + ::protozero::ConstBytes android_camera_frame_event() const { return at<80>().as_bytes(); } + bool has_android_camera_session_stats() const { return at<81>().valid(); } + ::protozero::ConstBytes android_camera_session_stats() const { return at<81>().as_bytes(); } + bool has_translation_table() const { return at<82>().valid(); } + ::protozero::ConstBytes translation_table() const { return at<82>().as_bytes(); } + bool has_android_game_intervention_list() const { return at<83>().valid(); } + ::protozero::ConstBytes android_game_intervention_list() const { return at<83>().as_bytes(); } + bool has_statsd_atom() const { return at<84>().valid(); } + ::protozero::ConstBytes statsd_atom() const { return at<84>().as_bytes(); } + bool has_android_system_property() const { return at<86>().valid(); } + ::protozero::ConstBytes android_system_property() const { return at<86>().as_bytes(); } + bool has_entity_state_residency() const { return at<91>().valid(); } + ::protozero::ConstBytes entity_state_residency() const { return at<91>().as_bytes(); } + bool has_profiled_frame_symbols() const { return at<55>().valid(); } + ::protozero::ConstBytes profiled_frame_symbols() const { return at<55>().as_bytes(); } + bool has_module_symbols() const { return at<61>().valid(); } + ::protozero::ConstBytes module_symbols() const { return at<61>().as_bytes(); } + bool has_deobfuscation_mapping() const { return at<64>().valid(); } + ::protozero::ConstBytes deobfuscation_mapping() const { return at<64>().as_bytes(); } + bool has_track_descriptor() const { return at<60>().valid(); } + ::protozero::ConstBytes track_descriptor() const { return at<60>().as_bytes(); } + bool has_process_descriptor() const { return at<43>().valid(); } + ::protozero::ConstBytes process_descriptor() const { return at<43>().as_bytes(); } + bool has_thread_descriptor() const { return at<44>().valid(); } + ::protozero::ConstBytes thread_descriptor() const { return at<44>().as_bytes(); } + bool has_ftrace_events() const { return at<1>().valid(); } + ::protozero::ConstBytes ftrace_events() const { return at<1>().as_bytes(); } + bool has_synchronization_marker() const { return at<36>().valid(); } + ::protozero::ConstBytes synchronization_marker() const { return at<36>().as_bytes(); } + bool has_compressed_packets() const { return at<50>().valid(); } + ::protozero::ConstBytes compressed_packets() const { return at<50>().as_bytes(); } + bool has_extension_descriptor() const { return at<72>().valid(); } + ::protozero::ConstBytes extension_descriptor() const { return at<72>().as_bytes(); } + bool has_network_packet() const { return at<88>().valid(); } + ::protozero::ConstBytes network_packet() const { return at<88>().as_bytes(); } + bool has_network_packet_bundle() const { return at<92>().valid(); } + ::protozero::ConstBytes network_packet_bundle() const { return at<92>().as_bytes(); } + bool has_track_event_range_of_interest() const { return at<90>().valid(); } + ::protozero::ConstBytes track_event_range_of_interest() const { return at<90>().as_bytes(); } + bool has_surfaceflinger_layers_snapshot() const { return at<93>().valid(); } + ::protozero::ConstBytes surfaceflinger_layers_snapshot() const { return at<93>().as_bytes(); } + bool has_surfaceflinger_transactions() const { return at<94>().valid(); } + ::protozero::ConstBytes surfaceflinger_transactions() const { return at<94>().as_bytes(); } + bool has_shell_transition() const { return at<96>().valid(); } + ::protozero::ConstBytes shell_transition() const { return at<96>().as_bytes(); } + bool has_shell_handler_mappings() const { return at<97>().valid(); } + ::protozero::ConstBytes shell_handler_mappings() const { return at<97>().as_bytes(); } + bool has_protolog_message() const { return at<104>().valid(); } + ::protozero::ConstBytes protolog_message() const { return at<104>().as_bytes(); } + bool has_protolog_viewer_config() const { return at<105>().valid(); } + ::protozero::ConstBytes protolog_viewer_config() const { return at<105>().as_bytes(); } + bool has_etw_events() const { return at<95>().valid(); } + ::protozero::ConstBytes etw_events() const { return at<95>().as_bytes(); } + bool has_v8_js_code() const { return at<99>().valid(); } + ::protozero::ConstBytes v8_js_code() const { return at<99>().as_bytes(); } + bool has_v8_internal_code() const { return at<100>().valid(); } + ::protozero::ConstBytes v8_internal_code() const { return at<100>().as_bytes(); } + bool has_v8_wasm_code() const { return at<101>().valid(); } + ::protozero::ConstBytes v8_wasm_code() const { return at<101>().as_bytes(); } + bool has_v8_reg_exp_code() const { return at<102>().valid(); } + ::protozero::ConstBytes v8_reg_exp_code() const { return at<102>().as_bytes(); } + bool has_v8_code_move() const { return at<103>().valid(); } + ::protozero::ConstBytes v8_code_move() const { return at<103>().as_bytes(); } + bool has_android_input_event() const { return at<106>().valid(); } + ::protozero::ConstBytes android_input_event() const { return at<106>().as_bytes(); } + bool has_remote_clock_sync() const { return at<107>().valid(); } + ::protozero::ConstBytes remote_clock_sync() const { return at<107>().as_bytes(); } + bool has_for_testing() const { return at<900>().valid(); } + ::protozero::ConstBytes for_testing() const { return at<900>().as_bytes(); } + bool has_trusted_uid() const { return at<3>().valid(); } + int32_t trusted_uid() const { return at<3>().as_int32(); } + bool has_trusted_packet_sequence_id() const { return at<10>().valid(); } + uint32_t trusted_packet_sequence_id() const { return at<10>().as_uint32(); } + bool has_trusted_pid() const { return at<79>().valid(); } + int32_t trusted_pid() const { return at<79>().as_int32(); } + bool has_interned_data() const { return at<12>().valid(); } + ::protozero::ConstBytes interned_data() const { return at<12>().as_bytes(); } + bool has_sequence_flags() const { return at<13>().valid(); } + uint32_t sequence_flags() const { return at<13>().as_uint32(); } + bool has_incremental_state_cleared() const { return at<41>().valid(); } + bool incremental_state_cleared() const { return at<41>().as_bool(); } + bool has_trace_packet_defaults() const { return at<59>().valid(); } + ::protozero::ConstBytes trace_packet_defaults() const { return at<59>().as_bytes(); } + bool has_previous_packet_dropped() const { return at<42>().valid(); } + bool previous_packet_dropped() const { return at<42>().as_bool(); } + bool has_first_packet_on_sequence() const { return at<87>().valid(); } + bool first_packet_on_sequence() const { return at<87>().as_bool(); } + bool has_machine_id() const { return at<98>().valid(); } + uint32_t machine_id() const { return at<98>().as_uint32(); } +}; + +class TracePacket : public ::protozero::Message { + public: + using Decoder = TracePacket_Decoder; + enum : int32_t { + kTimestampFieldNumber = 8, + kTimestampClockIdFieldNumber = 58, + kProcessTreeFieldNumber = 2, + kProcessStatsFieldNumber = 9, + kInodeFileMapFieldNumber = 4, + kChromeEventsFieldNumber = 5, + kClockSnapshotFieldNumber = 6, + kSysStatsFieldNumber = 7, + kTrackEventFieldNumber = 11, + kTraceUuidFieldNumber = 89, + kTraceConfigFieldNumber = 33, + kFtraceStatsFieldNumber = 34, + kTraceStatsFieldNumber = 35, + kProfilePacketFieldNumber = 37, + kStreamingAllocationFieldNumber = 74, + kStreamingFreeFieldNumber = 75, + kBatteryFieldNumber = 38, + kPowerRailsFieldNumber = 40, + kAndroidLogFieldNumber = 39, + kSystemInfoFieldNumber = 45, + kTriggerFieldNumber = 46, + kChromeTriggerFieldNumber = 109, + kPackagesListFieldNumber = 47, + kChromeBenchmarkMetadataFieldNumber = 48, + kPerfettoMetatraceFieldNumber = 49, + kChromeMetadataFieldNumber = 51, + kGpuCounterEventFieldNumber = 52, + kGpuRenderStageEventFieldNumber = 53, + kStreamingProfilePacketFieldNumber = 54, + kHeapGraphFieldNumber = 56, + kGraphicsFrameEventFieldNumber = 57, + kVulkanMemoryEventFieldNumber = 62, + kGpuLogFieldNumber = 63, + kVulkanApiEventFieldNumber = 65, + kPerfSampleFieldNumber = 66, + kCpuInfoFieldNumber = 67, + kSmapsPacketFieldNumber = 68, + kServiceEventFieldNumber = 69, + kInitialDisplayStateFieldNumber = 70, + kGpuMemTotalEventFieldNumber = 71, + kMemoryTrackerSnapshotFieldNumber = 73, + kFrameTimelineEventFieldNumber = 76, + kAndroidEnergyEstimationBreakdownFieldNumber = 77, + kUiStateFieldNumber = 78, + kAndroidCameraFrameEventFieldNumber = 80, + kAndroidCameraSessionStatsFieldNumber = 81, + kTranslationTableFieldNumber = 82, + kAndroidGameInterventionListFieldNumber = 83, + kStatsdAtomFieldNumber = 84, + kAndroidSystemPropertyFieldNumber = 86, + kEntityStateResidencyFieldNumber = 91, + kProfiledFrameSymbolsFieldNumber = 55, + kModuleSymbolsFieldNumber = 61, + kDeobfuscationMappingFieldNumber = 64, + kTrackDescriptorFieldNumber = 60, + kProcessDescriptorFieldNumber = 43, + kThreadDescriptorFieldNumber = 44, + kFtraceEventsFieldNumber = 1, + kSynchronizationMarkerFieldNumber = 36, + kCompressedPacketsFieldNumber = 50, + kExtensionDescriptorFieldNumber = 72, + kNetworkPacketFieldNumber = 88, + kNetworkPacketBundleFieldNumber = 92, + kTrackEventRangeOfInterestFieldNumber = 90, + kSurfaceflingerLayersSnapshotFieldNumber = 93, + kSurfaceflingerTransactionsFieldNumber = 94, + kShellTransitionFieldNumber = 96, + kShellHandlerMappingsFieldNumber = 97, + kProtologMessageFieldNumber = 104, + kProtologViewerConfigFieldNumber = 105, + kEtwEventsFieldNumber = 95, + kV8JsCodeFieldNumber = 99, + kV8InternalCodeFieldNumber = 100, + kV8WasmCodeFieldNumber = 101, + kV8RegExpCodeFieldNumber = 102, + kV8CodeMoveFieldNumber = 103, + kAndroidInputEventFieldNumber = 106, + kRemoteClockSyncFieldNumber = 107, + kForTestingFieldNumber = 900, + kTrustedUidFieldNumber = 3, + kTrustedPacketSequenceIdFieldNumber = 10, + kTrustedPidFieldNumber = 79, + kInternedDataFieldNumber = 12, + kSequenceFlagsFieldNumber = 13, + kIncrementalStateClearedFieldNumber = 41, + kTracePacketDefaultsFieldNumber = 59, + kPreviousPacketDroppedFieldNumber = 42, + kFirstPacketOnSequenceFieldNumber = 87, + kMachineIdFieldNumber = 98, + }; + static constexpr const char* GetName() { return ".perfetto.protos.TracePacket"; } + + + using SequenceFlags = ::perfetto::protos::pbzero::TracePacket_SequenceFlags; + static inline const char* SequenceFlags_Name(SequenceFlags value) { + return ::perfetto::protos::pbzero::TracePacket_SequenceFlags_Name(value); + } + static inline const SequenceFlags SEQ_UNSPECIFIED = SequenceFlags::SEQ_UNSPECIFIED; + static inline const SequenceFlags SEQ_INCREMENTAL_STATE_CLEARED = SequenceFlags::SEQ_INCREMENTAL_STATE_CLEARED; + static inline const SequenceFlags SEQ_NEEDS_INCREMENTAL_STATE = SequenceFlags::SEQ_NEEDS_INCREMENTAL_STATE; + + using FieldMetadata_Timestamp = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TracePacket>; + + static constexpr FieldMetadata_Timestamp kTimestamp{}; + void set_timestamp(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Timestamp::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TimestampClockId = + ::protozero::proto_utils::FieldMetadata< + 58, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + TracePacket>; + + static constexpr FieldMetadata_TimestampClockId kTimestampClockId{}; + void set_timestamp_clock_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TimestampClockId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ProcessTree = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ProcessTree, + TracePacket>; + + static constexpr FieldMetadata_ProcessTree kProcessTree{}; + template T* set_process_tree() { + return BeginNestedMessage(2); + } + + + using FieldMetadata_ProcessStats = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ProcessStats, + TracePacket>; + + static constexpr FieldMetadata_ProcessStats kProcessStats{}; + template T* set_process_stats() { + return BeginNestedMessage(9); + } + + + using FieldMetadata_InodeFileMap = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + InodeFileMap, + TracePacket>; + + static constexpr FieldMetadata_InodeFileMap kInodeFileMap{}; + template T* set_inode_file_map() { + return BeginNestedMessage(4); + } + + + using FieldMetadata_ChromeEvents = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ChromeEventBundle, + TracePacket>; + + static constexpr FieldMetadata_ChromeEvents kChromeEvents{}; + template T* set_chrome_events() { + return BeginNestedMessage(5); + } + + + using FieldMetadata_ClockSnapshot = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ClockSnapshot, + TracePacket>; + + static constexpr FieldMetadata_ClockSnapshot kClockSnapshot{}; + template T* set_clock_snapshot() { + return BeginNestedMessage(6); + } + + + using FieldMetadata_SysStats = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + SysStats, + TracePacket>; + + static constexpr FieldMetadata_SysStats kSysStats{}; + template T* set_sys_stats() { + return BeginNestedMessage(7); + } + + + using FieldMetadata_TrackEvent = + ::protozero::proto_utils::FieldMetadata< + 11, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TrackEvent, + TracePacket>; + + static constexpr FieldMetadata_TrackEvent kTrackEvent{}; + template T* set_track_event() { + return BeginNestedMessage(11); + } + + + using FieldMetadata_TraceUuid = + ::protozero::proto_utils::FieldMetadata< + 89, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TraceUuid, + TracePacket>; + + static constexpr FieldMetadata_TraceUuid kTraceUuid{}; + template T* set_trace_uuid() { + return BeginNestedMessage(89); + } + + + using FieldMetadata_TraceConfig = + ::protozero::proto_utils::FieldMetadata< + 33, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TraceConfig, + TracePacket>; + + static constexpr FieldMetadata_TraceConfig kTraceConfig{}; + template T* set_trace_config() { + return BeginNestedMessage(33); + } + + + using FieldMetadata_FtraceStats = + ::protozero::proto_utils::FieldMetadata< + 34, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + FtraceStats, + TracePacket>; + + static constexpr FieldMetadata_FtraceStats kFtraceStats{}; + template T* set_ftrace_stats() { + return BeginNestedMessage(34); + } + + + using FieldMetadata_TraceStats = + ::protozero::proto_utils::FieldMetadata< + 35, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TraceStats, + TracePacket>; + + static constexpr FieldMetadata_TraceStats kTraceStats{}; + template T* set_trace_stats() { + return BeginNestedMessage(35); + } + + + using FieldMetadata_ProfilePacket = + ::protozero::proto_utils::FieldMetadata< + 37, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ProfilePacket, + TracePacket>; + + static constexpr FieldMetadata_ProfilePacket kProfilePacket{}; + template T* set_profile_packet() { + return BeginNestedMessage(37); + } + + + using FieldMetadata_StreamingAllocation = + ::protozero::proto_utils::FieldMetadata< + 74, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + StreamingAllocation, + TracePacket>; + + static constexpr FieldMetadata_StreamingAllocation kStreamingAllocation{}; + template T* set_streaming_allocation() { + return BeginNestedMessage(74); + } + + + using FieldMetadata_StreamingFree = + ::protozero::proto_utils::FieldMetadata< + 75, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + StreamingFree, + TracePacket>; + + static constexpr FieldMetadata_StreamingFree kStreamingFree{}; + template T* set_streaming_free() { + return BeginNestedMessage(75); + } + + + using FieldMetadata_Battery = + ::protozero::proto_utils::FieldMetadata< + 38, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + BatteryCounters, + TracePacket>; + + static constexpr FieldMetadata_Battery kBattery{}; + template T* set_battery() { + return BeginNestedMessage(38); + } + + + using FieldMetadata_PowerRails = + ::protozero::proto_utils::FieldMetadata< + 40, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + PowerRails, + TracePacket>; + + static constexpr FieldMetadata_PowerRails kPowerRails{}; + template T* set_power_rails() { + return BeginNestedMessage(40); + } + + + using FieldMetadata_AndroidLog = + ::protozero::proto_utils::FieldMetadata< + 39, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + AndroidLogPacket, + TracePacket>; + + static constexpr FieldMetadata_AndroidLog kAndroidLog{}; + template T* set_android_log() { + return BeginNestedMessage(39); + } + + + using FieldMetadata_SystemInfo = + ::protozero::proto_utils::FieldMetadata< + 45, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + SystemInfo, + TracePacket>; + + static constexpr FieldMetadata_SystemInfo kSystemInfo{}; + template T* set_system_info() { + return BeginNestedMessage(45); + } + + + using FieldMetadata_Trigger = + ::protozero::proto_utils::FieldMetadata< + 46, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Trigger, + TracePacket>; + + static constexpr FieldMetadata_Trigger kTrigger{}; + template T* set_trigger() { + return BeginNestedMessage(46); + } + + + using FieldMetadata_ChromeTrigger = + ::protozero::proto_utils::FieldMetadata< + 109, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ChromeTrigger, + TracePacket>; + + static constexpr FieldMetadata_ChromeTrigger kChromeTrigger{}; + template T* set_chrome_trigger() { + return BeginNestedMessage(109); + } + + + using FieldMetadata_PackagesList = + ::protozero::proto_utils::FieldMetadata< + 47, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + PackagesList, + TracePacket>; + + static constexpr FieldMetadata_PackagesList kPackagesList{}; + template T* set_packages_list() { + return BeginNestedMessage(47); + } + + + using FieldMetadata_ChromeBenchmarkMetadata = + ::protozero::proto_utils::FieldMetadata< + 48, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ChromeBenchmarkMetadata, + TracePacket>; + + static constexpr FieldMetadata_ChromeBenchmarkMetadata kChromeBenchmarkMetadata{}; + template T* set_chrome_benchmark_metadata() { + return BeginNestedMessage(48); + } + + + using FieldMetadata_PerfettoMetatrace = + ::protozero::proto_utils::FieldMetadata< + 49, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + PerfettoMetatrace, + TracePacket>; + + static constexpr FieldMetadata_PerfettoMetatrace kPerfettoMetatrace{}; + template T* set_perfetto_metatrace() { + return BeginNestedMessage(49); + } + + + using FieldMetadata_ChromeMetadata = + ::protozero::proto_utils::FieldMetadata< + 51, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ChromeMetadataPacket, + TracePacket>; + + static constexpr FieldMetadata_ChromeMetadata kChromeMetadata{}; + template T* set_chrome_metadata() { + return BeginNestedMessage(51); + } + + + using FieldMetadata_GpuCounterEvent = + ::protozero::proto_utils::FieldMetadata< + 52, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + GpuCounterEvent, + TracePacket>; + + static constexpr FieldMetadata_GpuCounterEvent kGpuCounterEvent{}; + template T* set_gpu_counter_event() { + return BeginNestedMessage(52); + } + + + using FieldMetadata_GpuRenderStageEvent = + ::protozero::proto_utils::FieldMetadata< + 53, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + GpuRenderStageEvent, + TracePacket>; + + static constexpr FieldMetadata_GpuRenderStageEvent kGpuRenderStageEvent{}; + template T* set_gpu_render_stage_event() { + return BeginNestedMessage(53); + } + + + using FieldMetadata_StreamingProfilePacket = + ::protozero::proto_utils::FieldMetadata< + 54, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + StreamingProfilePacket, + TracePacket>; + + static constexpr FieldMetadata_StreamingProfilePacket kStreamingProfilePacket{}; + template T* set_streaming_profile_packet() { + return BeginNestedMessage(54); + } + + + using FieldMetadata_HeapGraph = + ::protozero::proto_utils::FieldMetadata< + 56, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + HeapGraph, + TracePacket>; + + static constexpr FieldMetadata_HeapGraph kHeapGraph{}; + template T* set_heap_graph() { + return BeginNestedMessage(56); + } + + + using FieldMetadata_GraphicsFrameEvent = + ::protozero::proto_utils::FieldMetadata< + 57, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + GraphicsFrameEvent, + TracePacket>; + + static constexpr FieldMetadata_GraphicsFrameEvent kGraphicsFrameEvent{}; + template T* set_graphics_frame_event() { + return BeginNestedMessage(57); + } + + + using FieldMetadata_VulkanMemoryEvent = + ::protozero::proto_utils::FieldMetadata< + 62, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + VulkanMemoryEvent, + TracePacket>; + + static constexpr FieldMetadata_VulkanMemoryEvent kVulkanMemoryEvent{}; + template T* set_vulkan_memory_event() { + return BeginNestedMessage(62); + } + + + using FieldMetadata_GpuLog = + ::protozero::proto_utils::FieldMetadata< + 63, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + GpuLog, + TracePacket>; + + static constexpr FieldMetadata_GpuLog kGpuLog{}; + template T* set_gpu_log() { + return BeginNestedMessage(63); + } + + + using FieldMetadata_VulkanApiEvent = + ::protozero::proto_utils::FieldMetadata< + 65, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + VulkanApiEvent, + TracePacket>; + + static constexpr FieldMetadata_VulkanApiEvent kVulkanApiEvent{}; + template T* set_vulkan_api_event() { + return BeginNestedMessage(65); + } + + + using FieldMetadata_PerfSample = + ::protozero::proto_utils::FieldMetadata< + 66, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + PerfSample, + TracePacket>; + + static constexpr FieldMetadata_PerfSample kPerfSample{}; + template T* set_perf_sample() { + return BeginNestedMessage(66); + } + + + using FieldMetadata_CpuInfo = + ::protozero::proto_utils::FieldMetadata< + 67, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + CpuInfo, + TracePacket>; + + static constexpr FieldMetadata_CpuInfo kCpuInfo{}; + template T* set_cpu_info() { + return BeginNestedMessage(67); + } + + + using FieldMetadata_SmapsPacket = + ::protozero::proto_utils::FieldMetadata< + 68, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + SmapsPacket, + TracePacket>; + + static constexpr FieldMetadata_SmapsPacket kSmapsPacket{}; + template T* set_smaps_packet() { + return BeginNestedMessage(68); + } + + + using FieldMetadata_ServiceEvent = + ::protozero::proto_utils::FieldMetadata< + 69, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TracingServiceEvent, + TracePacket>; + + static constexpr FieldMetadata_ServiceEvent kServiceEvent{}; + template T* set_service_event() { + return BeginNestedMessage(69); + } + + + using FieldMetadata_InitialDisplayState = + ::protozero::proto_utils::FieldMetadata< + 70, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + InitialDisplayState, + TracePacket>; + + static constexpr FieldMetadata_InitialDisplayState kInitialDisplayState{}; + template T* set_initial_display_state() { + return BeginNestedMessage(70); + } + + + using FieldMetadata_GpuMemTotalEvent = + ::protozero::proto_utils::FieldMetadata< + 71, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + GpuMemTotalEvent, + TracePacket>; + + static constexpr FieldMetadata_GpuMemTotalEvent kGpuMemTotalEvent{}; + template T* set_gpu_mem_total_event() { + return BeginNestedMessage(71); + } + + + using FieldMetadata_MemoryTrackerSnapshot = + ::protozero::proto_utils::FieldMetadata< + 73, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MemoryTrackerSnapshot, + TracePacket>; + + static constexpr FieldMetadata_MemoryTrackerSnapshot kMemoryTrackerSnapshot{}; + template T* set_memory_tracker_snapshot() { + return BeginNestedMessage(73); + } + + + using FieldMetadata_FrameTimelineEvent = + ::protozero::proto_utils::FieldMetadata< + 76, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + FrameTimelineEvent, + TracePacket>; + + static constexpr FieldMetadata_FrameTimelineEvent kFrameTimelineEvent{}; + template T* set_frame_timeline_event() { + return BeginNestedMessage(76); + } + + + using FieldMetadata_AndroidEnergyEstimationBreakdown = + ::protozero::proto_utils::FieldMetadata< + 77, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + AndroidEnergyEstimationBreakdown, + TracePacket>; + + static constexpr FieldMetadata_AndroidEnergyEstimationBreakdown kAndroidEnergyEstimationBreakdown{}; + template T* set_android_energy_estimation_breakdown() { + return BeginNestedMessage(77); + } + + + using FieldMetadata_UiState = + ::protozero::proto_utils::FieldMetadata< + 78, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + UiState, + TracePacket>; + + static constexpr FieldMetadata_UiState kUiState{}; + template T* set_ui_state() { + return BeginNestedMessage(78); + } + + + using FieldMetadata_AndroidCameraFrameEvent = + ::protozero::proto_utils::FieldMetadata< + 80, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + AndroidCameraFrameEvent, + TracePacket>; + + static constexpr FieldMetadata_AndroidCameraFrameEvent kAndroidCameraFrameEvent{}; + template T* set_android_camera_frame_event() { + return BeginNestedMessage(80); + } + + + using FieldMetadata_AndroidCameraSessionStats = + ::protozero::proto_utils::FieldMetadata< + 81, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + AndroidCameraSessionStats, + TracePacket>; + + static constexpr FieldMetadata_AndroidCameraSessionStats kAndroidCameraSessionStats{}; + template T* set_android_camera_session_stats() { + return BeginNestedMessage(81); + } + + + using FieldMetadata_TranslationTable = + ::protozero::proto_utils::FieldMetadata< + 82, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TranslationTable, + TracePacket>; + + static constexpr FieldMetadata_TranslationTable kTranslationTable{}; + template T* set_translation_table() { + return BeginNestedMessage(82); + } + + + using FieldMetadata_AndroidGameInterventionList = + ::protozero::proto_utils::FieldMetadata< + 83, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + AndroidGameInterventionList, + TracePacket>; + + static constexpr FieldMetadata_AndroidGameInterventionList kAndroidGameInterventionList{}; + template T* set_android_game_intervention_list() { + return BeginNestedMessage(83); + } + + + using FieldMetadata_StatsdAtom = + ::protozero::proto_utils::FieldMetadata< + 84, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + StatsdAtom, + TracePacket>; + + static constexpr FieldMetadata_StatsdAtom kStatsdAtom{}; + template T* set_statsd_atom() { + return BeginNestedMessage(84); + } + + + using FieldMetadata_AndroidSystemProperty = + ::protozero::proto_utils::FieldMetadata< + 86, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + AndroidSystemProperty, + TracePacket>; + + static constexpr FieldMetadata_AndroidSystemProperty kAndroidSystemProperty{}; + template T* set_android_system_property() { + return BeginNestedMessage(86); + } + + + using FieldMetadata_EntityStateResidency = + ::protozero::proto_utils::FieldMetadata< + 91, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + EntityStateResidency, + TracePacket>; + + static constexpr FieldMetadata_EntityStateResidency kEntityStateResidency{}; + template T* set_entity_state_residency() { + return BeginNestedMessage(91); + } + + + using FieldMetadata_ProfiledFrameSymbols = + ::protozero::proto_utils::FieldMetadata< + 55, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ProfiledFrameSymbols, + TracePacket>; + + static constexpr FieldMetadata_ProfiledFrameSymbols kProfiledFrameSymbols{}; + template T* set_profiled_frame_symbols() { + return BeginNestedMessage(55); + } + + + using FieldMetadata_ModuleSymbols = + ::protozero::proto_utils::FieldMetadata< + 61, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ModuleSymbols, + TracePacket>; + + static constexpr FieldMetadata_ModuleSymbols kModuleSymbols{}; + template T* set_module_symbols() { + return BeginNestedMessage(61); + } + + + using FieldMetadata_DeobfuscationMapping = + ::protozero::proto_utils::FieldMetadata< + 64, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + DeobfuscationMapping, + TracePacket>; + + static constexpr FieldMetadata_DeobfuscationMapping kDeobfuscationMapping{}; + template T* set_deobfuscation_mapping() { + return BeginNestedMessage(64); + } + + + using FieldMetadata_TrackDescriptor = + ::protozero::proto_utils::FieldMetadata< + 60, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TrackDescriptor, + TracePacket>; + + static constexpr FieldMetadata_TrackDescriptor kTrackDescriptor{}; + template T* set_track_descriptor() { + return BeginNestedMessage(60); + } + + + using FieldMetadata_ProcessDescriptor = + ::protozero::proto_utils::FieldMetadata< + 43, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ProcessDescriptor, + TracePacket>; + + static constexpr FieldMetadata_ProcessDescriptor kProcessDescriptor{}; + template T* set_process_descriptor() { + return BeginNestedMessage(43); + } + + + using FieldMetadata_ThreadDescriptor = + ::protozero::proto_utils::FieldMetadata< + 44, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ThreadDescriptor, + TracePacket>; + + static constexpr FieldMetadata_ThreadDescriptor kThreadDescriptor{}; + template T* set_thread_descriptor() { + return BeginNestedMessage(44); + } + + + using FieldMetadata_FtraceEvents = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + FtraceEventBundle, + TracePacket>; + + static constexpr FieldMetadata_FtraceEvents kFtraceEvents{}; + template T* set_ftrace_events() { + return BeginNestedMessage(1); + } + + + using FieldMetadata_SynchronizationMarker = + ::protozero::proto_utils::FieldMetadata< + 36, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBytes, + std::string, + TracePacket>; + + static constexpr FieldMetadata_SynchronizationMarker kSynchronizationMarker{}; + void set_synchronization_marker(const uint8_t* data, size_t size) { + AppendBytes(FieldMetadata_SynchronizationMarker::kFieldId, data, size); + } + void set_synchronization_marker(::protozero::ConstBytes bytes) { + AppendBytes(FieldMetadata_SynchronizationMarker::kFieldId, bytes.data, bytes.size); + } + void set_synchronization_marker(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_SynchronizationMarker::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBytes> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CompressedPackets = + ::protozero::proto_utils::FieldMetadata< + 50, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBytes, + std::string, + TracePacket>; + + static constexpr FieldMetadata_CompressedPackets kCompressedPackets{}; + void set_compressed_packets(const uint8_t* data, size_t size) { + AppendBytes(FieldMetadata_CompressedPackets::kFieldId, data, size); + } + void set_compressed_packets(::protozero::ConstBytes bytes) { + AppendBytes(FieldMetadata_CompressedPackets::kFieldId, bytes.data, bytes.size); + } + void set_compressed_packets(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_CompressedPackets::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBytes> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ExtensionDescriptor = + ::protozero::proto_utils::FieldMetadata< + 72, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ExtensionDescriptor, + TracePacket>; + + static constexpr FieldMetadata_ExtensionDescriptor kExtensionDescriptor{}; + template T* set_extension_descriptor() { + return BeginNestedMessage(72); + } + + + using FieldMetadata_NetworkPacket = + ::protozero::proto_utils::FieldMetadata< + 88, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + NetworkPacketEvent, + TracePacket>; + + static constexpr FieldMetadata_NetworkPacket kNetworkPacket{}; + template T* set_network_packet() { + return BeginNestedMessage(88); + } + + + using FieldMetadata_NetworkPacketBundle = + ::protozero::proto_utils::FieldMetadata< + 92, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + NetworkPacketBundle, + TracePacket>; + + static constexpr FieldMetadata_NetworkPacketBundle kNetworkPacketBundle{}; + template T* set_network_packet_bundle() { + return BeginNestedMessage(92); + } + + + using FieldMetadata_TrackEventRangeOfInterest = + ::protozero::proto_utils::FieldMetadata< + 90, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TrackEventRangeOfInterest, + TracePacket>; + + static constexpr FieldMetadata_TrackEventRangeOfInterest kTrackEventRangeOfInterest{}; + template T* set_track_event_range_of_interest() { + return BeginNestedMessage(90); + } + + + using FieldMetadata_SurfaceflingerLayersSnapshot = + ::protozero::proto_utils::FieldMetadata< + 93, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + LayersSnapshotProto, + TracePacket>; + + static constexpr FieldMetadata_SurfaceflingerLayersSnapshot kSurfaceflingerLayersSnapshot{}; + template T* set_surfaceflinger_layers_snapshot() { + return BeginNestedMessage(93); + } + + + using FieldMetadata_SurfaceflingerTransactions = + ::protozero::proto_utils::FieldMetadata< + 94, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TransactionTraceEntry, + TracePacket>; + + static constexpr FieldMetadata_SurfaceflingerTransactions kSurfaceflingerTransactions{}; + template T* set_surfaceflinger_transactions() { + return BeginNestedMessage(94); + } + + + using FieldMetadata_ShellTransition = + ::protozero::proto_utils::FieldMetadata< + 96, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ShellTransition, + TracePacket>; + + static constexpr FieldMetadata_ShellTransition kShellTransition{}; + template T* set_shell_transition() { + return BeginNestedMessage(96); + } + + + using FieldMetadata_ShellHandlerMappings = + ::protozero::proto_utils::FieldMetadata< + 97, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ShellHandlerMappings, + TracePacket>; + + static constexpr FieldMetadata_ShellHandlerMappings kShellHandlerMappings{}; + template T* set_shell_handler_mappings() { + return BeginNestedMessage(97); + } + + + using FieldMetadata_ProtologMessage = + ::protozero::proto_utils::FieldMetadata< + 104, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ProtoLogMessage, + TracePacket>; + + static constexpr FieldMetadata_ProtologMessage kProtologMessage{}; + template T* set_protolog_message() { + return BeginNestedMessage(104); + } + + + using FieldMetadata_ProtologViewerConfig = + ::protozero::proto_utils::FieldMetadata< + 105, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ProtoLogViewerConfig, + TracePacket>; + + static constexpr FieldMetadata_ProtologViewerConfig kProtologViewerConfig{}; + template T* set_protolog_viewer_config() { + return BeginNestedMessage(105); + } + + + using FieldMetadata_EtwEvents = + ::protozero::proto_utils::FieldMetadata< + 95, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + EtwTraceEventBundle, + TracePacket>; + + static constexpr FieldMetadata_EtwEvents kEtwEvents{}; + template T* set_etw_events() { + return BeginNestedMessage(95); + } + + + using FieldMetadata_V8JsCode = + ::protozero::proto_utils::FieldMetadata< + 99, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + V8JsCode, + TracePacket>; + + static constexpr FieldMetadata_V8JsCode kV8JsCode{}; + template T* set_v8_js_code() { + return BeginNestedMessage(99); + } + + + using FieldMetadata_V8InternalCode = + ::protozero::proto_utils::FieldMetadata< + 100, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + V8InternalCode, + TracePacket>; + + static constexpr FieldMetadata_V8InternalCode kV8InternalCode{}; + template T* set_v8_internal_code() { + return BeginNestedMessage(100); + } + + + using FieldMetadata_V8WasmCode = + ::protozero::proto_utils::FieldMetadata< + 101, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + V8WasmCode, + TracePacket>; + + static constexpr FieldMetadata_V8WasmCode kV8WasmCode{}; + template T* set_v8_wasm_code() { + return BeginNestedMessage(101); + } + + + using FieldMetadata_V8RegExpCode = + ::protozero::proto_utils::FieldMetadata< + 102, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + V8RegExpCode, + TracePacket>; + + static constexpr FieldMetadata_V8RegExpCode kV8RegExpCode{}; + template T* set_v8_reg_exp_code() { + return BeginNestedMessage(102); + } + + + using FieldMetadata_V8CodeMove = + ::protozero::proto_utils::FieldMetadata< + 103, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + V8CodeMove, + TracePacket>; + + static constexpr FieldMetadata_V8CodeMove kV8CodeMove{}; + template T* set_v8_code_move() { + return BeginNestedMessage(103); + } + + + using FieldMetadata_AndroidInputEvent = + ::protozero::proto_utils::FieldMetadata< + 106, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + AndroidInputEvent, + TracePacket>; + + static constexpr FieldMetadata_AndroidInputEvent kAndroidInputEvent{}; + template T* set_android_input_event() { + return BeginNestedMessage(106); + } + + + using FieldMetadata_RemoteClockSync = + ::protozero::proto_utils::FieldMetadata< + 107, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + RemoteClockSync, + TracePacket>; + + static constexpr FieldMetadata_RemoteClockSync kRemoteClockSync{}; + template T* set_remote_clock_sync() { + return BeginNestedMessage(107); + } + + + using FieldMetadata_ForTesting = + ::protozero::proto_utils::FieldMetadata< + 900, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TestEvent, + TracePacket>; + + static constexpr FieldMetadata_ForTesting kForTesting{}; + template T* set_for_testing() { + return BeginNestedMessage(900); + } + + + using FieldMetadata_TrustedUid = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + TracePacket>; + + static constexpr FieldMetadata_TrustedUid kTrustedUid{}; + void set_trusted_uid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TrustedUid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TrustedPacketSequenceId = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + TracePacket>; + + static constexpr FieldMetadata_TrustedPacketSequenceId kTrustedPacketSequenceId{}; + void set_trusted_packet_sequence_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TrustedPacketSequenceId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TrustedPid = + ::protozero::proto_utils::FieldMetadata< + 79, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + TracePacket>; + + static constexpr FieldMetadata_TrustedPid kTrustedPid{}; + void set_trusted_pid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TrustedPid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_InternedData = + ::protozero::proto_utils::FieldMetadata< + 12, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + InternedData, + TracePacket>; + + static constexpr FieldMetadata_InternedData kInternedData{}; + template T* set_interned_data() { + return BeginNestedMessage(12); + } + + + using FieldMetadata_SequenceFlags = + ::protozero::proto_utils::FieldMetadata< + 13, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + TracePacket>; + + static constexpr FieldMetadata_SequenceFlags kSequenceFlags{}; + void set_sequence_flags(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_SequenceFlags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_IncrementalStateCleared = + ::protozero::proto_utils::FieldMetadata< + 41, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + TracePacket>; + + static constexpr FieldMetadata_IncrementalStateCleared kIncrementalStateCleared{}; + void set_incremental_state_cleared(bool value) { + static constexpr uint32_t field_id = FieldMetadata_IncrementalStateCleared::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TracePacketDefaults = + ::protozero::proto_utils::FieldMetadata< + 59, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TracePacketDefaults, + TracePacket>; + + static constexpr FieldMetadata_TracePacketDefaults kTracePacketDefaults{}; + template T* set_trace_packet_defaults() { + return BeginNestedMessage(59); + } + + + using FieldMetadata_PreviousPacketDropped = + ::protozero::proto_utils::FieldMetadata< + 42, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + TracePacket>; + + static constexpr FieldMetadata_PreviousPacketDropped kPreviousPacketDropped{}; + void set_previous_packet_dropped(bool value) { + static constexpr uint32_t field_id = FieldMetadata_PreviousPacketDropped::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FirstPacketOnSequence = + ::protozero::proto_utils::FieldMetadata< + 87, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + TracePacket>; + + static constexpr FieldMetadata_FirstPacketOnSequence kFirstPacketOnSequence{}; + void set_first_packet_on_sequence(bool value) { + static constexpr uint32_t field_id = FieldMetadata_FirstPacketOnSequence::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_MachineId = + ::protozero::proto_utils::FieldMetadata< + 98, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + TracePacket>; + + static constexpr FieldMetadata_MachineId kMachineId{}; + void set_machine_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_MachineId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class UiState_Decoder : public ::protozero::TypedProtoDecoder { + public: + UiState_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit UiState_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit UiState_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_timeline_start_ts() const { return at<1>().valid(); } + int64_t timeline_start_ts() const { return at<1>().as_int64(); } + bool has_timeline_end_ts() const { return at<2>().valid(); } + int64_t timeline_end_ts() const { return at<2>().as_int64(); } + bool has_highlight_process() const { return at<3>().valid(); } + ::protozero::ConstBytes highlight_process() const { return at<3>().as_bytes(); } +}; + +class UiState : public ::protozero::Message { + public: + using Decoder = UiState_Decoder; + enum : int32_t { + kTimelineStartTsFieldNumber = 1, + kTimelineEndTsFieldNumber = 2, + kHighlightProcessFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.UiState"; } + + using HighlightProcess = ::perfetto::protos::pbzero::UiState_HighlightProcess; + + using FieldMetadata_TimelineStartTs = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + UiState>; + + static constexpr FieldMetadata_TimelineStartTs kTimelineStartTs{}; + void set_timeline_start_ts(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_TimelineStartTs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TimelineEndTs = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + UiState>; + + static constexpr FieldMetadata_TimelineEndTs kTimelineEndTs{}; + void set_timeline_end_ts(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_TimelineEndTs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_HighlightProcess = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + UiState_HighlightProcess, + UiState>; + + static constexpr FieldMetadata_HighlightProcess kHighlightProcess{}; + template T* set_highlight_process() { + return BeginNestedMessage(3); + } + +}; + +class UiState_HighlightProcess_Decoder : public ::protozero::TypedProtoDecoder { + public: + UiState_HighlightProcess_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit UiState_HighlightProcess_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit UiState_HighlightProcess_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_pid() const { return at<1>().valid(); } + uint32_t pid() const { return at<1>().as_uint32(); } + bool has_cmdline() const { return at<2>().valid(); } + ::protozero::ConstChars cmdline() const { return at<2>().as_string(); } +}; + +class UiState_HighlightProcess : public ::protozero::Message { + public: + using Decoder = UiState_HighlightProcess_Decoder; + enum : int32_t { + kPidFieldNumber = 1, + kCmdlineFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.UiState.HighlightProcess"; } + + + using FieldMetadata_Pid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + UiState_HighlightProcess>; + + static constexpr FieldMetadata_Pid kPid{}; + void set_pid(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Cmdline = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + UiState_HighlightProcess>; + + static constexpr FieldMetadata_Cmdline kCmdline{}; + void set_cmdline(const char* data, size_t size) { + AppendBytes(FieldMetadata_Cmdline::kFieldId, data, size); + } + void set_cmdline(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Cmdline::kFieldId, chars.data, chars.size); + } + void set_cmdline(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Cmdline::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class Trigger_Decoder : public ::protozero::TypedProtoDecoder { + public: + Trigger_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Trigger_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Trigger_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_trigger_name() const { return at<1>().valid(); } + ::protozero::ConstChars trigger_name() const { return at<1>().as_string(); } + bool has_producer_name() const { return at<2>().valid(); } + ::protozero::ConstChars producer_name() const { return at<2>().as_string(); } + bool has_trusted_producer_uid() const { return at<3>().valid(); } + int32_t trusted_producer_uid() const { return at<3>().as_int32(); } +}; + +class Trigger : public ::protozero::Message { + public: + using Decoder = Trigger_Decoder; + enum : int32_t { + kTriggerNameFieldNumber = 1, + kProducerNameFieldNumber = 2, + kTrustedProducerUidFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Trigger"; } + + + using FieldMetadata_TriggerName = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + Trigger>; + + static constexpr FieldMetadata_TriggerName kTriggerName{}; + void set_trigger_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_TriggerName::kFieldId, data, size); + } + void set_trigger_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_TriggerName::kFieldId, chars.data, chars.size); + } + void set_trigger_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_TriggerName::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ProducerName = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + Trigger>; + + static constexpr FieldMetadata_ProducerName kProducerName{}; + void set_producer_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_ProducerName::kFieldId, data, size); + } + void set_producer_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_ProducerName::kFieldId, chars.data, chars.size); + } + void set_producer_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_ProducerName::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TrustedProducerUid = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Trigger>; + + static constexpr FieldMetadata_TrustedProducerUid kTrustedProducerUid{}; + void set_trusted_producer_uid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TrustedProducerUid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class SliceNameTranslationTable_Decoder : public ::protozero::TypedProtoDecoder { + public: + SliceNameTranslationTable_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit SliceNameTranslationTable_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit SliceNameTranslationTable_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_raw_to_deobfuscated_name() const { return at<1>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> raw_to_deobfuscated_name() const { return GetRepeated<::protozero::ConstBytes>(1); } +}; + +class SliceNameTranslationTable : public ::protozero::Message { + public: + using Decoder = SliceNameTranslationTable_Decoder; + enum : int32_t { + kRawToDeobfuscatedNameFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.SliceNameTranslationTable"; } + + using RawToDeobfuscatedNameEntry = ::perfetto::protos::pbzero::SliceNameTranslationTable_RawToDeobfuscatedNameEntry; + + using FieldMetadata_RawToDeobfuscatedName = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + SliceNameTranslationTable_RawToDeobfuscatedNameEntry, + SliceNameTranslationTable>; + + static constexpr FieldMetadata_RawToDeobfuscatedName kRawToDeobfuscatedName{}; + template T* add_raw_to_deobfuscated_name() { + return BeginNestedMessage(1); + } + +}; + +class SliceNameTranslationTable_RawToDeobfuscatedNameEntry_Decoder : public ::protozero::TypedProtoDecoder { + public: + SliceNameTranslationTable_RawToDeobfuscatedNameEntry_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit SliceNameTranslationTable_RawToDeobfuscatedNameEntry_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit SliceNameTranslationTable_RawToDeobfuscatedNameEntry_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_key() const { return at<1>().valid(); } + ::protozero::ConstChars key() const { return at<1>().as_string(); } + bool has_value() const { return at<2>().valid(); } + ::protozero::ConstChars value() const { return at<2>().as_string(); } +}; + +class SliceNameTranslationTable_RawToDeobfuscatedNameEntry : public ::protozero::Message { + public: + using Decoder = SliceNameTranslationTable_RawToDeobfuscatedNameEntry_Decoder; + enum : int32_t { + kKeyFieldNumber = 1, + kValueFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.SliceNameTranslationTable.RawToDeobfuscatedNameEntry"; } + + + using FieldMetadata_Key = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + SliceNameTranslationTable_RawToDeobfuscatedNameEntry>; + + static constexpr FieldMetadata_Key kKey{}; + void set_key(const char* data, size_t size) { + AppendBytes(FieldMetadata_Key::kFieldId, data, size); + } + void set_key(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Key::kFieldId, chars.data, chars.size); + } + void set_key(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Key::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Value = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + SliceNameTranslationTable_RawToDeobfuscatedNameEntry>; + + static constexpr FieldMetadata_Value kValue{}; + void set_value(const char* data, size_t size) { + AppendBytes(FieldMetadata_Value::kFieldId, data, size); + } + void set_value(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Value::kFieldId, chars.data, chars.size); + } + void set_value(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class ChromePerformanceMarkTranslationTable_Decoder : public ::protozero::TypedProtoDecoder { + public: + ChromePerformanceMarkTranslationTable_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ChromePerformanceMarkTranslationTable_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ChromePerformanceMarkTranslationTable_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_site_hash_to_name() const { return at<1>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> site_hash_to_name() const { return GetRepeated<::protozero::ConstBytes>(1); } + bool has_mark_hash_to_name() const { return at<2>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> mark_hash_to_name() const { return GetRepeated<::protozero::ConstBytes>(2); } +}; + +class ChromePerformanceMarkTranslationTable : public ::protozero::Message { + public: + using Decoder = ChromePerformanceMarkTranslationTable_Decoder; + enum : int32_t { + kSiteHashToNameFieldNumber = 1, + kMarkHashToNameFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ChromePerformanceMarkTranslationTable"; } + + using SiteHashToNameEntry = ::perfetto::protos::pbzero::ChromePerformanceMarkTranslationTable_SiteHashToNameEntry; + using MarkHashToNameEntry = ::perfetto::protos::pbzero::ChromePerformanceMarkTranslationTable_MarkHashToNameEntry; + + using FieldMetadata_SiteHashToName = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ChromePerformanceMarkTranslationTable_SiteHashToNameEntry, + ChromePerformanceMarkTranslationTable>; + + static constexpr FieldMetadata_SiteHashToName kSiteHashToName{}; + template T* add_site_hash_to_name() { + return BeginNestedMessage(1); + } + + + using FieldMetadata_MarkHashToName = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ChromePerformanceMarkTranslationTable_MarkHashToNameEntry, + ChromePerformanceMarkTranslationTable>; + + static constexpr FieldMetadata_MarkHashToName kMarkHashToName{}; + template T* add_mark_hash_to_name() { + return BeginNestedMessage(2); + } + +}; + +class ChromePerformanceMarkTranslationTable_MarkHashToNameEntry_Decoder : public ::protozero::TypedProtoDecoder { + public: + ChromePerformanceMarkTranslationTable_MarkHashToNameEntry_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ChromePerformanceMarkTranslationTable_MarkHashToNameEntry_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ChromePerformanceMarkTranslationTable_MarkHashToNameEntry_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_key() const { return at<1>().valid(); } + uint32_t key() const { return at<1>().as_uint32(); } + bool has_value() const { return at<2>().valid(); } + ::protozero::ConstChars value() const { return at<2>().as_string(); } +}; + +class ChromePerformanceMarkTranslationTable_MarkHashToNameEntry : public ::protozero::Message { + public: + using Decoder = ChromePerformanceMarkTranslationTable_MarkHashToNameEntry_Decoder; + enum : int32_t { + kKeyFieldNumber = 1, + kValueFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ChromePerformanceMarkTranslationTable.MarkHashToNameEntry"; } + + + using FieldMetadata_Key = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + ChromePerformanceMarkTranslationTable_MarkHashToNameEntry>; + + static constexpr FieldMetadata_Key kKey{}; + void set_key(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Key::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Value = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + ChromePerformanceMarkTranslationTable_MarkHashToNameEntry>; + + static constexpr FieldMetadata_Value kValue{}; + void set_value(const char* data, size_t size) { + AppendBytes(FieldMetadata_Value::kFieldId, data, size); + } + void set_value(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Value::kFieldId, chars.data, chars.size); + } + void set_value(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class ChromePerformanceMarkTranslationTable_SiteHashToNameEntry_Decoder : public ::protozero::TypedProtoDecoder { + public: + ChromePerformanceMarkTranslationTable_SiteHashToNameEntry_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ChromePerformanceMarkTranslationTable_SiteHashToNameEntry_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ChromePerformanceMarkTranslationTable_SiteHashToNameEntry_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_key() const { return at<1>().valid(); } + uint32_t key() const { return at<1>().as_uint32(); } + bool has_value() const { return at<2>().valid(); } + ::protozero::ConstChars value() const { return at<2>().as_string(); } +}; + +class ChromePerformanceMarkTranslationTable_SiteHashToNameEntry : public ::protozero::Message { + public: + using Decoder = ChromePerformanceMarkTranslationTable_SiteHashToNameEntry_Decoder; + enum : int32_t { + kKeyFieldNumber = 1, + kValueFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ChromePerformanceMarkTranslationTable.SiteHashToNameEntry"; } + + + using FieldMetadata_Key = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + ChromePerformanceMarkTranslationTable_SiteHashToNameEntry>; + + static constexpr FieldMetadata_Key kKey{}; + void set_key(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Key::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Value = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + ChromePerformanceMarkTranslationTable_SiteHashToNameEntry>; + + static constexpr FieldMetadata_Value kValue{}; + void set_value(const char* data, size_t size) { + AppendBytes(FieldMetadata_Value::kFieldId, data, size); + } + void set_value(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Value::kFieldId, chars.data, chars.size); + } + void set_value(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class ChromeUserEventTranslationTable_Decoder : public ::protozero::TypedProtoDecoder { + public: + ChromeUserEventTranslationTable_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ChromeUserEventTranslationTable_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ChromeUserEventTranslationTable_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_action_hash_to_name() const { return at<1>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> action_hash_to_name() const { return GetRepeated<::protozero::ConstBytes>(1); } +}; + +class ChromeUserEventTranslationTable : public ::protozero::Message { + public: + using Decoder = ChromeUserEventTranslationTable_Decoder; + enum : int32_t { + kActionHashToNameFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ChromeUserEventTranslationTable"; } + + using ActionHashToNameEntry = ::perfetto::protos::pbzero::ChromeUserEventTranslationTable_ActionHashToNameEntry; + + using FieldMetadata_ActionHashToName = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ChromeUserEventTranslationTable_ActionHashToNameEntry, + ChromeUserEventTranslationTable>; + + static constexpr FieldMetadata_ActionHashToName kActionHashToName{}; + template T* add_action_hash_to_name() { + return BeginNestedMessage(1); + } + +}; + +class ChromeUserEventTranslationTable_ActionHashToNameEntry_Decoder : public ::protozero::TypedProtoDecoder { + public: + ChromeUserEventTranslationTable_ActionHashToNameEntry_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ChromeUserEventTranslationTable_ActionHashToNameEntry_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ChromeUserEventTranslationTable_ActionHashToNameEntry_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_key() const { return at<1>().valid(); } + uint64_t key() const { return at<1>().as_uint64(); } + bool has_value() const { return at<2>().valid(); } + ::protozero::ConstChars value() const { return at<2>().as_string(); } +}; + +class ChromeUserEventTranslationTable_ActionHashToNameEntry : public ::protozero::Message { + public: + using Decoder = ChromeUserEventTranslationTable_ActionHashToNameEntry_Decoder; + enum : int32_t { + kKeyFieldNumber = 1, + kValueFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ChromeUserEventTranslationTable.ActionHashToNameEntry"; } + + + using FieldMetadata_Key = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + ChromeUserEventTranslationTable_ActionHashToNameEntry>; + + static constexpr FieldMetadata_Key kKey{}; + void set_key(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Key::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Value = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + ChromeUserEventTranslationTable_ActionHashToNameEntry>; + + static constexpr FieldMetadata_Value kValue{}; + void set_value(const char* data, size_t size) { + AppendBytes(FieldMetadata_Value::kFieldId, data, size); + } + void set_value(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Value::kFieldId, chars.data, chars.size); + } + void set_value(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class ChromeHistorgramTranslationTable_Decoder : public ::protozero::TypedProtoDecoder { + public: + ChromeHistorgramTranslationTable_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ChromeHistorgramTranslationTable_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ChromeHistorgramTranslationTable_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_hash_to_name() const { return at<1>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> hash_to_name() const { return GetRepeated<::protozero::ConstBytes>(1); } +}; + +class ChromeHistorgramTranslationTable : public ::protozero::Message { + public: + using Decoder = ChromeHistorgramTranslationTable_Decoder; + enum : int32_t { + kHashToNameFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ChromeHistorgramTranslationTable"; } + + using HashToNameEntry = ::perfetto::protos::pbzero::ChromeHistorgramTranslationTable_HashToNameEntry; + + using FieldMetadata_HashToName = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ChromeHistorgramTranslationTable_HashToNameEntry, + ChromeHistorgramTranslationTable>; + + static constexpr FieldMetadata_HashToName kHashToName{}; + template T* add_hash_to_name() { + return BeginNestedMessage(1); + } + +}; + +class ChromeHistorgramTranslationTable_HashToNameEntry_Decoder : public ::protozero::TypedProtoDecoder { + public: + ChromeHistorgramTranslationTable_HashToNameEntry_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ChromeHistorgramTranslationTable_HashToNameEntry_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ChromeHistorgramTranslationTable_HashToNameEntry_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_key() const { return at<1>().valid(); } + uint64_t key() const { return at<1>().as_uint64(); } + bool has_value() const { return at<2>().valid(); } + ::protozero::ConstChars value() const { return at<2>().as_string(); } +}; + +class ChromeHistorgramTranslationTable_HashToNameEntry : public ::protozero::Message { + public: + using Decoder = ChromeHistorgramTranslationTable_HashToNameEntry_Decoder; + enum : int32_t { + kKeyFieldNumber = 1, + kValueFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ChromeHistorgramTranslationTable.HashToNameEntry"; } + + + using FieldMetadata_Key = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + ChromeHistorgramTranslationTable_HashToNameEntry>; + + static constexpr FieldMetadata_Key kKey{}; + void set_key(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Key::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Value = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + ChromeHistorgramTranslationTable_HashToNameEntry>; + + static constexpr FieldMetadata_Value kValue{}; + void set_value(const char* data, size_t size) { + AppendBytes(FieldMetadata_Value::kFieldId, data, size); + } + void set_value(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Value::kFieldId, chars.data, chars.size); + } + void set_value(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class TranslationTable_Decoder : public ::protozero::TypedProtoDecoder { + public: + TranslationTable_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TranslationTable_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TranslationTable_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_chrome_histogram() const { return at<1>().valid(); } + ::protozero::ConstBytes chrome_histogram() const { return at<1>().as_bytes(); } + bool has_chrome_user_event() const { return at<2>().valid(); } + ::protozero::ConstBytes chrome_user_event() const { return at<2>().as_bytes(); } + bool has_chrome_performance_mark() const { return at<3>().valid(); } + ::protozero::ConstBytes chrome_performance_mark() const { return at<3>().as_bytes(); } + bool has_slice_name() const { return at<4>().valid(); } + ::protozero::ConstBytes slice_name() const { return at<4>().as_bytes(); } +}; + +class TranslationTable : public ::protozero::Message { + public: + using Decoder = TranslationTable_Decoder; + enum : int32_t { + kChromeHistogramFieldNumber = 1, + kChromeUserEventFieldNumber = 2, + kChromePerformanceMarkFieldNumber = 3, + kSliceNameFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.TranslationTable"; } + + + using FieldMetadata_ChromeHistogram = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ChromeHistorgramTranslationTable, + TranslationTable>; + + static constexpr FieldMetadata_ChromeHistogram kChromeHistogram{}; + template T* set_chrome_histogram() { + return BeginNestedMessage(1); + } + + + using FieldMetadata_ChromeUserEvent = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ChromeUserEventTranslationTable, + TranslationTable>; + + static constexpr FieldMetadata_ChromeUserEvent kChromeUserEvent{}; + template T* set_chrome_user_event() { + return BeginNestedMessage(2); + } + + + using FieldMetadata_ChromePerformanceMark = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ChromePerformanceMarkTranslationTable, + TranslationTable>; + + static constexpr FieldMetadata_ChromePerformanceMark kChromePerformanceMark{}; + template T* set_chrome_performance_mark() { + return BeginNestedMessage(3); + } + + + using FieldMetadata_SliceName = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + SliceNameTranslationTable, + TranslationTable>; + + static constexpr FieldMetadata_SliceName kSliceName{}; + template T* set_slice_name() { + return BeginNestedMessage(4); + } + +}; + +class TrackDescriptor_Decoder : public ::protozero::TypedProtoDecoder { + public: + TrackDescriptor_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TrackDescriptor_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TrackDescriptor_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_uuid() const { return at<1>().valid(); } + uint64_t uuid() const { return at<1>().as_uint64(); } + bool has_parent_uuid() const { return at<5>().valid(); } + uint64_t parent_uuid() const { return at<5>().as_uint64(); } + bool has_name() const { return at<2>().valid(); } + ::protozero::ConstChars name() const { return at<2>().as_string(); } + bool has_process() const { return at<3>().valid(); } + ::protozero::ConstBytes process() const { return at<3>().as_bytes(); } + bool has_chrome_process() const { return at<6>().valid(); } + ::protozero::ConstBytes chrome_process() const { return at<6>().as_bytes(); } + bool has_thread() const { return at<4>().valid(); } + ::protozero::ConstBytes thread() const { return at<4>().as_bytes(); } + bool has_chrome_thread() const { return at<7>().valid(); } + ::protozero::ConstBytes chrome_thread() const { return at<7>().as_bytes(); } + bool has_counter() const { return at<8>().valid(); } + ::protozero::ConstBytes counter() const { return at<8>().as_bytes(); } + bool has_disallow_merging_with_system_tracks() const { return at<9>().valid(); } + bool disallow_merging_with_system_tracks() const { return at<9>().as_bool(); } +}; + +class TrackDescriptor : public ::protozero::Message { + public: + using Decoder = TrackDescriptor_Decoder; + enum : int32_t { + kUuidFieldNumber = 1, + kParentUuidFieldNumber = 5, + kNameFieldNumber = 2, + kProcessFieldNumber = 3, + kChromeProcessFieldNumber = 6, + kThreadFieldNumber = 4, + kChromeThreadFieldNumber = 7, + kCounterFieldNumber = 8, + kDisallowMergingWithSystemTracksFieldNumber = 9, + }; + static constexpr const char* GetName() { return ".perfetto.protos.TrackDescriptor"; } + + + using FieldMetadata_Uuid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TrackDescriptor>; + + static constexpr FieldMetadata_Uuid kUuid{}; + void set_uuid(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Uuid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ParentUuid = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TrackDescriptor>; + + static constexpr FieldMetadata_ParentUuid kParentUuid{}; + void set_parent_uuid(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_ParentUuid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + TrackDescriptor>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Process = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ProcessDescriptor, + TrackDescriptor>; + + static constexpr FieldMetadata_Process kProcess{}; + template T* set_process() { + return BeginNestedMessage(3); + } + + + using FieldMetadata_ChromeProcess = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ChromeProcessDescriptor, + TrackDescriptor>; + + static constexpr FieldMetadata_ChromeProcess kChromeProcess{}; + template T* set_chrome_process() { + return BeginNestedMessage(6); + } + + + using FieldMetadata_Thread = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ThreadDescriptor, + TrackDescriptor>; + + static constexpr FieldMetadata_Thread kThread{}; + template T* set_thread() { + return BeginNestedMessage(4); + } + + + using FieldMetadata_ChromeThread = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ChromeThreadDescriptor, + TrackDescriptor>; + + static constexpr FieldMetadata_ChromeThread kChromeThread{}; + template T* set_chrome_thread() { + return BeginNestedMessage(7); + } + + + using FieldMetadata_Counter = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + CounterDescriptor, + TrackDescriptor>; + + static constexpr FieldMetadata_Counter kCounter{}; + template T* set_counter() { + return BeginNestedMessage(8); + } + + + using FieldMetadata_DisallowMergingWithSystemTracks = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + TrackDescriptor>; + + static constexpr FieldMetadata_DisallowMergingWithSystemTracks kDisallowMergingWithSystemTracks{}; + void set_disallow_merging_with_system_tracks(bool value) { + static constexpr uint32_t field_id = FieldMetadata_DisallowMergingWithSystemTracks::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } +}; + +class CounterDescriptor_Decoder : public ::protozero::TypedProtoDecoder { + public: + CounterDescriptor_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit CounterDescriptor_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit CounterDescriptor_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_type() const { return at<1>().valid(); } + int32_t type() const { return at<1>().as_int32(); } + bool has_categories() const { return at<2>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstChars> categories() const { return GetRepeated<::protozero::ConstChars>(2); } + bool has_unit() const { return at<3>().valid(); } + int32_t unit() const { return at<3>().as_int32(); } + bool has_unit_name() const { return at<6>().valid(); } + ::protozero::ConstChars unit_name() const { return at<6>().as_string(); } + bool has_unit_multiplier() const { return at<4>().valid(); } + int64_t unit_multiplier() const { return at<4>().as_int64(); } + bool has_is_incremental() const { return at<5>().valid(); } + bool is_incremental() const { return at<5>().as_bool(); } +}; + +class CounterDescriptor : public ::protozero::Message { + public: + using Decoder = CounterDescriptor_Decoder; + enum : int32_t { + kTypeFieldNumber = 1, + kCategoriesFieldNumber = 2, + kUnitFieldNumber = 3, + kUnitNameFieldNumber = 6, + kUnitMultiplierFieldNumber = 4, + kIsIncrementalFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.CounterDescriptor"; } + + + using BuiltinCounterType = ::perfetto::protos::pbzero::CounterDescriptor_BuiltinCounterType; + static inline const char* BuiltinCounterType_Name(BuiltinCounterType value) { + return ::perfetto::protos::pbzero::CounterDescriptor_BuiltinCounterType_Name(value); + } + + using Unit = ::perfetto::protos::pbzero::CounterDescriptor_Unit; + static inline const char* Unit_Name(Unit value) { + return ::perfetto::protos::pbzero::CounterDescriptor_Unit_Name(value); + } + static inline const BuiltinCounterType COUNTER_UNSPECIFIED = BuiltinCounterType::COUNTER_UNSPECIFIED; + static inline const BuiltinCounterType COUNTER_THREAD_TIME_NS = BuiltinCounterType::COUNTER_THREAD_TIME_NS; + static inline const BuiltinCounterType COUNTER_THREAD_INSTRUCTION_COUNT = BuiltinCounterType::COUNTER_THREAD_INSTRUCTION_COUNT; + static inline const Unit UNIT_UNSPECIFIED = Unit::UNIT_UNSPECIFIED; + static inline const Unit UNIT_TIME_NS = Unit::UNIT_TIME_NS; + static inline const Unit UNIT_COUNT = Unit::UNIT_COUNT; + static inline const Unit UNIT_SIZE_BYTES = Unit::UNIT_SIZE_BYTES; + + using FieldMetadata_Type = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + CounterDescriptor_BuiltinCounterType, + CounterDescriptor>; + + static constexpr FieldMetadata_Type kType{}; + void set_type(CounterDescriptor_BuiltinCounterType value) { + static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Categories = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + CounterDescriptor>; + + static constexpr FieldMetadata_Categories kCategories{}; + void add_categories(const char* data, size_t size) { + AppendBytes(FieldMetadata_Categories::kFieldId, data, size); + } + void add_categories(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Categories::kFieldId, chars.data, chars.size); + } + void add_categories(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Categories::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Unit = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + CounterDescriptor_Unit, + CounterDescriptor>; + + static constexpr FieldMetadata_Unit kUnit{}; + void set_unit(CounterDescriptor_Unit value) { + static constexpr uint32_t field_id = FieldMetadata_Unit::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_UnitName = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + CounterDescriptor>; + + static constexpr FieldMetadata_UnitName kUnitName{}; + void set_unit_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_UnitName::kFieldId, data, size); + } + void set_unit_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_UnitName::kFieldId, chars.data, chars.size); + } + void set_unit_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_UnitName::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_UnitMultiplier = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + CounterDescriptor>; + + static constexpr FieldMetadata_UnitMultiplier kUnitMultiplier{}; + void set_unit_multiplier(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_UnitMultiplier::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_IsIncremental = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + CounterDescriptor>; + + static constexpr FieldMetadata_IsIncremental kIsIncremental{}; + void set_is_incremental(bool value) { + static constexpr uint32_t field_id = FieldMetadata_IsIncremental::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } +}; + +class ChromeThreadDescriptor_Decoder : public ::protozero::TypedProtoDecoder { + public: + ChromeThreadDescriptor_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ChromeThreadDescriptor_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ChromeThreadDescriptor_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_thread_type() const { return at<1>().valid(); } + int32_t thread_type() const { return at<1>().as_int32(); } + bool has_legacy_sort_index() const { return at<2>().valid(); } + int32_t legacy_sort_index() const { return at<2>().as_int32(); } +}; + +class ChromeThreadDescriptor : public ::protozero::Message { + public: + using Decoder = ChromeThreadDescriptor_Decoder; + enum : int32_t { + kThreadTypeFieldNumber = 1, + kLegacySortIndexFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ChromeThreadDescriptor"; } + + + using ThreadType = ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType; + static inline const char* ThreadType_Name(ThreadType value) { + return ::perfetto::protos::pbzero::ChromeThreadDescriptor_ThreadType_Name(value); + } + static inline const ThreadType THREAD_UNSPECIFIED = ThreadType::THREAD_UNSPECIFIED; + static inline const ThreadType THREAD_MAIN = ThreadType::THREAD_MAIN; + static inline const ThreadType THREAD_IO = ThreadType::THREAD_IO; + static inline const ThreadType THREAD_POOL_BG_WORKER = ThreadType::THREAD_POOL_BG_WORKER; + static inline const ThreadType THREAD_POOL_FG_WORKER = ThreadType::THREAD_POOL_FG_WORKER; + static inline const ThreadType THREAD_POOL_FG_BLOCKING = ThreadType::THREAD_POOL_FG_BLOCKING; + static inline const ThreadType THREAD_POOL_BG_BLOCKING = ThreadType::THREAD_POOL_BG_BLOCKING; + static inline const ThreadType THREAD_POOL_SERVICE = ThreadType::THREAD_POOL_SERVICE; + static inline const ThreadType THREAD_COMPOSITOR = ThreadType::THREAD_COMPOSITOR; + static inline const ThreadType THREAD_VIZ_COMPOSITOR = ThreadType::THREAD_VIZ_COMPOSITOR; + static inline const ThreadType THREAD_COMPOSITOR_WORKER = ThreadType::THREAD_COMPOSITOR_WORKER; + static inline const ThreadType THREAD_SERVICE_WORKER = ThreadType::THREAD_SERVICE_WORKER; + static inline const ThreadType THREAD_NETWORK_SERVICE = ThreadType::THREAD_NETWORK_SERVICE; + static inline const ThreadType THREAD_CHILD_IO = ThreadType::THREAD_CHILD_IO; + static inline const ThreadType THREAD_BROWSER_IO = ThreadType::THREAD_BROWSER_IO; + static inline const ThreadType THREAD_BROWSER_MAIN = ThreadType::THREAD_BROWSER_MAIN; + static inline const ThreadType THREAD_RENDERER_MAIN = ThreadType::THREAD_RENDERER_MAIN; + static inline const ThreadType THREAD_UTILITY_MAIN = ThreadType::THREAD_UTILITY_MAIN; + static inline const ThreadType THREAD_GPU_MAIN = ThreadType::THREAD_GPU_MAIN; + static inline const ThreadType THREAD_CACHE_BLOCKFILE = ThreadType::THREAD_CACHE_BLOCKFILE; + static inline const ThreadType THREAD_MEDIA = ThreadType::THREAD_MEDIA; + static inline const ThreadType THREAD_AUDIO_OUTPUTDEVICE = ThreadType::THREAD_AUDIO_OUTPUTDEVICE; + static inline const ThreadType THREAD_AUDIO_INPUTDEVICE = ThreadType::THREAD_AUDIO_INPUTDEVICE; + static inline const ThreadType THREAD_GPU_MEMORY = ThreadType::THREAD_GPU_MEMORY; + static inline const ThreadType THREAD_GPU_VSYNC = ThreadType::THREAD_GPU_VSYNC; + static inline const ThreadType THREAD_DXA_VIDEODECODER = ThreadType::THREAD_DXA_VIDEODECODER; + static inline const ThreadType THREAD_BROWSER_WATCHDOG = ThreadType::THREAD_BROWSER_WATCHDOG; + static inline const ThreadType THREAD_WEBRTC_NETWORK = ThreadType::THREAD_WEBRTC_NETWORK; + static inline const ThreadType THREAD_WINDOW_OWNER = ThreadType::THREAD_WINDOW_OWNER; + static inline const ThreadType THREAD_WEBRTC_SIGNALING = ThreadType::THREAD_WEBRTC_SIGNALING; + static inline const ThreadType THREAD_WEBRTC_WORKER = ThreadType::THREAD_WEBRTC_WORKER; + static inline const ThreadType THREAD_PPAPI_MAIN = ThreadType::THREAD_PPAPI_MAIN; + static inline const ThreadType THREAD_GPU_WATCHDOG = ThreadType::THREAD_GPU_WATCHDOG; + static inline const ThreadType THREAD_SWAPPER = ThreadType::THREAD_SWAPPER; + static inline const ThreadType THREAD_GAMEPAD_POLLING = ThreadType::THREAD_GAMEPAD_POLLING; + static inline const ThreadType THREAD_WEBCRYPTO = ThreadType::THREAD_WEBCRYPTO; + static inline const ThreadType THREAD_DATABASE = ThreadType::THREAD_DATABASE; + static inline const ThreadType THREAD_PROXYRESOLVER = ThreadType::THREAD_PROXYRESOLVER; + static inline const ThreadType THREAD_DEVTOOLSADB = ThreadType::THREAD_DEVTOOLSADB; + static inline const ThreadType THREAD_NETWORKCONFIGWATCHER = ThreadType::THREAD_NETWORKCONFIGWATCHER; + static inline const ThreadType THREAD_WASAPI_RENDER = ThreadType::THREAD_WASAPI_RENDER; + static inline const ThreadType THREAD_LOADER_LOCK_SAMPLER = ThreadType::THREAD_LOADER_LOCK_SAMPLER; + static inline const ThreadType THREAD_MEMORY_INFRA = ThreadType::THREAD_MEMORY_INFRA; + static inline const ThreadType THREAD_SAMPLING_PROFILER = ThreadType::THREAD_SAMPLING_PROFILER; + + using FieldMetadata_ThreadType = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + ChromeThreadDescriptor_ThreadType, + ChromeThreadDescriptor>; + + static constexpr FieldMetadata_ThreadType kThreadType{}; + void set_thread_type(ChromeThreadDescriptor_ThreadType value) { + static constexpr uint32_t field_id = FieldMetadata_ThreadType::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_LegacySortIndex = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + ChromeThreadDescriptor>; + + static constexpr FieldMetadata_LegacySortIndex kLegacySortIndex{}; + void set_legacy_sort_index(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_LegacySortIndex::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class ChromeProcessDescriptor_Decoder : public ::protozero::TypedProtoDecoder { + public: + ChromeProcessDescriptor_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ChromeProcessDescriptor_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ChromeProcessDescriptor_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_process_type() const { return at<1>().valid(); } + int32_t process_type() const { return at<1>().as_int32(); } + bool has_process_priority() const { return at<2>().valid(); } + int32_t process_priority() const { return at<2>().as_int32(); } + bool has_legacy_sort_index() const { return at<3>().valid(); } + int32_t legacy_sort_index() const { return at<3>().as_int32(); } + bool has_host_app_package_name() const { return at<4>().valid(); } + ::protozero::ConstChars host_app_package_name() const { return at<4>().as_string(); } + bool has_crash_trace_id() const { return at<5>().valid(); } + uint64_t crash_trace_id() const { return at<5>().as_uint64(); } +}; + +class ChromeProcessDescriptor : public ::protozero::Message { + public: + using Decoder = ChromeProcessDescriptor_Decoder; + enum : int32_t { + kProcessTypeFieldNumber = 1, + kProcessPriorityFieldNumber = 2, + kLegacySortIndexFieldNumber = 3, + kHostAppPackageNameFieldNumber = 4, + kCrashTraceIdFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ChromeProcessDescriptor"; } + + + using ProcessType = ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType; + static inline const char* ProcessType_Name(ProcessType value) { + return ::perfetto::protos::pbzero::ChromeProcessDescriptor_ProcessType_Name(value); + } + static inline const ProcessType PROCESS_UNSPECIFIED = ProcessType::PROCESS_UNSPECIFIED; + static inline const ProcessType PROCESS_BROWSER = ProcessType::PROCESS_BROWSER; + static inline const ProcessType PROCESS_RENDERER = ProcessType::PROCESS_RENDERER; + static inline const ProcessType PROCESS_UTILITY = ProcessType::PROCESS_UTILITY; + static inline const ProcessType PROCESS_ZYGOTE = ProcessType::PROCESS_ZYGOTE; + static inline const ProcessType PROCESS_SANDBOX_HELPER = ProcessType::PROCESS_SANDBOX_HELPER; + static inline const ProcessType PROCESS_GPU = ProcessType::PROCESS_GPU; + static inline const ProcessType PROCESS_PPAPI_PLUGIN = ProcessType::PROCESS_PPAPI_PLUGIN; + static inline const ProcessType PROCESS_PPAPI_BROKER = ProcessType::PROCESS_PPAPI_BROKER; + static inline const ProcessType PROCESS_SERVICE_NETWORK = ProcessType::PROCESS_SERVICE_NETWORK; + static inline const ProcessType PROCESS_SERVICE_TRACING = ProcessType::PROCESS_SERVICE_TRACING; + static inline const ProcessType PROCESS_SERVICE_STORAGE = ProcessType::PROCESS_SERVICE_STORAGE; + static inline const ProcessType PROCESS_SERVICE_AUDIO = ProcessType::PROCESS_SERVICE_AUDIO; + static inline const ProcessType PROCESS_SERVICE_DATA_DECODER = ProcessType::PROCESS_SERVICE_DATA_DECODER; + static inline const ProcessType PROCESS_SERVICE_UTIL_WIN = ProcessType::PROCESS_SERVICE_UTIL_WIN; + static inline const ProcessType PROCESS_SERVICE_PROXY_RESOLVER = ProcessType::PROCESS_SERVICE_PROXY_RESOLVER; + static inline const ProcessType PROCESS_SERVICE_CDM = ProcessType::PROCESS_SERVICE_CDM; + static inline const ProcessType PROCESS_SERVICE_VIDEO_CAPTURE = ProcessType::PROCESS_SERVICE_VIDEO_CAPTURE; + static inline const ProcessType PROCESS_SERVICE_UNZIPPER = ProcessType::PROCESS_SERVICE_UNZIPPER; + static inline const ProcessType PROCESS_SERVICE_MIRRORING = ProcessType::PROCESS_SERVICE_MIRRORING; + static inline const ProcessType PROCESS_SERVICE_FILEPATCHER = ProcessType::PROCESS_SERVICE_FILEPATCHER; + static inline const ProcessType PROCESS_SERVICE_TTS = ProcessType::PROCESS_SERVICE_TTS; + static inline const ProcessType PROCESS_SERVICE_PRINTING = ProcessType::PROCESS_SERVICE_PRINTING; + static inline const ProcessType PROCESS_SERVICE_QUARANTINE = ProcessType::PROCESS_SERVICE_QUARANTINE; + static inline const ProcessType PROCESS_SERVICE_CROS_LOCALSEARCH = ProcessType::PROCESS_SERVICE_CROS_LOCALSEARCH; + static inline const ProcessType PROCESS_SERVICE_CROS_ASSISTANT_AUDIO_DECODER = ProcessType::PROCESS_SERVICE_CROS_ASSISTANT_AUDIO_DECODER; + static inline const ProcessType PROCESS_SERVICE_FILEUTIL = ProcessType::PROCESS_SERVICE_FILEUTIL; + static inline const ProcessType PROCESS_SERVICE_PRINTCOMPOSITOR = ProcessType::PROCESS_SERVICE_PRINTCOMPOSITOR; + static inline const ProcessType PROCESS_SERVICE_PAINTPREVIEW = ProcessType::PROCESS_SERVICE_PAINTPREVIEW; + static inline const ProcessType PROCESS_SERVICE_SPEECHRECOGNITION = ProcessType::PROCESS_SERVICE_SPEECHRECOGNITION; + static inline const ProcessType PROCESS_SERVICE_XRDEVICE = ProcessType::PROCESS_SERVICE_XRDEVICE; + static inline const ProcessType PROCESS_SERVICE_READICON = ProcessType::PROCESS_SERVICE_READICON; + static inline const ProcessType PROCESS_SERVICE_LANGUAGEDETECTION = ProcessType::PROCESS_SERVICE_LANGUAGEDETECTION; + static inline const ProcessType PROCESS_SERVICE_SHARING = ProcessType::PROCESS_SERVICE_SHARING; + static inline const ProcessType PROCESS_SERVICE_MEDIAPARSER = ProcessType::PROCESS_SERVICE_MEDIAPARSER; + static inline const ProcessType PROCESS_SERVICE_QRCODEGENERATOR = ProcessType::PROCESS_SERVICE_QRCODEGENERATOR; + static inline const ProcessType PROCESS_SERVICE_PROFILEIMPORT = ProcessType::PROCESS_SERVICE_PROFILEIMPORT; + static inline const ProcessType PROCESS_SERVICE_IME = ProcessType::PROCESS_SERVICE_IME; + static inline const ProcessType PROCESS_SERVICE_RECORDING = ProcessType::PROCESS_SERVICE_RECORDING; + static inline const ProcessType PROCESS_SERVICE_SHAPEDETECTION = ProcessType::PROCESS_SERVICE_SHAPEDETECTION; + static inline const ProcessType PROCESS_RENDERER_EXTENSION = ProcessType::PROCESS_RENDERER_EXTENSION; + static inline const ProcessType PROCESS_SERVICE_MEDIA_FOUNDATION = ProcessType::PROCESS_SERVICE_MEDIA_FOUNDATION; + + using FieldMetadata_ProcessType = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + ChromeProcessDescriptor_ProcessType, + ChromeProcessDescriptor>; + + static constexpr FieldMetadata_ProcessType kProcessType{}; + void set_process_type(ChromeProcessDescriptor_ProcessType value) { + static constexpr uint32_t field_id = FieldMetadata_ProcessType::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ProcessPriority = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + ChromeProcessDescriptor>; + + static constexpr FieldMetadata_ProcessPriority kProcessPriority{}; + void set_process_priority(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ProcessPriority::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_LegacySortIndex = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + ChromeProcessDescriptor>; + + static constexpr FieldMetadata_LegacySortIndex kLegacySortIndex{}; + void set_legacy_sort_index(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_LegacySortIndex::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_HostAppPackageName = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + ChromeProcessDescriptor>; + + static constexpr FieldMetadata_HostAppPackageName kHostAppPackageName{}; + void set_host_app_package_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_HostAppPackageName::kFieldId, data, size); + } + void set_host_app_package_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_HostAppPackageName::kFieldId, chars.data, chars.size); + } + void set_host_app_package_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_HostAppPackageName::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CrashTraceId = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + ChromeProcessDescriptor>; + + static constexpr FieldMetadata_CrashTraceId kCrashTraceId{}; + void set_crash_trace_id(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_CrashTraceId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class ThreadDescriptor_Decoder : public ::protozero::TypedProtoDecoder { + public: + ThreadDescriptor_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ThreadDescriptor_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ThreadDescriptor_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_pid() const { return at<1>().valid(); } + int32_t pid() const { return at<1>().as_int32(); } + bool has_tid() const { return at<2>().valid(); } + int32_t tid() const { return at<2>().as_int32(); } + bool has_thread_name() const { return at<5>().valid(); } + ::protozero::ConstChars thread_name() const { return at<5>().as_string(); } + bool has_chrome_thread_type() const { return at<4>().valid(); } + int32_t chrome_thread_type() const { return at<4>().as_int32(); } + bool has_reference_timestamp_us() const { return at<6>().valid(); } + int64_t reference_timestamp_us() const { return at<6>().as_int64(); } + bool has_reference_thread_time_us() const { return at<7>().valid(); } + int64_t reference_thread_time_us() const { return at<7>().as_int64(); } + bool has_reference_thread_instruction_count() const { return at<8>().valid(); } + int64_t reference_thread_instruction_count() const { return at<8>().as_int64(); } + bool has_legacy_sort_index() const { return at<3>().valid(); } + int32_t legacy_sort_index() const { return at<3>().as_int32(); } +}; + +class ThreadDescriptor : public ::protozero::Message { + public: + using Decoder = ThreadDescriptor_Decoder; + enum : int32_t { + kPidFieldNumber = 1, + kTidFieldNumber = 2, + kThreadNameFieldNumber = 5, + kChromeThreadTypeFieldNumber = 4, + kReferenceTimestampUsFieldNumber = 6, + kReferenceThreadTimeUsFieldNumber = 7, + kReferenceThreadInstructionCountFieldNumber = 8, + kLegacySortIndexFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ThreadDescriptor"; } + + + using ChromeThreadType = ::perfetto::protos::pbzero::ThreadDescriptor_ChromeThreadType; + static inline const char* ChromeThreadType_Name(ChromeThreadType value) { + return ::perfetto::protos::pbzero::ThreadDescriptor_ChromeThreadType_Name(value); + } + static inline const ChromeThreadType CHROME_THREAD_UNSPECIFIED = ChromeThreadType::CHROME_THREAD_UNSPECIFIED; + static inline const ChromeThreadType CHROME_THREAD_MAIN = ChromeThreadType::CHROME_THREAD_MAIN; + static inline const ChromeThreadType CHROME_THREAD_IO = ChromeThreadType::CHROME_THREAD_IO; + static inline const ChromeThreadType CHROME_THREAD_POOL_BG_WORKER = ChromeThreadType::CHROME_THREAD_POOL_BG_WORKER; + static inline const ChromeThreadType CHROME_THREAD_POOL_FG_WORKER = ChromeThreadType::CHROME_THREAD_POOL_FG_WORKER; + static inline const ChromeThreadType CHROME_THREAD_POOL_FB_BLOCKING = ChromeThreadType::CHROME_THREAD_POOL_FB_BLOCKING; + static inline const ChromeThreadType CHROME_THREAD_POOL_BG_BLOCKING = ChromeThreadType::CHROME_THREAD_POOL_BG_BLOCKING; + static inline const ChromeThreadType CHROME_THREAD_POOL_SERVICE = ChromeThreadType::CHROME_THREAD_POOL_SERVICE; + static inline const ChromeThreadType CHROME_THREAD_COMPOSITOR = ChromeThreadType::CHROME_THREAD_COMPOSITOR; + static inline const ChromeThreadType CHROME_THREAD_VIZ_COMPOSITOR = ChromeThreadType::CHROME_THREAD_VIZ_COMPOSITOR; + static inline const ChromeThreadType CHROME_THREAD_COMPOSITOR_WORKER = ChromeThreadType::CHROME_THREAD_COMPOSITOR_WORKER; + static inline const ChromeThreadType CHROME_THREAD_SERVICE_WORKER = ChromeThreadType::CHROME_THREAD_SERVICE_WORKER; + static inline const ChromeThreadType CHROME_THREAD_MEMORY_INFRA = ChromeThreadType::CHROME_THREAD_MEMORY_INFRA; + static inline const ChromeThreadType CHROME_THREAD_SAMPLING_PROFILER = ChromeThreadType::CHROME_THREAD_SAMPLING_PROFILER; + + using FieldMetadata_Pid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + ThreadDescriptor>; + + static constexpr FieldMetadata_Pid kPid{}; + void set_pid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Tid = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + ThreadDescriptor>; + + static constexpr FieldMetadata_Tid kTid{}; + void set_tid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Tid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ThreadName = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + ThreadDescriptor>; + + static constexpr FieldMetadata_ThreadName kThreadName{}; + void set_thread_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_ThreadName::kFieldId, data, size); + } + void set_thread_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_ThreadName::kFieldId, chars.data, chars.size); + } + void set_thread_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_ThreadName::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ChromeThreadType = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + ThreadDescriptor_ChromeThreadType, + ThreadDescriptor>; + + static constexpr FieldMetadata_ChromeThreadType kChromeThreadType{}; + void set_chrome_thread_type(ThreadDescriptor_ChromeThreadType value) { + static constexpr uint32_t field_id = FieldMetadata_ChromeThreadType::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ReferenceTimestampUs = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + ThreadDescriptor>; + + static constexpr FieldMetadata_ReferenceTimestampUs kReferenceTimestampUs{}; + void set_reference_timestamp_us(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_ReferenceTimestampUs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ReferenceThreadTimeUs = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + ThreadDescriptor>; + + static constexpr FieldMetadata_ReferenceThreadTimeUs kReferenceThreadTimeUs{}; + void set_reference_thread_time_us(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_ReferenceThreadTimeUs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ReferenceThreadInstructionCount = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + ThreadDescriptor>; + + static constexpr FieldMetadata_ReferenceThreadInstructionCount kReferenceThreadInstructionCount{}; + void set_reference_thread_instruction_count(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_ReferenceThreadInstructionCount::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_LegacySortIndex = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + ThreadDescriptor>; + + static constexpr FieldMetadata_LegacySortIndex kLegacySortIndex{}; + void set_legacy_sort_index(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_LegacySortIndex::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class TrackEventRangeOfInterest_Decoder : public ::protozero::TypedProtoDecoder { + public: + TrackEventRangeOfInterest_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TrackEventRangeOfInterest_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TrackEventRangeOfInterest_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_start_us() const { return at<1>().valid(); } + int64_t start_us() const { return at<1>().as_int64(); } +}; + +class TrackEventRangeOfInterest : public ::protozero::Message { + public: + using Decoder = TrackEventRangeOfInterest_Decoder; + enum : int32_t { + kStartUsFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.TrackEventRangeOfInterest"; } + + + using FieldMetadata_StartUs = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + TrackEventRangeOfInterest>; + + static constexpr FieldMetadata_StartUs kStartUs{}; + void set_start_us(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_StartUs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } +}; + +class ProcessDescriptor_Decoder : public ::protozero::TypedProtoDecoder { + public: + ProcessDescriptor_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ProcessDescriptor_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ProcessDescriptor_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_pid() const { return at<1>().valid(); } + int32_t pid() const { return at<1>().as_int32(); } + bool has_cmdline() const { return at<2>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstChars> cmdline() const { return GetRepeated<::protozero::ConstChars>(2); } + bool has_process_name() const { return at<6>().valid(); } + ::protozero::ConstChars process_name() const { return at<6>().as_string(); } + bool has_process_priority() const { return at<5>().valid(); } + int32_t process_priority() const { return at<5>().as_int32(); } + bool has_start_timestamp_ns() const { return at<7>().valid(); } + int64_t start_timestamp_ns() const { return at<7>().as_int64(); } + bool has_chrome_process_type() const { return at<4>().valid(); } + int32_t chrome_process_type() const { return at<4>().as_int32(); } + bool has_legacy_sort_index() const { return at<3>().valid(); } + int32_t legacy_sort_index() const { return at<3>().as_int32(); } + bool has_process_labels() const { return at<8>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstChars> process_labels() const { return GetRepeated<::protozero::ConstChars>(8); } +}; + +class ProcessDescriptor : public ::protozero::Message { + public: + using Decoder = ProcessDescriptor_Decoder; + enum : int32_t { + kPidFieldNumber = 1, + kCmdlineFieldNumber = 2, + kProcessNameFieldNumber = 6, + kProcessPriorityFieldNumber = 5, + kStartTimestampNsFieldNumber = 7, + kChromeProcessTypeFieldNumber = 4, + kLegacySortIndexFieldNumber = 3, + kProcessLabelsFieldNumber = 8, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ProcessDescriptor"; } + + + using ChromeProcessType = ::perfetto::protos::pbzero::ProcessDescriptor_ChromeProcessType; + static inline const char* ChromeProcessType_Name(ChromeProcessType value) { + return ::perfetto::protos::pbzero::ProcessDescriptor_ChromeProcessType_Name(value); + } + static inline const ChromeProcessType PROCESS_UNSPECIFIED = ChromeProcessType::PROCESS_UNSPECIFIED; + static inline const ChromeProcessType PROCESS_BROWSER = ChromeProcessType::PROCESS_BROWSER; + static inline const ChromeProcessType PROCESS_RENDERER = ChromeProcessType::PROCESS_RENDERER; + static inline const ChromeProcessType PROCESS_UTILITY = ChromeProcessType::PROCESS_UTILITY; + static inline const ChromeProcessType PROCESS_ZYGOTE = ChromeProcessType::PROCESS_ZYGOTE; + static inline const ChromeProcessType PROCESS_SANDBOX_HELPER = ChromeProcessType::PROCESS_SANDBOX_HELPER; + static inline const ChromeProcessType PROCESS_GPU = ChromeProcessType::PROCESS_GPU; + static inline const ChromeProcessType PROCESS_PPAPI_PLUGIN = ChromeProcessType::PROCESS_PPAPI_PLUGIN; + static inline const ChromeProcessType PROCESS_PPAPI_BROKER = ChromeProcessType::PROCESS_PPAPI_BROKER; + + using FieldMetadata_Pid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + ProcessDescriptor>; + + static constexpr FieldMetadata_Pid kPid{}; + void set_pid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Cmdline = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + ProcessDescriptor>; + + static constexpr FieldMetadata_Cmdline kCmdline{}; + void add_cmdline(const char* data, size_t size) { + AppendBytes(FieldMetadata_Cmdline::kFieldId, data, size); + } + void add_cmdline(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Cmdline::kFieldId, chars.data, chars.size); + } + void add_cmdline(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Cmdline::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ProcessName = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + ProcessDescriptor>; + + static constexpr FieldMetadata_ProcessName kProcessName{}; + void set_process_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_ProcessName::kFieldId, data, size); + } + void set_process_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_ProcessName::kFieldId, chars.data, chars.size); + } + void set_process_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_ProcessName::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ProcessPriority = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + ProcessDescriptor>; + + static constexpr FieldMetadata_ProcessPriority kProcessPriority{}; + void set_process_priority(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ProcessPriority::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_StartTimestampNs = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + ProcessDescriptor>; + + static constexpr FieldMetadata_StartTimestampNs kStartTimestampNs{}; + void set_start_timestamp_ns(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_StartTimestampNs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ChromeProcessType = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + ProcessDescriptor_ChromeProcessType, + ProcessDescriptor>; + + static constexpr FieldMetadata_ChromeProcessType kChromeProcessType{}; + void set_chrome_process_type(ProcessDescriptor_ChromeProcessType value) { + static constexpr uint32_t field_id = FieldMetadata_ChromeProcessType::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_LegacySortIndex = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + ProcessDescriptor>; + + static constexpr FieldMetadata_LegacySortIndex kLegacySortIndex{}; + void set_legacy_sort_index(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_LegacySortIndex::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ProcessLabels = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + ProcessDescriptor>; + + static constexpr FieldMetadata_ProcessLabels kProcessLabels{}; + void add_process_labels(const char* data, size_t size) { + AppendBytes(FieldMetadata_ProcessLabels::kFieldId, data, size); + } + void add_process_labels(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_ProcessLabels::kFieldId, chars.data, chars.size); + } + void add_process_labels(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_ProcessLabels::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class TraceUuid_Decoder : public ::protozero::TypedProtoDecoder { + public: + TraceUuid_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TraceUuid_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TraceUuid_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_msb() const { return at<1>().valid(); } + int64_t msb() const { return at<1>().as_int64(); } + bool has_lsb() const { return at<2>().valid(); } + int64_t lsb() const { return at<2>().as_int64(); } +}; + +class TraceUuid : public ::protozero::Message { + public: + using Decoder = TraceUuid_Decoder; + enum : int32_t { + kMsbFieldNumber = 1, + kLsbFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.TraceUuid"; } + + + using FieldMetadata_Msb = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + TraceUuid>; + + static constexpr FieldMetadata_Msb kMsb{}; + void set_msb(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Msb::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Lsb = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + TraceUuid>; + + static constexpr FieldMetadata_Lsb kLsb{}; + void set_lsb(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Lsb::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } +}; + +class TracePacketDefaults_Decoder : public ::protozero::TypedProtoDecoder { + public: + TracePacketDefaults_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TracePacketDefaults_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TracePacketDefaults_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_timestamp_clock_id() const { return at<58>().valid(); } + uint32_t timestamp_clock_id() const { return at<58>().as_uint32(); } + bool has_track_event_defaults() const { return at<11>().valid(); } + ::protozero::ConstBytes track_event_defaults() const { return at<11>().as_bytes(); } + bool has_perf_sample_defaults() const { return at<12>().valid(); } + ::protozero::ConstBytes perf_sample_defaults() const { return at<12>().as_bytes(); } + bool has_v8_code_defaults() const { return at<99>().valid(); } + ::protozero::ConstBytes v8_code_defaults() const { return at<99>().as_bytes(); } +}; + +class TracePacketDefaults : public ::protozero::Message { + public: + using Decoder = TracePacketDefaults_Decoder; + enum : int32_t { + kTimestampClockIdFieldNumber = 58, + kTrackEventDefaultsFieldNumber = 11, + kPerfSampleDefaultsFieldNumber = 12, + kV8CodeDefaultsFieldNumber = 99, + }; + static constexpr const char* GetName() { return ".perfetto.protos.TracePacketDefaults"; } + + + using FieldMetadata_TimestampClockId = + ::protozero::proto_utils::FieldMetadata< + 58, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + TracePacketDefaults>; + + static constexpr FieldMetadata_TimestampClockId kTimestampClockId{}; + void set_timestamp_clock_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TimestampClockId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TrackEventDefaults = + ::protozero::proto_utils::FieldMetadata< + 11, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TrackEventDefaults, + TracePacketDefaults>; + + static constexpr FieldMetadata_TrackEventDefaults kTrackEventDefaults{}; + template T* set_track_event_defaults() { + return BeginNestedMessage(11); + } + + + using FieldMetadata_PerfSampleDefaults = + ::protozero::proto_utils::FieldMetadata< + 12, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + PerfSampleDefaults, + TracePacketDefaults>; + + static constexpr FieldMetadata_PerfSampleDefaults kPerfSampleDefaults{}; + template T* set_perf_sample_defaults() { + return BeginNestedMessage(12); + } + + + using FieldMetadata_V8CodeDefaults = + ::protozero::proto_utils::FieldMetadata< + 99, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + V8CodeDefaults, + TracePacketDefaults>; + + static constexpr FieldMetadata_V8CodeDefaults kV8CodeDefaults{}; + template T* set_v8_code_defaults() { + return BeginNestedMessage(99); + } + +}; + +class TestEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + TestEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TestEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TestEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_str() const { return at<1>().valid(); } + ::protozero::ConstChars str() const { return at<1>().as_string(); } + bool has_seq_value() const { return at<2>().valid(); } + uint32_t seq_value() const { return at<2>().as_uint32(); } + bool has_counter() const { return at<3>().valid(); } + uint64_t counter() const { return at<3>().as_uint64(); } + bool has_is_last() const { return at<4>().valid(); } + bool is_last() const { return at<4>().as_bool(); } + bool has_payload() const { return at<5>().valid(); } + ::protozero::ConstBytes payload() const { return at<5>().as_bytes(); } +}; + +class TestEvent : public ::protozero::Message { + public: + using Decoder = TestEvent_Decoder; + enum : int32_t { + kStrFieldNumber = 1, + kSeqValueFieldNumber = 2, + kCounterFieldNumber = 3, + kIsLastFieldNumber = 4, + kPayloadFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.TestEvent"; } + + using TestPayload = ::perfetto::protos::pbzero::TestEvent_TestPayload; + + using FieldMetadata_Str = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + TestEvent>; + + static constexpr FieldMetadata_Str kStr{}; + void set_str(const char* data, size_t size) { + AppendBytes(FieldMetadata_Str::kFieldId, data, size); + } + void set_str(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Str::kFieldId, chars.data, chars.size); + } + void set_str(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Str::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SeqValue = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + TestEvent>; + + static constexpr FieldMetadata_SeqValue kSeqValue{}; + void set_seq_value(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_SeqValue::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Counter = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TestEvent>; + + static constexpr FieldMetadata_Counter kCounter{}; + void set_counter(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Counter::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_IsLast = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + TestEvent>; + + static constexpr FieldMetadata_IsLast kIsLast{}; + void set_is_last(bool value) { + static constexpr uint32_t field_id = FieldMetadata_IsLast::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Payload = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TestEvent_TestPayload, + TestEvent>; + + static constexpr FieldMetadata_Payload kPayload{}; + template T* set_payload() { + return BeginNestedMessage(5); + } + +}; + +class TestEvent_TestPayload_Decoder : public ::protozero::TypedProtoDecoder { + public: + TestEvent_TestPayload_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TestEvent_TestPayload_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TestEvent_TestPayload_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_str() const { return at<1>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstChars> str() const { return GetRepeated<::protozero::ConstChars>(1); } + bool has_nested() const { return at<2>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> nested() const { return GetRepeated<::protozero::ConstBytes>(2); } + bool has_single_string() const { return at<4>().valid(); } + ::protozero::ConstChars single_string() const { return at<4>().as_string(); } + bool has_single_int() const { return at<5>().valid(); } + int32_t single_int() const { return at<5>().as_int32(); } + bool has_repeated_ints() const { return at<6>().valid(); } + ::protozero::RepeatedFieldIterator repeated_ints() const { return GetRepeated(6); } + bool has_remaining_nesting_depth() const { return at<3>().valid(); } + uint32_t remaining_nesting_depth() const { return at<3>().as_uint32(); } + bool has_debug_annotations() const { return at<7>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> debug_annotations() const { return GetRepeated<::protozero::ConstBytes>(7); } +}; + +class TestEvent_TestPayload : public ::protozero::Message { + public: + using Decoder = TestEvent_TestPayload_Decoder; + enum : int32_t { + kStrFieldNumber = 1, + kNestedFieldNumber = 2, + kSingleStringFieldNumber = 4, + kSingleIntFieldNumber = 5, + kRepeatedIntsFieldNumber = 6, + kRemainingNestingDepthFieldNumber = 3, + kDebugAnnotationsFieldNumber = 7, + }; + static constexpr const char* GetName() { return ".perfetto.protos.TestEvent.TestPayload"; } + + + using FieldMetadata_Str = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + TestEvent_TestPayload>; + + static constexpr FieldMetadata_Str kStr{}; + void add_str(const char* data, size_t size) { + AppendBytes(FieldMetadata_Str::kFieldId, data, size); + } + void add_str(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Str::kFieldId, chars.data, chars.size); + } + void add_str(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Str::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Nested = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TestEvent_TestPayload, + TestEvent_TestPayload>; + + static constexpr FieldMetadata_Nested kNested{}; + template T* add_nested() { + return BeginNestedMessage(2); + } + + + using FieldMetadata_SingleString = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + TestEvent_TestPayload>; + + static constexpr FieldMetadata_SingleString kSingleString{}; + void set_single_string(const char* data, size_t size) { + AppendBytes(FieldMetadata_SingleString::kFieldId, data, size); + } + void set_single_string(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_SingleString::kFieldId, chars.data, chars.size); + } + void set_single_string(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_SingleString::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SingleInt = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + TestEvent_TestPayload>; + + static constexpr FieldMetadata_SingleInt kSingleInt{}; + void set_single_int(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_SingleInt::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_RepeatedInts = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + TestEvent_TestPayload>; + + static constexpr FieldMetadata_RepeatedInts kRepeatedInts{}; + void add_repeated_ints(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_RepeatedInts::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_RemainingNestingDepth = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + TestEvent_TestPayload>; + + static constexpr FieldMetadata_RemainingNestingDepth kRemainingNestingDepth{}; + void set_remaining_nesting_depth(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_RemainingNestingDepth::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DebugAnnotations = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + DebugAnnotation, + TestEvent_TestPayload>; + + static constexpr FieldMetadata_DebugAnnotations kDebugAnnotations{}; + template T* add_debug_annotations() { + return BeginNestedMessage(7); + } + +}; + +class CpuInfo_Decoder : public ::protozero::TypedProtoDecoder { + public: + CpuInfo_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit CpuInfo_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit CpuInfo_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_cpus() const { return at<1>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> cpus() const { return GetRepeated<::protozero::ConstBytes>(1); } +}; + +class CpuInfo : public ::protozero::Message { + public: + using Decoder = CpuInfo_Decoder; + enum : int32_t { + kCpusFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.CpuInfo"; } + + using Cpu = ::perfetto::protos::pbzero::CpuInfo_Cpu; + + using FieldMetadata_Cpus = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + CpuInfo_Cpu, + CpuInfo>; + + static constexpr FieldMetadata_Cpus kCpus{}; + template T* add_cpus() { + return BeginNestedMessage(1); + } + +}; + +class CpuInfo_Cpu_Decoder : public ::protozero::TypedProtoDecoder { + public: + CpuInfo_Cpu_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit CpuInfo_Cpu_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit CpuInfo_Cpu_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_processor() const { return at<1>().valid(); } + ::protozero::ConstChars processor() const { return at<1>().as_string(); } + bool has_frequencies() const { return at<2>().valid(); } + ::protozero::RepeatedFieldIterator frequencies() const { return GetRepeated(2); } +}; + +class CpuInfo_Cpu : public ::protozero::Message { + public: + using Decoder = CpuInfo_Cpu_Decoder; + enum : int32_t { + kProcessorFieldNumber = 1, + kFrequenciesFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.CpuInfo.Cpu"; } + + + using FieldMetadata_Processor = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + CpuInfo_Cpu>; + + static constexpr FieldMetadata_Processor kProcessor{}; + void set_processor(const char* data, size_t size) { + AppendBytes(FieldMetadata_Processor::kFieldId, data, size); + } + void set_processor(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Processor::kFieldId, chars.data, chars.size); + } + void set_processor(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Processor::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Frequencies = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + CpuInfo_Cpu>; + + static constexpr FieldMetadata_Frequencies kFrequencies{}; + void add_frequencies(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Frequencies::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class SystemInfo_Decoder : public ::protozero::TypedProtoDecoder { + public: + SystemInfo_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit SystemInfo_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit SystemInfo_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_utsname() const { return at<1>().valid(); } + ::protozero::ConstBytes utsname() const { return at<1>().as_bytes(); } + bool has_android_build_fingerprint() const { return at<2>().valid(); } + ::protozero::ConstChars android_build_fingerprint() const { return at<2>().as_string(); } + bool has_tracing_service_version() const { return at<4>().valid(); } + ::protozero::ConstChars tracing_service_version() const { return at<4>().as_string(); } + bool has_android_sdk_version() const { return at<5>().valid(); } + uint64_t android_sdk_version() const { return at<5>().as_uint64(); } + bool has_page_size() const { return at<6>().valid(); } + uint32_t page_size() const { return at<6>().as_uint32(); } + bool has_num_cpus() const { return at<8>().valid(); } + uint32_t num_cpus() const { return at<8>().as_uint32(); } + bool has_timezone_off_mins() const { return at<7>().valid(); } + int32_t timezone_off_mins() const { return at<7>().as_int32(); } + bool has_hz() const { return at<3>().valid(); } + int64_t hz() const { return at<3>().as_int64(); } +}; + +class SystemInfo : public ::protozero::Message { + public: + using Decoder = SystemInfo_Decoder; + enum : int32_t { + kUtsnameFieldNumber = 1, + kAndroidBuildFingerprintFieldNumber = 2, + kTracingServiceVersionFieldNumber = 4, + kAndroidSdkVersionFieldNumber = 5, + kPageSizeFieldNumber = 6, + kNumCpusFieldNumber = 8, + kTimezoneOffMinsFieldNumber = 7, + kHzFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.SystemInfo"; } + + + using FieldMetadata_Utsname = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Utsname, + SystemInfo>; + + static constexpr FieldMetadata_Utsname kUtsname{}; + template T* set_utsname() { + return BeginNestedMessage(1); + } + + + using FieldMetadata_AndroidBuildFingerprint = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + SystemInfo>; + + static constexpr FieldMetadata_AndroidBuildFingerprint kAndroidBuildFingerprint{}; + void set_android_build_fingerprint(const char* data, size_t size) { + AppendBytes(FieldMetadata_AndroidBuildFingerprint::kFieldId, data, size); + } + void set_android_build_fingerprint(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_AndroidBuildFingerprint::kFieldId, chars.data, chars.size); + } + void set_android_build_fingerprint(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_AndroidBuildFingerprint::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TracingServiceVersion = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + SystemInfo>; + + static constexpr FieldMetadata_TracingServiceVersion kTracingServiceVersion{}; + void set_tracing_service_version(const char* data, size_t size) { + AppendBytes(FieldMetadata_TracingServiceVersion::kFieldId, data, size); + } + void set_tracing_service_version(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_TracingServiceVersion::kFieldId, chars.data, chars.size); + } + void set_tracing_service_version(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_TracingServiceVersion::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_AndroidSdkVersion = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + SystemInfo>; + + static constexpr FieldMetadata_AndroidSdkVersion kAndroidSdkVersion{}; + void set_android_sdk_version(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_AndroidSdkVersion::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PageSize = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SystemInfo>; + + static constexpr FieldMetadata_PageSize kPageSize{}; + void set_page_size(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_PageSize::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NumCpus = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SystemInfo>; + + static constexpr FieldMetadata_NumCpus kNumCpus{}; + void set_num_cpus(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_NumCpus::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TimezoneOffMins = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + SystemInfo>; + + static constexpr FieldMetadata_TimezoneOffMins kTimezoneOffMins{}; + void set_timezone_off_mins(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TimezoneOffMins::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Hz = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + SystemInfo>; + + static constexpr FieldMetadata_Hz kHz{}; + void set_hz(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Hz::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } +}; + +class Utsname_Decoder : public ::protozero::TypedProtoDecoder { + public: + Utsname_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Utsname_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Utsname_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_sysname() const { return at<1>().valid(); } + ::protozero::ConstChars sysname() const { return at<1>().as_string(); } + bool has_version() const { return at<2>().valid(); } + ::protozero::ConstChars version() const { return at<2>().as_string(); } + bool has_release() const { return at<3>().valid(); } + ::protozero::ConstChars release() const { return at<3>().as_string(); } + bool has_machine() const { return at<4>().valid(); } + ::protozero::ConstChars machine() const { return at<4>().as_string(); } +}; + +class Utsname : public ::protozero::Message { + public: + using Decoder = Utsname_Decoder; + enum : int32_t { + kSysnameFieldNumber = 1, + kVersionFieldNumber = 2, + kReleaseFieldNumber = 3, + kMachineFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Utsname"; } + + + using FieldMetadata_Sysname = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + Utsname>; + + static constexpr FieldMetadata_Sysname kSysname{}; + void set_sysname(const char* data, size_t size) { + AppendBytes(FieldMetadata_Sysname::kFieldId, data, size); + } + void set_sysname(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Sysname::kFieldId, chars.data, chars.size); + } + void set_sysname(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Sysname::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Version = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + Utsname>; + + static constexpr FieldMetadata_Version kVersion{}; + void set_version(const char* data, size_t size) { + AppendBytes(FieldMetadata_Version::kFieldId, data, size); + } + void set_version(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Version::kFieldId, chars.data, chars.size); + } + void set_version(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Version::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Release = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + Utsname>; + + static constexpr FieldMetadata_Release kRelease{}; + void set_release(const char* data, size_t size) { + AppendBytes(FieldMetadata_Release::kFieldId, data, size); + } + void set_release(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Release::kFieldId, chars.data, chars.size); + } + void set_release(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Release::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Machine = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + Utsname>; + + static constexpr FieldMetadata_Machine kMachine{}; + void set_machine(const char* data, size_t size) { + AppendBytes(FieldMetadata_Machine::kFieldId, data, size); + } + void set_machine(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Machine::kFieldId, chars.data, chars.size); + } + void set_machine(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Machine::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class SysStats_Decoder : public ::protozero::TypedProtoDecoder { + public: + SysStats_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit SysStats_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit SysStats_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_meminfo() const { return at<1>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> meminfo() const { return GetRepeated<::protozero::ConstBytes>(1); } + bool has_vmstat() const { return at<2>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> vmstat() const { return GetRepeated<::protozero::ConstBytes>(2); } + bool has_cpu_stat() const { return at<3>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> cpu_stat() const { return GetRepeated<::protozero::ConstBytes>(3); } + bool has_num_forks() const { return at<4>().valid(); } + uint64_t num_forks() const { return at<4>().as_uint64(); } + bool has_num_irq_total() const { return at<5>().valid(); } + uint64_t num_irq_total() const { return at<5>().as_uint64(); } + bool has_num_irq() const { return at<6>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> num_irq() const { return GetRepeated<::protozero::ConstBytes>(6); } + bool has_num_softirq_total() const { return at<7>().valid(); } + uint64_t num_softirq_total() const { return at<7>().as_uint64(); } + bool has_num_softirq() const { return at<8>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> num_softirq() const { return GetRepeated<::protozero::ConstBytes>(8); } + bool has_collection_end_timestamp() const { return at<9>().valid(); } + uint64_t collection_end_timestamp() const { return at<9>().as_uint64(); } + bool has_devfreq() const { return at<10>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> devfreq() const { return GetRepeated<::protozero::ConstBytes>(10); } + bool has_cpufreq_khz() const { return at<11>().valid(); } + ::protozero::RepeatedFieldIterator cpufreq_khz() const { return GetRepeated(11); } + bool has_buddy_info() const { return at<12>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> buddy_info() const { return GetRepeated<::protozero::ConstBytes>(12); } + bool has_disk_stat() const { return at<13>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> disk_stat() const { return GetRepeated<::protozero::ConstBytes>(13); } + bool has_psi() const { return at<14>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> psi() const { return GetRepeated<::protozero::ConstBytes>(14); } +}; + +class SysStats : public ::protozero::Message { + public: + using Decoder = SysStats_Decoder; + enum : int32_t { + kMeminfoFieldNumber = 1, + kVmstatFieldNumber = 2, + kCpuStatFieldNumber = 3, + kNumForksFieldNumber = 4, + kNumIrqTotalFieldNumber = 5, + kNumIrqFieldNumber = 6, + kNumSoftirqTotalFieldNumber = 7, + kNumSoftirqFieldNumber = 8, + kCollectionEndTimestampFieldNumber = 9, + kDevfreqFieldNumber = 10, + kCpufreqKhzFieldNumber = 11, + kBuddyInfoFieldNumber = 12, + kDiskStatFieldNumber = 13, + kPsiFieldNumber = 14, + }; + static constexpr const char* GetName() { return ".perfetto.protos.SysStats"; } + + using MeminfoValue = ::perfetto::protos::pbzero::SysStats_MeminfoValue; + using VmstatValue = ::perfetto::protos::pbzero::SysStats_VmstatValue; + using CpuTimes = ::perfetto::protos::pbzero::SysStats_CpuTimes; + using InterruptCount = ::perfetto::protos::pbzero::SysStats_InterruptCount; + using DevfreqValue = ::perfetto::protos::pbzero::SysStats_DevfreqValue; + using BuddyInfo = ::perfetto::protos::pbzero::SysStats_BuddyInfo; + using DiskStat = ::perfetto::protos::pbzero::SysStats_DiskStat; + using PsiSample = ::perfetto::protos::pbzero::SysStats_PsiSample; + + using FieldMetadata_Meminfo = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + SysStats_MeminfoValue, + SysStats>; + + static constexpr FieldMetadata_Meminfo kMeminfo{}; + template T* add_meminfo() { + return BeginNestedMessage(1); + } + + + using FieldMetadata_Vmstat = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + SysStats_VmstatValue, + SysStats>; + + static constexpr FieldMetadata_Vmstat kVmstat{}; + template T* add_vmstat() { + return BeginNestedMessage(2); + } + + + using FieldMetadata_CpuStat = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + SysStats_CpuTimes, + SysStats>; + + static constexpr FieldMetadata_CpuStat kCpuStat{}; + template T* add_cpu_stat() { + return BeginNestedMessage(3); + } + + + using FieldMetadata_NumForks = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + SysStats>; + + static constexpr FieldMetadata_NumForks kNumForks{}; + void set_num_forks(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_NumForks::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NumIrqTotal = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + SysStats>; + + static constexpr FieldMetadata_NumIrqTotal kNumIrqTotal{}; + void set_num_irq_total(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_NumIrqTotal::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NumIrq = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + SysStats_InterruptCount, + SysStats>; + + static constexpr FieldMetadata_NumIrq kNumIrq{}; + template T* add_num_irq() { + return BeginNestedMessage(6); + } + + + using FieldMetadata_NumSoftirqTotal = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + SysStats>; + + static constexpr FieldMetadata_NumSoftirqTotal kNumSoftirqTotal{}; + void set_num_softirq_total(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_NumSoftirqTotal::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NumSoftirq = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + SysStats_InterruptCount, + SysStats>; + + static constexpr FieldMetadata_NumSoftirq kNumSoftirq{}; + template T* add_num_softirq() { + return BeginNestedMessage(8); + } + + + using FieldMetadata_CollectionEndTimestamp = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + SysStats>; + + static constexpr FieldMetadata_CollectionEndTimestamp kCollectionEndTimestamp{}; + void set_collection_end_timestamp(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_CollectionEndTimestamp::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Devfreq = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + SysStats_DevfreqValue, + SysStats>; + + static constexpr FieldMetadata_Devfreq kDevfreq{}; + template T* add_devfreq() { + return BeginNestedMessage(10); + } + + + using FieldMetadata_CpufreqKhz = + ::protozero::proto_utils::FieldMetadata< + 11, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SysStats>; + + static constexpr FieldMetadata_CpufreqKhz kCpufreqKhz{}; + void add_cpufreq_khz(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_CpufreqKhz::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_BuddyInfo = + ::protozero::proto_utils::FieldMetadata< + 12, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + SysStats_BuddyInfo, + SysStats>; + + static constexpr FieldMetadata_BuddyInfo kBuddyInfo{}; + template T* add_buddy_info() { + return BeginNestedMessage(12); + } + + + using FieldMetadata_DiskStat = + ::protozero::proto_utils::FieldMetadata< + 13, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + SysStats_DiskStat, + SysStats>; + + static constexpr FieldMetadata_DiskStat kDiskStat{}; + template T* add_disk_stat() { + return BeginNestedMessage(13); + } + + + using FieldMetadata_Psi = + ::protozero::proto_utils::FieldMetadata< + 14, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + SysStats_PsiSample, + SysStats>; + + static constexpr FieldMetadata_Psi kPsi{}; + template T* add_psi() { + return BeginNestedMessage(14); + } + +}; + +class SysStats_PsiSample_Decoder : public ::protozero::TypedProtoDecoder { + public: + SysStats_PsiSample_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit SysStats_PsiSample_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit SysStats_PsiSample_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_resource() const { return at<1>().valid(); } + int32_t resource() const { return at<1>().as_int32(); } + bool has_total_ns() const { return at<2>().valid(); } + uint64_t total_ns() const { return at<2>().as_uint64(); } +}; + +class SysStats_PsiSample : public ::protozero::Message { + public: + using Decoder = SysStats_PsiSample_Decoder; + enum : int32_t { + kResourceFieldNumber = 1, + kTotalNsFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.SysStats.PsiSample"; } + + + using PsiResource = ::perfetto::protos::pbzero::SysStats_PsiSample_PsiResource; + static inline const char* PsiResource_Name(PsiResource value) { + return ::perfetto::protos::pbzero::SysStats_PsiSample_PsiResource_Name(value); + } + static inline const PsiResource PSI_RESOURCE_UNSPECIFIED = PsiResource::PSI_RESOURCE_UNSPECIFIED; + static inline const PsiResource PSI_RESOURCE_CPU_SOME = PsiResource::PSI_RESOURCE_CPU_SOME; + static inline const PsiResource PSI_RESOURCE_CPU_FULL = PsiResource::PSI_RESOURCE_CPU_FULL; + static inline const PsiResource PSI_RESOURCE_IO_SOME = PsiResource::PSI_RESOURCE_IO_SOME; + static inline const PsiResource PSI_RESOURCE_IO_FULL = PsiResource::PSI_RESOURCE_IO_FULL; + static inline const PsiResource PSI_RESOURCE_MEMORY_SOME = PsiResource::PSI_RESOURCE_MEMORY_SOME; + static inline const PsiResource PSI_RESOURCE_MEMORY_FULL = PsiResource::PSI_RESOURCE_MEMORY_FULL; + + using FieldMetadata_Resource = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + SysStats_PsiSample_PsiResource, + SysStats_PsiSample>; + + static constexpr FieldMetadata_Resource kResource{}; + void set_resource(SysStats_PsiSample_PsiResource value) { + static constexpr uint32_t field_id = FieldMetadata_Resource::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TotalNs = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + SysStats_PsiSample>; + + static constexpr FieldMetadata_TotalNs kTotalNs{}; + void set_total_ns(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_TotalNs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class SysStats_DiskStat_Decoder : public ::protozero::TypedProtoDecoder { + public: + SysStats_DiskStat_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit SysStats_DiskStat_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit SysStats_DiskStat_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_device_name() const { return at<1>().valid(); } + ::protozero::ConstChars device_name() const { return at<1>().as_string(); } + bool has_read_sectors() const { return at<2>().valid(); } + uint64_t read_sectors() const { return at<2>().as_uint64(); } + bool has_read_time_ms() const { return at<3>().valid(); } + uint64_t read_time_ms() const { return at<3>().as_uint64(); } + bool has_write_sectors() const { return at<4>().valid(); } + uint64_t write_sectors() const { return at<4>().as_uint64(); } + bool has_write_time_ms() const { return at<5>().valid(); } + uint64_t write_time_ms() const { return at<5>().as_uint64(); } + bool has_discard_sectors() const { return at<6>().valid(); } + uint64_t discard_sectors() const { return at<6>().as_uint64(); } + bool has_discard_time_ms() const { return at<7>().valid(); } + uint64_t discard_time_ms() const { return at<7>().as_uint64(); } + bool has_flush_count() const { return at<8>().valid(); } + uint64_t flush_count() const { return at<8>().as_uint64(); } + bool has_flush_time_ms() const { return at<9>().valid(); } + uint64_t flush_time_ms() const { return at<9>().as_uint64(); } +}; + +class SysStats_DiskStat : public ::protozero::Message { + public: + using Decoder = SysStats_DiskStat_Decoder; + enum : int32_t { + kDeviceNameFieldNumber = 1, + kReadSectorsFieldNumber = 2, + kReadTimeMsFieldNumber = 3, + kWriteSectorsFieldNumber = 4, + kWriteTimeMsFieldNumber = 5, + kDiscardSectorsFieldNumber = 6, + kDiscardTimeMsFieldNumber = 7, + kFlushCountFieldNumber = 8, + kFlushTimeMsFieldNumber = 9, + }; + static constexpr const char* GetName() { return ".perfetto.protos.SysStats.DiskStat"; } + + + using FieldMetadata_DeviceName = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + SysStats_DiskStat>; + + static constexpr FieldMetadata_DeviceName kDeviceName{}; + void set_device_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_DeviceName::kFieldId, data, size); + } + void set_device_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_DeviceName::kFieldId, chars.data, chars.size); + } + void set_device_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_DeviceName::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ReadSectors = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + SysStats_DiskStat>; + + static constexpr FieldMetadata_ReadSectors kReadSectors{}; + void set_read_sectors(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_ReadSectors::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ReadTimeMs = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + SysStats_DiskStat>; + + static constexpr FieldMetadata_ReadTimeMs kReadTimeMs{}; + void set_read_time_ms(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_ReadTimeMs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_WriteSectors = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + SysStats_DiskStat>; + + static constexpr FieldMetadata_WriteSectors kWriteSectors{}; + void set_write_sectors(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_WriteSectors::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_WriteTimeMs = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + SysStats_DiskStat>; + + static constexpr FieldMetadata_WriteTimeMs kWriteTimeMs{}; + void set_write_time_ms(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_WriteTimeMs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DiscardSectors = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + SysStats_DiskStat>; + + static constexpr FieldMetadata_DiscardSectors kDiscardSectors{}; + void set_discard_sectors(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_DiscardSectors::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DiscardTimeMs = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + SysStats_DiskStat>; + + static constexpr FieldMetadata_DiscardTimeMs kDiscardTimeMs{}; + void set_discard_time_ms(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_DiscardTimeMs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FlushCount = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + SysStats_DiskStat>; + + static constexpr FieldMetadata_FlushCount kFlushCount{}; + void set_flush_count(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_FlushCount::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FlushTimeMs = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + SysStats_DiskStat>; + + static constexpr FieldMetadata_FlushTimeMs kFlushTimeMs{}; + void set_flush_time_ms(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_FlushTimeMs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class SysStats_BuddyInfo_Decoder : public ::protozero::TypedProtoDecoder { + public: + SysStats_BuddyInfo_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit SysStats_BuddyInfo_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit SysStats_BuddyInfo_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_node() const { return at<1>().valid(); } + ::protozero::ConstChars node() const { return at<1>().as_string(); } + bool has_zone() const { return at<2>().valid(); } + ::protozero::ConstChars zone() const { return at<2>().as_string(); } + bool has_order_pages() const { return at<3>().valid(); } + ::protozero::RepeatedFieldIterator order_pages() const { return GetRepeated(3); } +}; + +class SysStats_BuddyInfo : public ::protozero::Message { + public: + using Decoder = SysStats_BuddyInfo_Decoder; + enum : int32_t { + kNodeFieldNumber = 1, + kZoneFieldNumber = 2, + kOrderPagesFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.SysStats.BuddyInfo"; } + + + using FieldMetadata_Node = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + SysStats_BuddyInfo>; + + static constexpr FieldMetadata_Node kNode{}; + void set_node(const char* data, size_t size) { + AppendBytes(FieldMetadata_Node::kFieldId, data, size); + } + void set_node(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Node::kFieldId, chars.data, chars.size); + } + void set_node(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Node::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Zone = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + SysStats_BuddyInfo>; + + static constexpr FieldMetadata_Zone kZone{}; + void set_zone(const char* data, size_t size) { + AppendBytes(FieldMetadata_Zone::kFieldId, data, size); + } + void set_zone(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Zone::kFieldId, chars.data, chars.size); + } + void set_zone(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Zone::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_OrderPages = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SysStats_BuddyInfo>; + + static constexpr FieldMetadata_OrderPages kOrderPages{}; + void add_order_pages(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_OrderPages::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class SysStats_DevfreqValue_Decoder : public ::protozero::TypedProtoDecoder { + public: + SysStats_DevfreqValue_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit SysStats_DevfreqValue_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit SysStats_DevfreqValue_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_key() const { return at<1>().valid(); } + ::protozero::ConstChars key() const { return at<1>().as_string(); } + bool has_value() const { return at<2>().valid(); } + uint64_t value() const { return at<2>().as_uint64(); } +}; + +class SysStats_DevfreqValue : public ::protozero::Message { + public: + using Decoder = SysStats_DevfreqValue_Decoder; + enum : int32_t { + kKeyFieldNumber = 1, + kValueFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.SysStats.DevfreqValue"; } + + + using FieldMetadata_Key = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + SysStats_DevfreqValue>; + + static constexpr FieldMetadata_Key kKey{}; + void set_key(const char* data, size_t size) { + AppendBytes(FieldMetadata_Key::kFieldId, data, size); + } + void set_key(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Key::kFieldId, chars.data, chars.size); + } + void set_key(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Key::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Value = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + SysStats_DevfreqValue>; + + static constexpr FieldMetadata_Value kValue{}; + void set_value(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class SysStats_InterruptCount_Decoder : public ::protozero::TypedProtoDecoder { + public: + SysStats_InterruptCount_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit SysStats_InterruptCount_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit SysStats_InterruptCount_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_irq() const { return at<1>().valid(); } + int32_t irq() const { return at<1>().as_int32(); } + bool has_count() const { return at<2>().valid(); } + uint64_t count() const { return at<2>().as_uint64(); } +}; + +class SysStats_InterruptCount : public ::protozero::Message { + public: + using Decoder = SysStats_InterruptCount_Decoder; + enum : int32_t { + kIrqFieldNumber = 1, + kCountFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.SysStats.InterruptCount"; } + + + using FieldMetadata_Irq = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + SysStats_InterruptCount>; + + static constexpr FieldMetadata_Irq kIrq{}; + void set_irq(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Irq::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Count = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + SysStats_InterruptCount>; + + static constexpr FieldMetadata_Count kCount{}; + void set_count(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Count::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class SysStats_CpuTimes_Decoder : public ::protozero::TypedProtoDecoder { + public: + SysStats_CpuTimes_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit SysStats_CpuTimes_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit SysStats_CpuTimes_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_cpu_id() const { return at<1>().valid(); } + uint32_t cpu_id() const { return at<1>().as_uint32(); } + bool has_user_ns() const { return at<2>().valid(); } + uint64_t user_ns() const { return at<2>().as_uint64(); } + bool has_user_nice_ns() const { return at<3>().valid(); } + uint64_t user_nice_ns() const { return at<3>().as_uint64(); } + bool has_system_mode_ns() const { return at<4>().valid(); } + uint64_t system_mode_ns() const { return at<4>().as_uint64(); } + bool has_idle_ns() const { return at<5>().valid(); } + uint64_t idle_ns() const { return at<5>().as_uint64(); } + bool has_io_wait_ns() const { return at<6>().valid(); } + uint64_t io_wait_ns() const { return at<6>().as_uint64(); } + bool has_irq_ns() const { return at<7>().valid(); } + uint64_t irq_ns() const { return at<7>().as_uint64(); } + bool has_softirq_ns() const { return at<8>().valid(); } + uint64_t softirq_ns() const { return at<8>().as_uint64(); } +}; + +class SysStats_CpuTimes : public ::protozero::Message { + public: + using Decoder = SysStats_CpuTimes_Decoder; + enum : int32_t { + kCpuIdFieldNumber = 1, + kUserNsFieldNumber = 2, + kUserNiceNsFieldNumber = 3, + kSystemModeNsFieldNumber = 4, + kIdleNsFieldNumber = 5, + kIoWaitNsFieldNumber = 6, + kIrqNsFieldNumber = 7, + kSoftirqNsFieldNumber = 8, + }; + static constexpr const char* GetName() { return ".perfetto.protos.SysStats.CpuTimes"; } + + + using FieldMetadata_CpuId = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SysStats_CpuTimes>; + + static constexpr FieldMetadata_CpuId kCpuId{}; + void set_cpu_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_CpuId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_UserNs = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + SysStats_CpuTimes>; + + static constexpr FieldMetadata_UserNs kUserNs{}; + void set_user_ns(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_UserNs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_UserNiceNs = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + SysStats_CpuTimes>; + + static constexpr FieldMetadata_UserNiceNs kUserNiceNs{}; + void set_user_nice_ns(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_UserNiceNs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SystemModeNs = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + SysStats_CpuTimes>; + + static constexpr FieldMetadata_SystemModeNs kSystemModeNs{}; + void set_system_mode_ns(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_SystemModeNs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_IdleNs = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + SysStats_CpuTimes>; + + static constexpr FieldMetadata_IdleNs kIdleNs{}; + void set_idle_ns(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_IdleNs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_IoWaitNs = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + SysStats_CpuTimes>; + + static constexpr FieldMetadata_IoWaitNs kIoWaitNs{}; + void set_io_wait_ns(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_IoWaitNs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_IrqNs = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + SysStats_CpuTimes>; + + static constexpr FieldMetadata_IrqNs kIrqNs{}; + void set_irq_ns(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_IrqNs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SoftirqNs = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + SysStats_CpuTimes>; + + static constexpr FieldMetadata_SoftirqNs kSoftirqNs{}; + void set_softirq_ns(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_SoftirqNs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class SysStats_VmstatValue_Decoder : public ::protozero::TypedProtoDecoder { + public: + SysStats_VmstatValue_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit SysStats_VmstatValue_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit SysStats_VmstatValue_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_key() const { return at<1>().valid(); } + int32_t key() const { return at<1>().as_int32(); } + bool has_value() const { return at<2>().valid(); } + uint64_t value() const { return at<2>().as_uint64(); } +}; + +class SysStats_VmstatValue : public ::protozero::Message { + public: + using Decoder = SysStats_VmstatValue_Decoder; + enum : int32_t { + kKeyFieldNumber = 1, + kValueFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.SysStats.VmstatValue"; } + + + using FieldMetadata_Key = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + VmstatCounters, + SysStats_VmstatValue>; + + static constexpr FieldMetadata_Key kKey{}; + void set_key(VmstatCounters value) { + static constexpr uint32_t field_id = FieldMetadata_Key::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Value = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + SysStats_VmstatValue>; + + static constexpr FieldMetadata_Value kValue{}; + void set_value(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class SysStats_MeminfoValue_Decoder : public ::protozero::TypedProtoDecoder { + public: + SysStats_MeminfoValue_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit SysStats_MeminfoValue_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit SysStats_MeminfoValue_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_key() const { return at<1>().valid(); } + int32_t key() const { return at<1>().as_int32(); } + bool has_value() const { return at<2>().valid(); } + uint64_t value() const { return at<2>().as_uint64(); } +}; + +class SysStats_MeminfoValue : public ::protozero::Message { + public: + using Decoder = SysStats_MeminfoValue_Decoder; + enum : int32_t { + kKeyFieldNumber = 1, + kValueFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.SysStats.MeminfoValue"; } + + + using FieldMetadata_Key = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + MeminfoCounters, + SysStats_MeminfoValue>; + + static constexpr FieldMetadata_Key kKey{}; + void set_key(MeminfoCounters value) { + static constexpr uint32_t field_id = FieldMetadata_Key::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Value = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + SysStats_MeminfoValue>; + + static constexpr FieldMetadata_Value kValue{}; + void set_value(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class StatsdAtom_Decoder : public ::protozero::TypedProtoDecoder { + public: + StatsdAtom_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit StatsdAtom_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit StatsdAtom_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_atom() const { return at<1>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> atom() const { return GetRepeated<::protozero::ConstBytes>(1); } + bool has_timestamp_nanos() const { return at<2>().valid(); } + ::protozero::RepeatedFieldIterator timestamp_nanos() const { return GetRepeated(2); } +}; + +class StatsdAtom : public ::protozero::Message { + public: + using Decoder = StatsdAtom_Decoder; + enum : int32_t { + kAtomFieldNumber = 1, + kTimestampNanosFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.StatsdAtom"; } + + + using FieldMetadata_Atom = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Atom, + StatsdAtom>; + + static constexpr FieldMetadata_Atom kAtom{}; + template T* add_atom() { + return BeginNestedMessage(1); + } + + + using FieldMetadata_TimestampNanos = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + StatsdAtom>; + + static constexpr FieldMetadata_TimestampNanos kTimestampNanos{}; + void add_timestamp_nanos(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_TimestampNanos::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } +}; + +class Atom_Decoder : public ::protozero::TypedProtoDecoder { + public: + Atom_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Atom_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Atom_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} +}; + +class Atom : public ::protozero::Message { + public: + using Decoder = Atom_Decoder; + static constexpr const char* GetName() { return ".perfetto.protos.Atom"; } + +}; + +class RemoteClockSync_Decoder : public ::protozero::TypedProtoDecoder { + public: + RemoteClockSync_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit RemoteClockSync_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit RemoteClockSync_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_synced_clocks() const { return at<1>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> synced_clocks() const { return GetRepeated<::protozero::ConstBytes>(1); } +}; + +class RemoteClockSync : public ::protozero::Message { + public: + using Decoder = RemoteClockSync_Decoder; + enum : int32_t { + kSyncedClocksFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.RemoteClockSync"; } + + using SyncedClocks = ::perfetto::protos::pbzero::RemoteClockSync_SyncedClocks; + + using FieldMetadata_SyncedClocks = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + RemoteClockSync_SyncedClocks, + RemoteClockSync>; + + static constexpr FieldMetadata_SyncedClocks kSyncedClocks{}; + template T* add_synced_clocks() { + return BeginNestedMessage(1); + } + +}; + +class RemoteClockSync_SyncedClocks_Decoder : public ::protozero::TypedProtoDecoder { + public: + RemoteClockSync_SyncedClocks_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit RemoteClockSync_SyncedClocks_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit RemoteClockSync_SyncedClocks_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_client_clocks() const { return at<2>().valid(); } + ::protozero::ConstBytes client_clocks() const { return at<2>().as_bytes(); } + bool has_host_clocks() const { return at<3>().valid(); } + ::protozero::ConstBytes host_clocks() const { return at<3>().as_bytes(); } +}; + +class RemoteClockSync_SyncedClocks : public ::protozero::Message { + public: + using Decoder = RemoteClockSync_SyncedClocks_Decoder; + enum : int32_t { + kClientClocksFieldNumber = 2, + kHostClocksFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.RemoteClockSync.SyncedClocks"; } + + + using FieldMetadata_ClientClocks = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ClockSnapshot, + RemoteClockSync_SyncedClocks>; + + static constexpr FieldMetadata_ClientClocks kClientClocks{}; + template T* set_client_clocks() { + return BeginNestedMessage(2); + } + + + using FieldMetadata_HostClocks = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ClockSnapshot, + RemoteClockSync_SyncedClocks>; + + static constexpr FieldMetadata_HostClocks kHostClocks{}; + template T* set_host_clocks() { + return BeginNestedMessage(3); + } + +}; + +class ProcessTree_Decoder : public ::protozero::TypedProtoDecoder { + public: + ProcessTree_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ProcessTree_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ProcessTree_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_processes() const { return at<1>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> processes() const { return GetRepeated<::protozero::ConstBytes>(1); } + bool has_threads() const { return at<2>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> threads() const { return GetRepeated<::protozero::ConstBytes>(2); } + bool has_collection_end_timestamp() const { return at<3>().valid(); } + uint64_t collection_end_timestamp() const { return at<3>().as_uint64(); } +}; + +class ProcessTree : public ::protozero::Message { + public: + using Decoder = ProcessTree_Decoder; + enum : int32_t { + kProcessesFieldNumber = 1, + kThreadsFieldNumber = 2, + kCollectionEndTimestampFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ProcessTree"; } + + using Thread = ::perfetto::protos::pbzero::ProcessTree_Thread; + using Process = ::perfetto::protos::pbzero::ProcessTree_Process; + + using FieldMetadata_Processes = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ProcessTree_Process, + ProcessTree>; + + static constexpr FieldMetadata_Processes kProcesses{}; + template T* add_processes() { + return BeginNestedMessage(1); + } + + + using FieldMetadata_Threads = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ProcessTree_Thread, + ProcessTree>; + + static constexpr FieldMetadata_Threads kThreads{}; + template T* add_threads() { + return BeginNestedMessage(2); + } + + + using FieldMetadata_CollectionEndTimestamp = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + ProcessTree>; + + static constexpr FieldMetadata_CollectionEndTimestamp kCollectionEndTimestamp{}; + void set_collection_end_timestamp(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_CollectionEndTimestamp::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class ProcessTree_Process_Decoder : public ::protozero::TypedProtoDecoder { + public: + ProcessTree_Process_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ProcessTree_Process_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ProcessTree_Process_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_pid() const { return at<1>().valid(); } + int32_t pid() const { return at<1>().as_int32(); } + bool has_ppid() const { return at<2>().valid(); } + int32_t ppid() const { return at<2>().as_int32(); } + bool has_cmdline() const { return at<3>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstChars> cmdline() const { return GetRepeated<::protozero::ConstChars>(3); } + bool has_uid() const { return at<5>().valid(); } + int32_t uid() const { return at<5>().as_int32(); } + bool has_nspid() const { return at<6>().valid(); } + ::protozero::RepeatedFieldIterator nspid() const { return GetRepeated(6); } + bool has_process_start_from_boot() const { return at<7>().valid(); } + uint64_t process_start_from_boot() const { return at<7>().as_uint64(); } +}; + +class ProcessTree_Process : public ::protozero::Message { + public: + using Decoder = ProcessTree_Process_Decoder; + enum : int32_t { + kPidFieldNumber = 1, + kPpidFieldNumber = 2, + kCmdlineFieldNumber = 3, + kUidFieldNumber = 5, + kNspidFieldNumber = 6, + kProcessStartFromBootFieldNumber = 7, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ProcessTree.Process"; } + + + using FieldMetadata_Pid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + ProcessTree_Process>; + + static constexpr FieldMetadata_Pid kPid{}; + void set_pid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ppid = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + ProcessTree_Process>; + + static constexpr FieldMetadata_Ppid kPpid{}; + void set_ppid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ppid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Cmdline = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + ProcessTree_Process>; + + static constexpr FieldMetadata_Cmdline kCmdline{}; + void add_cmdline(const char* data, size_t size) { + AppendBytes(FieldMetadata_Cmdline::kFieldId, data, size); + } + void add_cmdline(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Cmdline::kFieldId, chars.data, chars.size); + } + void add_cmdline(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Cmdline::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Uid = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + ProcessTree_Process>; + + static constexpr FieldMetadata_Uid kUid{}; + void set_uid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Uid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Nspid = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + ProcessTree_Process>; + + static constexpr FieldMetadata_Nspid kNspid{}; + void add_nspid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Nspid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ProcessStartFromBoot = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + ProcessTree_Process>; + + static constexpr FieldMetadata_ProcessStartFromBoot kProcessStartFromBoot{}; + void set_process_start_from_boot(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_ProcessStartFromBoot::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class ProcessTree_Thread_Decoder : public ::protozero::TypedProtoDecoder { + public: + ProcessTree_Thread_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ProcessTree_Thread_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ProcessTree_Thread_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_tid() const { return at<1>().valid(); } + int32_t tid() const { return at<1>().as_int32(); } + bool has_tgid() const { return at<3>().valid(); } + int32_t tgid() const { return at<3>().as_int32(); } + bool has_name() const { return at<2>().valid(); } + ::protozero::ConstChars name() const { return at<2>().as_string(); } + bool has_nstid() const { return at<4>().valid(); } + ::protozero::RepeatedFieldIterator nstid() const { return GetRepeated(4); } +}; + +class ProcessTree_Thread : public ::protozero::Message { + public: + using Decoder = ProcessTree_Thread_Decoder; + enum : int32_t { + kTidFieldNumber = 1, + kTgidFieldNumber = 3, + kNameFieldNumber = 2, + kNstidFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ProcessTree.Thread"; } + + + using FieldMetadata_Tid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + ProcessTree_Thread>; + + static constexpr FieldMetadata_Tid kTid{}; + void set_tid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Tid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Tgid = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + ProcessTree_Thread>; + + static constexpr FieldMetadata_Tgid kTgid{}; + void set_tgid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Tgid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + ProcessTree_Thread>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Nstid = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + ProcessTree_Thread>; + + static constexpr FieldMetadata_Nstid kNstid{}; + void add_nstid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Nstid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class ProcessStats_Decoder : public ::protozero::TypedProtoDecoder { + public: + ProcessStats_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ProcessStats_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ProcessStats_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_processes() const { return at<1>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> processes() const { return GetRepeated<::protozero::ConstBytes>(1); } + bool has_collection_end_timestamp() const { return at<2>().valid(); } + uint64_t collection_end_timestamp() const { return at<2>().as_uint64(); } +}; + +class ProcessStats : public ::protozero::Message { + public: + using Decoder = ProcessStats_Decoder; + enum : int32_t { + kProcessesFieldNumber = 1, + kCollectionEndTimestampFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ProcessStats"; } + + using Thread = ::perfetto::protos::pbzero::ProcessStats_Thread; + using FDInfo = ::perfetto::protos::pbzero::ProcessStats_FDInfo; + using Process = ::perfetto::protos::pbzero::ProcessStats_Process; + + using FieldMetadata_Processes = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ProcessStats_Process, + ProcessStats>; + + static constexpr FieldMetadata_Processes kProcesses{}; + template T* add_processes() { + return BeginNestedMessage(1); + } + + + using FieldMetadata_CollectionEndTimestamp = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + ProcessStats>; + + static constexpr FieldMetadata_CollectionEndTimestamp kCollectionEndTimestamp{}; + void set_collection_end_timestamp(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_CollectionEndTimestamp::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class ProcessStats_Process_Decoder : public ::protozero::TypedProtoDecoder { + public: + ProcessStats_Process_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ProcessStats_Process_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ProcessStats_Process_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_pid() const { return at<1>().valid(); } + int32_t pid() const { return at<1>().as_int32(); } + bool has_threads() const { return at<11>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> threads() const { return GetRepeated<::protozero::ConstBytes>(11); } + bool has_vm_size_kb() const { return at<2>().valid(); } + uint64_t vm_size_kb() const { return at<2>().as_uint64(); } + bool has_vm_rss_kb() const { return at<3>().valid(); } + uint64_t vm_rss_kb() const { return at<3>().as_uint64(); } + bool has_rss_anon_kb() const { return at<4>().valid(); } + uint64_t rss_anon_kb() const { return at<4>().as_uint64(); } + bool has_rss_file_kb() const { return at<5>().valid(); } + uint64_t rss_file_kb() const { return at<5>().as_uint64(); } + bool has_rss_shmem_kb() const { return at<6>().valid(); } + uint64_t rss_shmem_kb() const { return at<6>().as_uint64(); } + bool has_vm_swap_kb() const { return at<7>().valid(); } + uint64_t vm_swap_kb() const { return at<7>().as_uint64(); } + bool has_vm_locked_kb() const { return at<8>().valid(); } + uint64_t vm_locked_kb() const { return at<8>().as_uint64(); } + bool has_vm_hwm_kb() const { return at<9>().valid(); } + uint64_t vm_hwm_kb() const { return at<9>().as_uint64(); } + bool has_oom_score_adj() const { return at<10>().valid(); } + int64_t oom_score_adj() const { return at<10>().as_int64(); } + bool has_is_peak_rss_resettable() const { return at<12>().valid(); } + bool is_peak_rss_resettable() const { return at<12>().as_bool(); } + bool has_chrome_private_footprint_kb() const { return at<13>().valid(); } + uint32_t chrome_private_footprint_kb() const { return at<13>().as_uint32(); } + bool has_chrome_peak_resident_set_kb() const { return at<14>().valid(); } + uint32_t chrome_peak_resident_set_kb() const { return at<14>().as_uint32(); } + bool has_fds() const { return at<15>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> fds() const { return GetRepeated<::protozero::ConstBytes>(15); } + bool has_smr_rss_kb() const { return at<16>().valid(); } + uint64_t smr_rss_kb() const { return at<16>().as_uint64(); } + bool has_smr_pss_kb() const { return at<17>().valid(); } + uint64_t smr_pss_kb() const { return at<17>().as_uint64(); } + bool has_smr_pss_anon_kb() const { return at<18>().valid(); } + uint64_t smr_pss_anon_kb() const { return at<18>().as_uint64(); } + bool has_smr_pss_file_kb() const { return at<19>().valid(); } + uint64_t smr_pss_file_kb() const { return at<19>().as_uint64(); } + bool has_smr_pss_shmem_kb() const { return at<20>().valid(); } + uint64_t smr_pss_shmem_kb() const { return at<20>().as_uint64(); } + bool has_runtime_user_mode() const { return at<21>().valid(); } + uint64_t runtime_user_mode() const { return at<21>().as_uint64(); } + bool has_runtime_kernel_mode() const { return at<22>().valid(); } + uint64_t runtime_kernel_mode() const { return at<22>().as_uint64(); } +}; + +class ProcessStats_Process : public ::protozero::Message { + public: + using Decoder = ProcessStats_Process_Decoder; + enum : int32_t { + kPidFieldNumber = 1, + kThreadsFieldNumber = 11, + kVmSizeKbFieldNumber = 2, + kVmRssKbFieldNumber = 3, + kRssAnonKbFieldNumber = 4, + kRssFileKbFieldNumber = 5, + kRssShmemKbFieldNumber = 6, + kVmSwapKbFieldNumber = 7, + kVmLockedKbFieldNumber = 8, + kVmHwmKbFieldNumber = 9, + kOomScoreAdjFieldNumber = 10, + kIsPeakRssResettableFieldNumber = 12, + kChromePrivateFootprintKbFieldNumber = 13, + kChromePeakResidentSetKbFieldNumber = 14, + kFdsFieldNumber = 15, + kSmrRssKbFieldNumber = 16, + kSmrPssKbFieldNumber = 17, + kSmrPssAnonKbFieldNumber = 18, + kSmrPssFileKbFieldNumber = 19, + kSmrPssShmemKbFieldNumber = 20, + kRuntimeUserModeFieldNumber = 21, + kRuntimeKernelModeFieldNumber = 22, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ProcessStats.Process"; } + + + using FieldMetadata_Pid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + ProcessStats_Process>; + + static constexpr FieldMetadata_Pid kPid{}; + void set_pid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Threads = + ::protozero::proto_utils::FieldMetadata< + 11, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ProcessStats_Thread, + ProcessStats_Process>; + + static constexpr FieldMetadata_Threads kThreads{}; + template T* add_threads() { + return BeginNestedMessage(11); + } + + + using FieldMetadata_VmSizeKb = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + ProcessStats_Process>; + + static constexpr FieldMetadata_VmSizeKb kVmSizeKb{}; + void set_vm_size_kb(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_VmSizeKb::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_VmRssKb = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + ProcessStats_Process>; + + static constexpr FieldMetadata_VmRssKb kVmRssKb{}; + void set_vm_rss_kb(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_VmRssKb::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_RssAnonKb = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + ProcessStats_Process>; + + static constexpr FieldMetadata_RssAnonKb kRssAnonKb{}; + void set_rss_anon_kb(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_RssAnonKb::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_RssFileKb = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + ProcessStats_Process>; + + static constexpr FieldMetadata_RssFileKb kRssFileKb{}; + void set_rss_file_kb(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_RssFileKb::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_RssShmemKb = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + ProcessStats_Process>; + + static constexpr FieldMetadata_RssShmemKb kRssShmemKb{}; + void set_rss_shmem_kb(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_RssShmemKb::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_VmSwapKb = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + ProcessStats_Process>; + + static constexpr FieldMetadata_VmSwapKb kVmSwapKb{}; + void set_vm_swap_kb(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_VmSwapKb::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_VmLockedKb = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + ProcessStats_Process>; + + static constexpr FieldMetadata_VmLockedKb kVmLockedKb{}; + void set_vm_locked_kb(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_VmLockedKb::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_VmHwmKb = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + ProcessStats_Process>; + + static constexpr FieldMetadata_VmHwmKb kVmHwmKb{}; + void set_vm_hwm_kb(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_VmHwmKb::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_OomScoreAdj = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + ProcessStats_Process>; + + static constexpr FieldMetadata_OomScoreAdj kOomScoreAdj{}; + void set_oom_score_adj(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_OomScoreAdj::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_IsPeakRssResettable = + ::protozero::proto_utils::FieldMetadata< + 12, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + ProcessStats_Process>; + + static constexpr FieldMetadata_IsPeakRssResettable kIsPeakRssResettable{}; + void set_is_peak_rss_resettable(bool value) { + static constexpr uint32_t field_id = FieldMetadata_IsPeakRssResettable::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ChromePrivateFootprintKb = + ::protozero::proto_utils::FieldMetadata< + 13, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + ProcessStats_Process>; + + static constexpr FieldMetadata_ChromePrivateFootprintKb kChromePrivateFootprintKb{}; + void set_chrome_private_footprint_kb(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ChromePrivateFootprintKb::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ChromePeakResidentSetKb = + ::protozero::proto_utils::FieldMetadata< + 14, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + ProcessStats_Process>; + + static constexpr FieldMetadata_ChromePeakResidentSetKb kChromePeakResidentSetKb{}; + void set_chrome_peak_resident_set_kb(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ChromePeakResidentSetKb::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Fds = + ::protozero::proto_utils::FieldMetadata< + 15, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ProcessStats_FDInfo, + ProcessStats_Process>; + + static constexpr FieldMetadata_Fds kFds{}; + template T* add_fds() { + return BeginNestedMessage(15); + } + + + using FieldMetadata_SmrRssKb = + ::protozero::proto_utils::FieldMetadata< + 16, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + ProcessStats_Process>; + + static constexpr FieldMetadata_SmrRssKb kSmrRssKb{}; + void set_smr_rss_kb(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_SmrRssKb::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SmrPssKb = + ::protozero::proto_utils::FieldMetadata< + 17, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + ProcessStats_Process>; + + static constexpr FieldMetadata_SmrPssKb kSmrPssKb{}; + void set_smr_pss_kb(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_SmrPssKb::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SmrPssAnonKb = + ::protozero::proto_utils::FieldMetadata< + 18, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + ProcessStats_Process>; + + static constexpr FieldMetadata_SmrPssAnonKb kSmrPssAnonKb{}; + void set_smr_pss_anon_kb(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_SmrPssAnonKb::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SmrPssFileKb = + ::protozero::proto_utils::FieldMetadata< + 19, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + ProcessStats_Process>; + + static constexpr FieldMetadata_SmrPssFileKb kSmrPssFileKb{}; + void set_smr_pss_file_kb(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_SmrPssFileKb::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SmrPssShmemKb = + ::protozero::proto_utils::FieldMetadata< + 20, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + ProcessStats_Process>; + + static constexpr FieldMetadata_SmrPssShmemKb kSmrPssShmemKb{}; + void set_smr_pss_shmem_kb(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_SmrPssShmemKb::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_RuntimeUserMode = + ::protozero::proto_utils::FieldMetadata< + 21, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + ProcessStats_Process>; + + static constexpr FieldMetadata_RuntimeUserMode kRuntimeUserMode{}; + void set_runtime_user_mode(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_RuntimeUserMode::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_RuntimeKernelMode = + ::protozero::proto_utils::FieldMetadata< + 22, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + ProcessStats_Process>; + + static constexpr FieldMetadata_RuntimeKernelMode kRuntimeKernelMode{}; + void set_runtime_kernel_mode(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_RuntimeKernelMode::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class ProcessStats_FDInfo_Decoder : public ::protozero::TypedProtoDecoder { + public: + ProcessStats_FDInfo_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ProcessStats_FDInfo_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ProcessStats_FDInfo_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_fd() const { return at<1>().valid(); } + uint64_t fd() const { return at<1>().as_uint64(); } + bool has_path() const { return at<2>().valid(); } + ::protozero::ConstChars path() const { return at<2>().as_string(); } +}; + +class ProcessStats_FDInfo : public ::protozero::Message { + public: + using Decoder = ProcessStats_FDInfo_Decoder; + enum : int32_t { + kFdFieldNumber = 1, + kPathFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ProcessStats.FDInfo"; } + + + using FieldMetadata_Fd = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + ProcessStats_FDInfo>; + + static constexpr FieldMetadata_Fd kFd{}; + void set_fd(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Fd::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Path = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + ProcessStats_FDInfo>; + + static constexpr FieldMetadata_Path kPath{}; + void set_path(const char* data, size_t size) { + AppendBytes(FieldMetadata_Path::kFieldId, data, size); + } + void set_path(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Path::kFieldId, chars.data, chars.size); + } + void set_path(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Path::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class ProcessStats_Thread_Decoder : public ::protozero::TypedProtoDecoder { + public: + ProcessStats_Thread_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ProcessStats_Thread_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ProcessStats_Thread_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_tid() const { return at<1>().valid(); } + int32_t tid() const { return at<1>().as_int32(); } +}; + +class ProcessStats_Thread : public ::protozero::Message { + public: + using Decoder = ProcessStats_Thread_Decoder; + enum : int32_t { + kTidFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ProcessStats.Thread"; } + + + using FieldMetadata_Tid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + ProcessStats_Thread>; + + static constexpr FieldMetadata_Tid kTid{}; + void set_tid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Tid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class SmapsPacket_Decoder : public ::protozero::TypedProtoDecoder { + public: + SmapsPacket_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit SmapsPacket_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit SmapsPacket_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_pid() const { return at<1>().valid(); } + uint32_t pid() const { return at<1>().as_uint32(); } + bool has_entries() const { return at<2>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> entries() const { return GetRepeated<::protozero::ConstBytes>(2); } +}; + +class SmapsPacket : public ::protozero::Message { + public: + using Decoder = SmapsPacket_Decoder; + enum : int32_t { + kPidFieldNumber = 1, + kEntriesFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.SmapsPacket"; } + + + using FieldMetadata_Pid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SmapsPacket>; + + static constexpr FieldMetadata_Pid kPid{}; + void set_pid(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Entries = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + SmapsEntry, + SmapsPacket>; + + static constexpr FieldMetadata_Entries kEntries{}; + template T* add_entries() { + return BeginNestedMessage(2); + } + +}; + +class SmapsEntry_Decoder : public ::protozero::TypedProtoDecoder { + public: + SmapsEntry_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit SmapsEntry_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit SmapsEntry_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_path() const { return at<1>().valid(); } + ::protozero::ConstChars path() const { return at<1>().as_string(); } + bool has_size_kb() const { return at<2>().valid(); } + uint64_t size_kb() const { return at<2>().as_uint64(); } + bool has_private_dirty_kb() const { return at<3>().valid(); } + uint64_t private_dirty_kb() const { return at<3>().as_uint64(); } + bool has_swap_kb() const { return at<4>().valid(); } + uint64_t swap_kb() const { return at<4>().as_uint64(); } + bool has_file_name() const { return at<5>().valid(); } + ::protozero::ConstChars file_name() const { return at<5>().as_string(); } + bool has_start_address() const { return at<6>().valid(); } + uint64_t start_address() const { return at<6>().as_uint64(); } + bool has_module_timestamp() const { return at<7>().valid(); } + uint64_t module_timestamp() const { return at<7>().as_uint64(); } + bool has_module_debugid() const { return at<8>().valid(); } + ::protozero::ConstChars module_debugid() const { return at<8>().as_string(); } + bool has_module_debug_path() const { return at<9>().valid(); } + ::protozero::ConstChars module_debug_path() const { return at<9>().as_string(); } + bool has_protection_flags() const { return at<10>().valid(); } + uint32_t protection_flags() const { return at<10>().as_uint32(); } + bool has_private_clean_resident_kb() const { return at<11>().valid(); } + uint64_t private_clean_resident_kb() const { return at<11>().as_uint64(); } + bool has_shared_dirty_resident_kb() const { return at<12>().valid(); } + uint64_t shared_dirty_resident_kb() const { return at<12>().as_uint64(); } + bool has_shared_clean_resident_kb() const { return at<13>().valid(); } + uint64_t shared_clean_resident_kb() const { return at<13>().as_uint64(); } + bool has_locked_kb() const { return at<14>().valid(); } + uint64_t locked_kb() const { return at<14>().as_uint64(); } + bool has_proportional_resident_kb() const { return at<15>().valid(); } + uint64_t proportional_resident_kb() const { return at<15>().as_uint64(); } +}; + +class SmapsEntry : public ::protozero::Message { + public: + using Decoder = SmapsEntry_Decoder; + enum : int32_t { + kPathFieldNumber = 1, + kSizeKbFieldNumber = 2, + kPrivateDirtyKbFieldNumber = 3, + kSwapKbFieldNumber = 4, + kFileNameFieldNumber = 5, + kStartAddressFieldNumber = 6, + kModuleTimestampFieldNumber = 7, + kModuleDebugidFieldNumber = 8, + kModuleDebugPathFieldNumber = 9, + kProtectionFlagsFieldNumber = 10, + kPrivateCleanResidentKbFieldNumber = 11, + kSharedDirtyResidentKbFieldNumber = 12, + kSharedCleanResidentKbFieldNumber = 13, + kLockedKbFieldNumber = 14, + kProportionalResidentKbFieldNumber = 15, + }; + static constexpr const char* GetName() { return ".perfetto.protos.SmapsEntry"; } + + + using FieldMetadata_Path = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + SmapsEntry>; + + static constexpr FieldMetadata_Path kPath{}; + void set_path(const char* data, size_t size) { + AppendBytes(FieldMetadata_Path::kFieldId, data, size); + } + void set_path(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Path::kFieldId, chars.data, chars.size); + } + void set_path(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Path::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SizeKb = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + SmapsEntry>; + + static constexpr FieldMetadata_SizeKb kSizeKb{}; + void set_size_kb(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_SizeKb::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PrivateDirtyKb = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + SmapsEntry>; + + static constexpr FieldMetadata_PrivateDirtyKb kPrivateDirtyKb{}; + void set_private_dirty_kb(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_PrivateDirtyKb::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SwapKb = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + SmapsEntry>; + + static constexpr FieldMetadata_SwapKb kSwapKb{}; + void set_swap_kb(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_SwapKb::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FileName = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + SmapsEntry>; + + static constexpr FieldMetadata_FileName kFileName{}; + void set_file_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_FileName::kFieldId, data, size); + } + void set_file_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_FileName::kFieldId, chars.data, chars.size); + } + void set_file_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_FileName::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_StartAddress = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + SmapsEntry>; + + static constexpr FieldMetadata_StartAddress kStartAddress{}; + void set_start_address(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_StartAddress::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ModuleTimestamp = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + SmapsEntry>; + + static constexpr FieldMetadata_ModuleTimestamp kModuleTimestamp{}; + void set_module_timestamp(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_ModuleTimestamp::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ModuleDebugid = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + SmapsEntry>; + + static constexpr FieldMetadata_ModuleDebugid kModuleDebugid{}; + void set_module_debugid(const char* data, size_t size) { + AppendBytes(FieldMetadata_ModuleDebugid::kFieldId, data, size); + } + void set_module_debugid(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_ModuleDebugid::kFieldId, chars.data, chars.size); + } + void set_module_debugid(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_ModuleDebugid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ModuleDebugPath = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + SmapsEntry>; + + static constexpr FieldMetadata_ModuleDebugPath kModuleDebugPath{}; + void set_module_debug_path(const char* data, size_t size) { + AppendBytes(FieldMetadata_ModuleDebugPath::kFieldId, data, size); + } + void set_module_debug_path(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_ModuleDebugPath::kFieldId, chars.data, chars.size); + } + void set_module_debug_path(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_ModuleDebugPath::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ProtectionFlags = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SmapsEntry>; + + static constexpr FieldMetadata_ProtectionFlags kProtectionFlags{}; + void set_protection_flags(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ProtectionFlags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PrivateCleanResidentKb = + ::protozero::proto_utils::FieldMetadata< + 11, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + SmapsEntry>; + + static constexpr FieldMetadata_PrivateCleanResidentKb kPrivateCleanResidentKb{}; + void set_private_clean_resident_kb(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_PrivateCleanResidentKb::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SharedDirtyResidentKb = + ::protozero::proto_utils::FieldMetadata< + 12, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + SmapsEntry>; + + static constexpr FieldMetadata_SharedDirtyResidentKb kSharedDirtyResidentKb{}; + void set_shared_dirty_resident_kb(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_SharedDirtyResidentKb::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SharedCleanResidentKb = + ::protozero::proto_utils::FieldMetadata< + 13, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + SmapsEntry>; + + static constexpr FieldMetadata_SharedCleanResidentKb kSharedCleanResidentKb{}; + void set_shared_clean_resident_kb(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_SharedCleanResidentKb::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_LockedKb = + ::protozero::proto_utils::FieldMetadata< + 14, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + SmapsEntry>; + + static constexpr FieldMetadata_LockedKb kLockedKb{}; + void set_locked_kb(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_LockedKb::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ProportionalResidentKb = + ::protozero::proto_utils::FieldMetadata< + 15, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + SmapsEntry>; + + static constexpr FieldMetadata_ProportionalResidentKb kProportionalResidentKb{}; + void set_proportional_resident_kb(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_ProportionalResidentKb::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class PerfSampleDefaults_Decoder : public ::protozero::TypedProtoDecoder { + public: + PerfSampleDefaults_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit PerfSampleDefaults_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit PerfSampleDefaults_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_timebase() const { return at<1>().valid(); } + ::protozero::ConstBytes timebase() const { return at<1>().as_bytes(); } + bool has_process_shard_count() const { return at<2>().valid(); } + uint32_t process_shard_count() const { return at<2>().as_uint32(); } + bool has_chosen_process_shard() const { return at<3>().valid(); } + uint32_t chosen_process_shard() const { return at<3>().as_uint32(); } +}; + +class PerfSampleDefaults : public ::protozero::Message { + public: + using Decoder = PerfSampleDefaults_Decoder; + enum : int32_t { + kTimebaseFieldNumber = 1, + kProcessShardCountFieldNumber = 2, + kChosenProcessShardFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.PerfSampleDefaults"; } + + + using FieldMetadata_Timebase = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + PerfEvents_Timebase, + PerfSampleDefaults>; + + static constexpr FieldMetadata_Timebase kTimebase{}; + template T* set_timebase() { + return BeginNestedMessage(1); + } + + + using FieldMetadata_ProcessShardCount = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + PerfSampleDefaults>; + + static constexpr FieldMetadata_ProcessShardCount kProcessShardCount{}; + void set_process_shard_count(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ProcessShardCount::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ChosenProcessShard = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + PerfSampleDefaults>; + + static constexpr FieldMetadata_ChosenProcessShard kChosenProcessShard{}; + void set_chosen_process_shard(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ChosenProcessShard::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class PerfSample_Decoder : public ::protozero::TypedProtoDecoder { + public: + PerfSample_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit PerfSample_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit PerfSample_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_cpu() const { return at<1>().valid(); } + uint32_t cpu() const { return at<1>().as_uint32(); } + bool has_pid() const { return at<2>().valid(); } + uint32_t pid() const { return at<2>().as_uint32(); } + bool has_tid() const { return at<3>().valid(); } + uint32_t tid() const { return at<3>().as_uint32(); } + bool has_cpu_mode() const { return at<5>().valid(); } + int32_t cpu_mode() const { return at<5>().as_int32(); } + bool has_timebase_count() const { return at<6>().valid(); } + uint64_t timebase_count() const { return at<6>().as_uint64(); } + bool has_callstack_iid() const { return at<4>().valid(); } + uint64_t callstack_iid() const { return at<4>().as_uint64(); } + bool has_unwind_error() const { return at<16>().valid(); } + int32_t unwind_error() const { return at<16>().as_int32(); } + bool has_kernel_records_lost() const { return at<17>().valid(); } + uint64_t kernel_records_lost() const { return at<17>().as_uint64(); } + bool has_sample_skipped_reason() const { return at<18>().valid(); } + int32_t sample_skipped_reason() const { return at<18>().as_int32(); } + bool has_producer_event() const { return at<19>().valid(); } + ::protozero::ConstBytes producer_event() const { return at<19>().as_bytes(); } +}; + +class PerfSample : public ::protozero::Message { + public: + using Decoder = PerfSample_Decoder; + enum : int32_t { + kCpuFieldNumber = 1, + kPidFieldNumber = 2, + kTidFieldNumber = 3, + kCpuModeFieldNumber = 5, + kTimebaseCountFieldNumber = 6, + kCallstackIidFieldNumber = 4, + kUnwindErrorFieldNumber = 16, + kKernelRecordsLostFieldNumber = 17, + kSampleSkippedReasonFieldNumber = 18, + kProducerEventFieldNumber = 19, + }; + static constexpr const char* GetName() { return ".perfetto.protos.PerfSample"; } + + using ProducerEvent = ::perfetto::protos::pbzero::PerfSample_ProducerEvent; + + using SampleSkipReason = ::perfetto::protos::pbzero::PerfSample_SampleSkipReason; + static inline const char* SampleSkipReason_Name(SampleSkipReason value) { + return ::perfetto::protos::pbzero::PerfSample_SampleSkipReason_Name(value); + } + static inline const SampleSkipReason PROFILER_SKIP_UNKNOWN = SampleSkipReason::PROFILER_SKIP_UNKNOWN; + static inline const SampleSkipReason PROFILER_SKIP_READ_STAGE = SampleSkipReason::PROFILER_SKIP_READ_STAGE; + static inline const SampleSkipReason PROFILER_SKIP_UNWIND_STAGE = SampleSkipReason::PROFILER_SKIP_UNWIND_STAGE; + static inline const SampleSkipReason PROFILER_SKIP_UNWIND_ENQUEUE = SampleSkipReason::PROFILER_SKIP_UNWIND_ENQUEUE; + + using FieldMetadata_Cpu = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + PerfSample>; + + static constexpr FieldMetadata_Cpu kCpu{}; + void set_cpu(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Cpu::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pid = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + PerfSample>; + + static constexpr FieldMetadata_Pid kPid{}; + void set_pid(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Tid = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + PerfSample>; + + static constexpr FieldMetadata_Tid kTid{}; + void set_tid(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Tid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CpuMode = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + Profiling_CpuMode, + PerfSample>; + + static constexpr FieldMetadata_CpuMode kCpuMode{}; + void set_cpu_mode(Profiling_CpuMode value) { + static constexpr uint32_t field_id = FieldMetadata_CpuMode::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TimebaseCount = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + PerfSample>; + + static constexpr FieldMetadata_TimebaseCount kTimebaseCount{}; + void set_timebase_count(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_TimebaseCount::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CallstackIid = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + PerfSample>; + + static constexpr FieldMetadata_CallstackIid kCallstackIid{}; + void set_callstack_iid(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_CallstackIid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_UnwindError = + ::protozero::proto_utils::FieldMetadata< + 16, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + Profiling_StackUnwindError, + PerfSample>; + + static constexpr FieldMetadata_UnwindError kUnwindError{}; + void set_unwind_error(Profiling_StackUnwindError value) { + static constexpr uint32_t field_id = FieldMetadata_UnwindError::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_KernelRecordsLost = + ::protozero::proto_utils::FieldMetadata< + 17, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + PerfSample>; + + static constexpr FieldMetadata_KernelRecordsLost kKernelRecordsLost{}; + void set_kernel_records_lost(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_KernelRecordsLost::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SampleSkippedReason = + ::protozero::proto_utils::FieldMetadata< + 18, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + PerfSample_SampleSkipReason, + PerfSample>; + + static constexpr FieldMetadata_SampleSkippedReason kSampleSkippedReason{}; + void set_sample_skipped_reason(PerfSample_SampleSkipReason value) { + static constexpr uint32_t field_id = FieldMetadata_SampleSkippedReason::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ProducerEvent = + ::protozero::proto_utils::FieldMetadata< + 19, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + PerfSample_ProducerEvent, + PerfSample>; + + static constexpr FieldMetadata_ProducerEvent kProducerEvent{}; + template T* set_producer_event() { + return BeginNestedMessage(19); + } + +}; + +class PerfSample_ProducerEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + PerfSample_ProducerEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit PerfSample_ProducerEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit PerfSample_ProducerEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_source_stop_reason() const { return at<1>().valid(); } + int32_t source_stop_reason() const { return at<1>().as_int32(); } +}; + +class PerfSample_ProducerEvent : public ::protozero::Message { + public: + using Decoder = PerfSample_ProducerEvent_Decoder; + enum : int32_t { + kSourceStopReasonFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.PerfSample.ProducerEvent"; } + + + using DataSourceStopReason = ::perfetto::protos::pbzero::PerfSample_ProducerEvent_DataSourceStopReason; + static inline const char* DataSourceStopReason_Name(DataSourceStopReason value) { + return ::perfetto::protos::pbzero::PerfSample_ProducerEvent_DataSourceStopReason_Name(value); + } + static inline const DataSourceStopReason PROFILER_STOP_UNKNOWN = DataSourceStopReason::PROFILER_STOP_UNKNOWN; + static inline const DataSourceStopReason PROFILER_STOP_GUARDRAIL = DataSourceStopReason::PROFILER_STOP_GUARDRAIL; + + using FieldMetadata_SourceStopReason = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + PerfSample_ProducerEvent_DataSourceStopReason, + PerfSample_ProducerEvent>; + + static constexpr FieldMetadata_SourceStopReason kSourceStopReason{}; + void set_source_stop_reason(PerfSample_ProducerEvent_DataSourceStopReason value) { + static constexpr uint32_t field_id = FieldMetadata_SourceStopReason::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } +}; + +class Profiling_Decoder : public ::protozero::TypedProtoDecoder { + public: + Profiling_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Profiling_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Profiling_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} +}; + +class Profiling : public ::protozero::Message { + public: + using Decoder = Profiling_Decoder; + static constexpr const char* GetName() { return ".perfetto.protos.Profiling"; } + + + using CpuMode = ::perfetto::protos::pbzero::Profiling_CpuMode; + static inline const char* CpuMode_Name(CpuMode value) { + return ::perfetto::protos::pbzero::Profiling_CpuMode_Name(value); + } + + using StackUnwindError = ::perfetto::protos::pbzero::Profiling_StackUnwindError; + static inline const char* StackUnwindError_Name(StackUnwindError value) { + return ::perfetto::protos::pbzero::Profiling_StackUnwindError_Name(value); + } + static inline const CpuMode MODE_UNKNOWN = CpuMode::MODE_UNKNOWN; + static inline const CpuMode MODE_KERNEL = CpuMode::MODE_KERNEL; + static inline const CpuMode MODE_USER = CpuMode::MODE_USER; + static inline const CpuMode MODE_HYPERVISOR = CpuMode::MODE_HYPERVISOR; + static inline const CpuMode MODE_GUEST_KERNEL = CpuMode::MODE_GUEST_KERNEL; + static inline const CpuMode MODE_GUEST_USER = CpuMode::MODE_GUEST_USER; + static inline const StackUnwindError UNWIND_ERROR_UNKNOWN = StackUnwindError::UNWIND_ERROR_UNKNOWN; + static inline const StackUnwindError UNWIND_ERROR_NONE = StackUnwindError::UNWIND_ERROR_NONE; + static inline const StackUnwindError UNWIND_ERROR_MEMORY_INVALID = StackUnwindError::UNWIND_ERROR_MEMORY_INVALID; + static inline const StackUnwindError UNWIND_ERROR_UNWIND_INFO = StackUnwindError::UNWIND_ERROR_UNWIND_INFO; + static inline const StackUnwindError UNWIND_ERROR_UNSUPPORTED = StackUnwindError::UNWIND_ERROR_UNSUPPORTED; + static inline const StackUnwindError UNWIND_ERROR_INVALID_MAP = StackUnwindError::UNWIND_ERROR_INVALID_MAP; + static inline const StackUnwindError UNWIND_ERROR_MAX_FRAMES_EXCEEDED = StackUnwindError::UNWIND_ERROR_MAX_FRAMES_EXCEEDED; + static inline const StackUnwindError UNWIND_ERROR_REPEATED_FRAME = StackUnwindError::UNWIND_ERROR_REPEATED_FRAME; + static inline const StackUnwindError UNWIND_ERROR_INVALID_ELF = StackUnwindError::UNWIND_ERROR_INVALID_ELF; + static inline const StackUnwindError UNWIND_ERROR_SYSTEM_CALL = StackUnwindError::UNWIND_ERROR_SYSTEM_CALL; + static inline const StackUnwindError UNWIND_ERROR_THREAD_TIMEOUT = StackUnwindError::UNWIND_ERROR_THREAD_TIMEOUT; + static inline const StackUnwindError UNWIND_ERROR_THREAD_DOES_NOT_EXIST = StackUnwindError::UNWIND_ERROR_THREAD_DOES_NOT_EXIST; + static inline const StackUnwindError UNWIND_ERROR_BAD_ARCH = StackUnwindError::UNWIND_ERROR_BAD_ARCH; + static inline const StackUnwindError UNWIND_ERROR_MAPS_PARSE = StackUnwindError::UNWIND_ERROR_MAPS_PARSE; + static inline const StackUnwindError UNWIND_ERROR_INVALID_PARAMETER = StackUnwindError::UNWIND_ERROR_INVALID_PARAMETER; + static inline const StackUnwindError UNWIND_ERROR_PTRACE_CALL = StackUnwindError::UNWIND_ERROR_PTRACE_CALL; +}; + +class StreamingProfilePacket_Decoder : public ::protozero::TypedProtoDecoder { + public: + StreamingProfilePacket_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit StreamingProfilePacket_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit StreamingProfilePacket_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_callstack_iid() const { return at<1>().valid(); } + ::protozero::RepeatedFieldIterator callstack_iid() const { return GetRepeated(1); } + bool has_timestamp_delta_us() const { return at<2>().valid(); } + ::protozero::RepeatedFieldIterator timestamp_delta_us() const { return GetRepeated(2); } + bool has_process_priority() const { return at<3>().valid(); } + int32_t process_priority() const { return at<3>().as_int32(); } +}; + +class StreamingProfilePacket : public ::protozero::Message { + public: + using Decoder = StreamingProfilePacket_Decoder; + enum : int32_t { + kCallstackIidFieldNumber = 1, + kTimestampDeltaUsFieldNumber = 2, + kProcessPriorityFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.StreamingProfilePacket"; } + + + using FieldMetadata_CallstackIid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + StreamingProfilePacket>; + + static constexpr FieldMetadata_CallstackIid kCallstackIid{}; + void add_callstack_iid(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_CallstackIid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TimestampDeltaUs = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + StreamingProfilePacket>; + + static constexpr FieldMetadata_TimestampDeltaUs kTimestampDeltaUs{}; + void add_timestamp_delta_us(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_TimestampDeltaUs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ProcessPriority = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + StreamingProfilePacket>; + + static constexpr FieldMetadata_ProcessPriority kProcessPriority{}; + void set_process_priority(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ProcessPriority::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class StreamingFree_Decoder : public ::protozero::TypedProtoDecoder { + public: + StreamingFree_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit StreamingFree_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit StreamingFree_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_address() const { return at<1>().valid(); } + ::protozero::RepeatedFieldIterator address() const { return GetRepeated(1); } + bool has_heap_id() const { return at<2>().valid(); } + ::protozero::RepeatedFieldIterator heap_id() const { return GetRepeated(2); } + bool has_sequence_number() const { return at<3>().valid(); } + ::protozero::RepeatedFieldIterator sequence_number() const { return GetRepeated(3); } +}; + +class StreamingFree : public ::protozero::Message { + public: + using Decoder = StreamingFree_Decoder; + enum : int32_t { + kAddressFieldNumber = 1, + kHeapIdFieldNumber = 2, + kSequenceNumberFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.StreamingFree"; } + + + using FieldMetadata_Address = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + StreamingFree>; + + static constexpr FieldMetadata_Address kAddress{}; + void add_address(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Address::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_HeapId = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + StreamingFree>; + + static constexpr FieldMetadata_HeapId kHeapId{}; + void add_heap_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_HeapId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SequenceNumber = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + StreamingFree>; + + static constexpr FieldMetadata_SequenceNumber kSequenceNumber{}; + void add_sequence_number(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_SequenceNumber::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class StreamingAllocation_Decoder : public ::protozero::TypedProtoDecoder { + public: + StreamingAllocation_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit StreamingAllocation_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit StreamingAllocation_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_address() const { return at<1>().valid(); } + ::protozero::RepeatedFieldIterator address() const { return GetRepeated(1); } + bool has_size() const { return at<2>().valid(); } + ::protozero::RepeatedFieldIterator size() const { return GetRepeated(2); } + bool has_sample_size() const { return at<3>().valid(); } + ::protozero::RepeatedFieldIterator sample_size() const { return GetRepeated(3); } + bool has_clock_monotonic_coarse_timestamp() const { return at<4>().valid(); } + ::protozero::RepeatedFieldIterator clock_monotonic_coarse_timestamp() const { return GetRepeated(4); } + bool has_heap_id() const { return at<5>().valid(); } + ::protozero::RepeatedFieldIterator heap_id() const { return GetRepeated(5); } + bool has_sequence_number() const { return at<6>().valid(); } + ::protozero::RepeatedFieldIterator sequence_number() const { return GetRepeated(6); } +}; + +class StreamingAllocation : public ::protozero::Message { + public: + using Decoder = StreamingAllocation_Decoder; + enum : int32_t { + kAddressFieldNumber = 1, + kSizeFieldNumber = 2, + kSampleSizeFieldNumber = 3, + kClockMonotonicCoarseTimestampFieldNumber = 4, + kHeapIdFieldNumber = 5, + kSequenceNumberFieldNumber = 6, + }; + static constexpr const char* GetName() { return ".perfetto.protos.StreamingAllocation"; } + + + using FieldMetadata_Address = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + StreamingAllocation>; + + static constexpr FieldMetadata_Address kAddress{}; + void add_address(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Address::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Size = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + StreamingAllocation>; + + static constexpr FieldMetadata_Size kSize{}; + void add_size(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Size::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SampleSize = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + StreamingAllocation>; + + static constexpr FieldMetadata_SampleSize kSampleSize{}; + void add_sample_size(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_SampleSize::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ClockMonotonicCoarseTimestamp = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + StreamingAllocation>; + + static constexpr FieldMetadata_ClockMonotonicCoarseTimestamp kClockMonotonicCoarseTimestamp{}; + void add_clock_monotonic_coarse_timestamp(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_ClockMonotonicCoarseTimestamp::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_HeapId = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + StreamingAllocation>; + + static constexpr FieldMetadata_HeapId kHeapId{}; + void add_heap_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_HeapId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SequenceNumber = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + StreamingAllocation>; + + static constexpr FieldMetadata_SequenceNumber kSequenceNumber{}; + void add_sequence_number(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_SequenceNumber::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class ProfilePacket_Decoder : public ::protozero::TypedProtoDecoder { + public: + ProfilePacket_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ProfilePacket_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ProfilePacket_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_strings() const { return at<1>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> strings() const { return GetRepeated<::protozero::ConstBytes>(1); } + bool has_mappings() const { return at<4>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> mappings() const { return GetRepeated<::protozero::ConstBytes>(4); } + bool has_frames() const { return at<2>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> frames() const { return GetRepeated<::protozero::ConstBytes>(2); } + bool has_callstacks() const { return at<3>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> callstacks() const { return GetRepeated<::protozero::ConstBytes>(3); } + bool has_process_dumps() const { return at<5>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> process_dumps() const { return GetRepeated<::protozero::ConstBytes>(5); } + bool has_continued() const { return at<6>().valid(); } + bool continued() const { return at<6>().as_bool(); } + bool has_index() const { return at<7>().valid(); } + uint64_t index() const { return at<7>().as_uint64(); } +}; + +class ProfilePacket : public ::protozero::Message { + public: + using Decoder = ProfilePacket_Decoder; + enum : int32_t { + kStringsFieldNumber = 1, + kMappingsFieldNumber = 4, + kFramesFieldNumber = 2, + kCallstacksFieldNumber = 3, + kProcessDumpsFieldNumber = 5, + kContinuedFieldNumber = 6, + kIndexFieldNumber = 7, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ProfilePacket"; } + + using HeapSample = ::perfetto::protos::pbzero::ProfilePacket_HeapSample; + using Histogram = ::perfetto::protos::pbzero::ProfilePacket_Histogram; + using ProcessStats = ::perfetto::protos::pbzero::ProfilePacket_ProcessStats; + using ProcessHeapSamples = ::perfetto::protos::pbzero::ProfilePacket_ProcessHeapSamples; + + using FieldMetadata_Strings = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + InternedString, + ProfilePacket>; + + static constexpr FieldMetadata_Strings kStrings{}; + template T* add_strings() { + return BeginNestedMessage(1); + } + + + using FieldMetadata_Mappings = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Mapping, + ProfilePacket>; + + static constexpr FieldMetadata_Mappings kMappings{}; + template T* add_mappings() { + return BeginNestedMessage(4); + } + + + using FieldMetadata_Frames = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Frame, + ProfilePacket>; + + static constexpr FieldMetadata_Frames kFrames{}; + template T* add_frames() { + return BeginNestedMessage(2); + } + + + using FieldMetadata_Callstacks = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Callstack, + ProfilePacket>; + + static constexpr FieldMetadata_Callstacks kCallstacks{}; + template T* add_callstacks() { + return BeginNestedMessage(3); + } + + + using FieldMetadata_ProcessDumps = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ProfilePacket_ProcessHeapSamples, + ProfilePacket>; + + static constexpr FieldMetadata_ProcessDumps kProcessDumps{}; + template T* add_process_dumps() { + return BeginNestedMessage(5); + } + + + using FieldMetadata_Continued = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + ProfilePacket>; + + static constexpr FieldMetadata_Continued kContinued{}; + void set_continued(bool value) { + static constexpr uint32_t field_id = FieldMetadata_Continued::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Index = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + ProfilePacket>; + + static constexpr FieldMetadata_Index kIndex{}; + void set_index(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Index::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class ProfilePacket_ProcessHeapSamples_Decoder : public ::protozero::TypedProtoDecoder { + public: + ProfilePacket_ProcessHeapSamples_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ProfilePacket_ProcessHeapSamples_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ProfilePacket_ProcessHeapSamples_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_pid() const { return at<1>().valid(); } + uint64_t pid() const { return at<1>().as_uint64(); } + bool has_from_startup() const { return at<3>().valid(); } + bool from_startup() const { return at<3>().as_bool(); } + bool has_rejected_concurrent() const { return at<4>().valid(); } + bool rejected_concurrent() const { return at<4>().as_bool(); } + bool has_disconnected() const { return at<6>().valid(); } + bool disconnected() const { return at<6>().as_bool(); } + bool has_buffer_overran() const { return at<7>().valid(); } + bool buffer_overran() const { return at<7>().as_bool(); } + bool has_client_error() const { return at<14>().valid(); } + int32_t client_error() const { return at<14>().as_int32(); } + bool has_buffer_corrupted() const { return at<8>().valid(); } + bool buffer_corrupted() const { return at<8>().as_bool(); } + bool has_hit_guardrail() const { return at<10>().valid(); } + bool hit_guardrail() const { return at<10>().as_bool(); } + bool has_heap_name() const { return at<11>().valid(); } + ::protozero::ConstChars heap_name() const { return at<11>().as_string(); } + bool has_sampling_interval_bytes() const { return at<12>().valid(); } + uint64_t sampling_interval_bytes() const { return at<12>().as_uint64(); } + bool has_orig_sampling_interval_bytes() const { return at<13>().valid(); } + uint64_t orig_sampling_interval_bytes() const { return at<13>().as_uint64(); } + bool has_timestamp() const { return at<9>().valid(); } + uint64_t timestamp() const { return at<9>().as_uint64(); } + bool has_stats() const { return at<5>().valid(); } + ::protozero::ConstBytes stats() const { return at<5>().as_bytes(); } + bool has_samples() const { return at<2>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> samples() const { return GetRepeated<::protozero::ConstBytes>(2); } +}; + +class ProfilePacket_ProcessHeapSamples : public ::protozero::Message { + public: + using Decoder = ProfilePacket_ProcessHeapSamples_Decoder; + enum : int32_t { + kPidFieldNumber = 1, + kFromStartupFieldNumber = 3, + kRejectedConcurrentFieldNumber = 4, + kDisconnectedFieldNumber = 6, + kBufferOverranFieldNumber = 7, + kClientErrorFieldNumber = 14, + kBufferCorruptedFieldNumber = 8, + kHitGuardrailFieldNumber = 10, + kHeapNameFieldNumber = 11, + kSamplingIntervalBytesFieldNumber = 12, + kOrigSamplingIntervalBytesFieldNumber = 13, + kTimestampFieldNumber = 9, + kStatsFieldNumber = 5, + kSamplesFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ProfilePacket.ProcessHeapSamples"; } + + + using ClientError = ::perfetto::protos::pbzero::ProfilePacket_ProcessHeapSamples_ClientError; + static inline const char* ClientError_Name(ClientError value) { + return ::perfetto::protos::pbzero::ProfilePacket_ProcessHeapSamples_ClientError_Name(value); + } + static inline const ClientError CLIENT_ERROR_NONE = ClientError::CLIENT_ERROR_NONE; + static inline const ClientError CLIENT_ERROR_HIT_TIMEOUT = ClientError::CLIENT_ERROR_HIT_TIMEOUT; + static inline const ClientError CLIENT_ERROR_INVALID_STACK_BOUNDS = ClientError::CLIENT_ERROR_INVALID_STACK_BOUNDS; + + using FieldMetadata_Pid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + ProfilePacket_ProcessHeapSamples>; + + static constexpr FieldMetadata_Pid kPid{}; + void set_pid(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FromStartup = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + ProfilePacket_ProcessHeapSamples>; + + static constexpr FieldMetadata_FromStartup kFromStartup{}; + void set_from_startup(bool value) { + static constexpr uint32_t field_id = FieldMetadata_FromStartup::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_RejectedConcurrent = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + ProfilePacket_ProcessHeapSamples>; + + static constexpr FieldMetadata_RejectedConcurrent kRejectedConcurrent{}; + void set_rejected_concurrent(bool value) { + static constexpr uint32_t field_id = FieldMetadata_RejectedConcurrent::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Disconnected = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + ProfilePacket_ProcessHeapSamples>; + + static constexpr FieldMetadata_Disconnected kDisconnected{}; + void set_disconnected(bool value) { + static constexpr uint32_t field_id = FieldMetadata_Disconnected::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_BufferOverran = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + ProfilePacket_ProcessHeapSamples>; + + static constexpr FieldMetadata_BufferOverran kBufferOverran{}; + void set_buffer_overran(bool value) { + static constexpr uint32_t field_id = FieldMetadata_BufferOverran::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ClientError = + ::protozero::proto_utils::FieldMetadata< + 14, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + ProfilePacket_ProcessHeapSamples_ClientError, + ProfilePacket_ProcessHeapSamples>; + + static constexpr FieldMetadata_ClientError kClientError{}; + void set_client_error(ProfilePacket_ProcessHeapSamples_ClientError value) { + static constexpr uint32_t field_id = FieldMetadata_ClientError::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_BufferCorrupted = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + ProfilePacket_ProcessHeapSamples>; + + static constexpr FieldMetadata_BufferCorrupted kBufferCorrupted{}; + void set_buffer_corrupted(bool value) { + static constexpr uint32_t field_id = FieldMetadata_BufferCorrupted::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_HitGuardrail = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + ProfilePacket_ProcessHeapSamples>; + + static constexpr FieldMetadata_HitGuardrail kHitGuardrail{}; + void set_hit_guardrail(bool value) { + static constexpr uint32_t field_id = FieldMetadata_HitGuardrail::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_HeapName = + ::protozero::proto_utils::FieldMetadata< + 11, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + ProfilePacket_ProcessHeapSamples>; + + static constexpr FieldMetadata_HeapName kHeapName{}; + void set_heap_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_HeapName::kFieldId, data, size); + } + void set_heap_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_HeapName::kFieldId, chars.data, chars.size); + } + void set_heap_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_HeapName::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SamplingIntervalBytes = + ::protozero::proto_utils::FieldMetadata< + 12, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + ProfilePacket_ProcessHeapSamples>; + + static constexpr FieldMetadata_SamplingIntervalBytes kSamplingIntervalBytes{}; + void set_sampling_interval_bytes(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_SamplingIntervalBytes::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_OrigSamplingIntervalBytes = + ::protozero::proto_utils::FieldMetadata< + 13, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + ProfilePacket_ProcessHeapSamples>; + + static constexpr FieldMetadata_OrigSamplingIntervalBytes kOrigSamplingIntervalBytes{}; + void set_orig_sampling_interval_bytes(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_OrigSamplingIntervalBytes::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Timestamp = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + ProfilePacket_ProcessHeapSamples>; + + static constexpr FieldMetadata_Timestamp kTimestamp{}; + void set_timestamp(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Timestamp::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Stats = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ProfilePacket_ProcessStats, + ProfilePacket_ProcessHeapSamples>; + + static constexpr FieldMetadata_Stats kStats{}; + template T* set_stats() { + return BeginNestedMessage(5); + } + + + using FieldMetadata_Samples = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ProfilePacket_HeapSample, + ProfilePacket_ProcessHeapSamples>; + + static constexpr FieldMetadata_Samples kSamples{}; + template T* add_samples() { + return BeginNestedMessage(2); + } + +}; + +class ProfilePacket_ProcessStats_Decoder : public ::protozero::TypedProtoDecoder { + public: + ProfilePacket_ProcessStats_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ProfilePacket_ProcessStats_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ProfilePacket_ProcessStats_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_unwinding_errors() const { return at<1>().valid(); } + uint64_t unwinding_errors() const { return at<1>().as_uint64(); } + bool has_heap_samples() const { return at<2>().valid(); } + uint64_t heap_samples() const { return at<2>().as_uint64(); } + bool has_map_reparses() const { return at<3>().valid(); } + uint64_t map_reparses() const { return at<3>().as_uint64(); } + bool has_unwinding_time_us() const { return at<4>().valid(); } + ::protozero::ConstBytes unwinding_time_us() const { return at<4>().as_bytes(); } + bool has_total_unwinding_time_us() const { return at<5>().valid(); } + uint64_t total_unwinding_time_us() const { return at<5>().as_uint64(); } + bool has_client_spinlock_blocked_us() const { return at<6>().valid(); } + uint64_t client_spinlock_blocked_us() const { return at<6>().as_uint64(); } +}; + +class ProfilePacket_ProcessStats : public ::protozero::Message { + public: + using Decoder = ProfilePacket_ProcessStats_Decoder; + enum : int32_t { + kUnwindingErrorsFieldNumber = 1, + kHeapSamplesFieldNumber = 2, + kMapReparsesFieldNumber = 3, + kUnwindingTimeUsFieldNumber = 4, + kTotalUnwindingTimeUsFieldNumber = 5, + kClientSpinlockBlockedUsFieldNumber = 6, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ProfilePacket.ProcessStats"; } + + + using FieldMetadata_UnwindingErrors = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + ProfilePacket_ProcessStats>; + + static constexpr FieldMetadata_UnwindingErrors kUnwindingErrors{}; + void set_unwinding_errors(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_UnwindingErrors::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_HeapSamples = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + ProfilePacket_ProcessStats>; + + static constexpr FieldMetadata_HeapSamples kHeapSamples{}; + void set_heap_samples(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_HeapSamples::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_MapReparses = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + ProfilePacket_ProcessStats>; + + static constexpr FieldMetadata_MapReparses kMapReparses{}; + void set_map_reparses(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_MapReparses::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_UnwindingTimeUs = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ProfilePacket_Histogram, + ProfilePacket_ProcessStats>; + + static constexpr FieldMetadata_UnwindingTimeUs kUnwindingTimeUs{}; + template T* set_unwinding_time_us() { + return BeginNestedMessage(4); + } + + + using FieldMetadata_TotalUnwindingTimeUs = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + ProfilePacket_ProcessStats>; + + static constexpr FieldMetadata_TotalUnwindingTimeUs kTotalUnwindingTimeUs{}; + void set_total_unwinding_time_us(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_TotalUnwindingTimeUs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ClientSpinlockBlockedUs = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + ProfilePacket_ProcessStats>; + + static constexpr FieldMetadata_ClientSpinlockBlockedUs kClientSpinlockBlockedUs{}; + void set_client_spinlock_blocked_us(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_ClientSpinlockBlockedUs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class ProfilePacket_Histogram_Decoder : public ::protozero::TypedProtoDecoder { + public: + ProfilePacket_Histogram_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ProfilePacket_Histogram_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ProfilePacket_Histogram_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_buckets() const { return at<1>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> buckets() const { return GetRepeated<::protozero::ConstBytes>(1); } +}; + +class ProfilePacket_Histogram : public ::protozero::Message { + public: + using Decoder = ProfilePacket_Histogram_Decoder; + enum : int32_t { + kBucketsFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ProfilePacket.Histogram"; } + + using Bucket = ::perfetto::protos::pbzero::ProfilePacket_Histogram_Bucket; + + using FieldMetadata_Buckets = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ProfilePacket_Histogram_Bucket, + ProfilePacket_Histogram>; + + static constexpr FieldMetadata_Buckets kBuckets{}; + template T* add_buckets() { + return BeginNestedMessage(1); + } + +}; + +class ProfilePacket_Histogram_Bucket_Decoder : public ::protozero::TypedProtoDecoder { + public: + ProfilePacket_Histogram_Bucket_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ProfilePacket_Histogram_Bucket_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ProfilePacket_Histogram_Bucket_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_upper_limit() const { return at<1>().valid(); } + uint64_t upper_limit() const { return at<1>().as_uint64(); } + bool has_max_bucket() const { return at<2>().valid(); } + bool max_bucket() const { return at<2>().as_bool(); } + bool has_count() const { return at<3>().valid(); } + uint64_t count() const { return at<3>().as_uint64(); } +}; + +class ProfilePacket_Histogram_Bucket : public ::protozero::Message { + public: + using Decoder = ProfilePacket_Histogram_Bucket_Decoder; + enum : int32_t { + kUpperLimitFieldNumber = 1, + kMaxBucketFieldNumber = 2, + kCountFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ProfilePacket.Histogram.Bucket"; } + + + using FieldMetadata_UpperLimit = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + ProfilePacket_Histogram_Bucket>; + + static constexpr FieldMetadata_UpperLimit kUpperLimit{}; + void set_upper_limit(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_UpperLimit::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_MaxBucket = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + ProfilePacket_Histogram_Bucket>; + + static constexpr FieldMetadata_MaxBucket kMaxBucket{}; + void set_max_bucket(bool value) { + static constexpr uint32_t field_id = FieldMetadata_MaxBucket::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Count = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + ProfilePacket_Histogram_Bucket>; + + static constexpr FieldMetadata_Count kCount{}; + void set_count(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Count::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class ProfilePacket_HeapSample_Decoder : public ::protozero::TypedProtoDecoder { + public: + ProfilePacket_HeapSample_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ProfilePacket_HeapSample_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ProfilePacket_HeapSample_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_callstack_id() const { return at<1>().valid(); } + uint64_t callstack_id() const { return at<1>().as_uint64(); } + bool has_self_allocated() const { return at<2>().valid(); } + uint64_t self_allocated() const { return at<2>().as_uint64(); } + bool has_self_freed() const { return at<3>().valid(); } + uint64_t self_freed() const { return at<3>().as_uint64(); } + bool has_self_max() const { return at<8>().valid(); } + uint64_t self_max() const { return at<8>().as_uint64(); } + bool has_self_max_count() const { return at<9>().valid(); } + uint64_t self_max_count() const { return at<9>().as_uint64(); } + bool has_timestamp() const { return at<4>().valid(); } + uint64_t timestamp() const { return at<4>().as_uint64(); } + bool has_alloc_count() const { return at<5>().valid(); } + uint64_t alloc_count() const { return at<5>().as_uint64(); } + bool has_free_count() const { return at<6>().valid(); } + uint64_t free_count() const { return at<6>().as_uint64(); } +}; + +class ProfilePacket_HeapSample : public ::protozero::Message { + public: + using Decoder = ProfilePacket_HeapSample_Decoder; + enum : int32_t { + kCallstackIdFieldNumber = 1, + kSelfAllocatedFieldNumber = 2, + kSelfFreedFieldNumber = 3, + kSelfMaxFieldNumber = 8, + kSelfMaxCountFieldNumber = 9, + kTimestampFieldNumber = 4, + kAllocCountFieldNumber = 5, + kFreeCountFieldNumber = 6, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ProfilePacket.HeapSample"; } + + + using FieldMetadata_CallstackId = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + ProfilePacket_HeapSample>; + + static constexpr FieldMetadata_CallstackId kCallstackId{}; + void set_callstack_id(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_CallstackId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SelfAllocated = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + ProfilePacket_HeapSample>; + + static constexpr FieldMetadata_SelfAllocated kSelfAllocated{}; + void set_self_allocated(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_SelfAllocated::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SelfFreed = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + ProfilePacket_HeapSample>; + + static constexpr FieldMetadata_SelfFreed kSelfFreed{}; + void set_self_freed(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_SelfFreed::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SelfMax = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + ProfilePacket_HeapSample>; + + static constexpr FieldMetadata_SelfMax kSelfMax{}; + void set_self_max(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_SelfMax::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SelfMaxCount = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + ProfilePacket_HeapSample>; + + static constexpr FieldMetadata_SelfMaxCount kSelfMaxCount{}; + void set_self_max_count(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_SelfMaxCount::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Timestamp = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + ProfilePacket_HeapSample>; + + static constexpr FieldMetadata_Timestamp kTimestamp{}; + void set_timestamp(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Timestamp::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_AllocCount = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + ProfilePacket_HeapSample>; + + static constexpr FieldMetadata_AllocCount kAllocCount{}; + void set_alloc_count(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_AllocCount::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FreeCount = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + ProfilePacket_HeapSample>; + + static constexpr FieldMetadata_FreeCount kFreeCount{}; + void set_free_count(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_FreeCount::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class HeapGraph_Decoder : public ::protozero::TypedProtoDecoder { + public: + HeapGraph_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit HeapGraph_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit HeapGraph_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_pid() const { return at<1>().valid(); } + int32_t pid() const { return at<1>().as_int32(); } + bool has_objects() const { return at<2>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> objects() const { return GetRepeated<::protozero::ConstBytes>(2); } + bool has_roots() const { return at<7>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> roots() const { return GetRepeated<::protozero::ConstBytes>(7); } + bool has_types() const { return at<9>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> types() const { return GetRepeated<::protozero::ConstBytes>(9); } + bool has_field_names() const { return at<4>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> field_names() const { return GetRepeated<::protozero::ConstBytes>(4); } + bool has_location_names() const { return at<8>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> location_names() const { return GetRepeated<::protozero::ConstBytes>(8); } + bool has_continued() const { return at<5>().valid(); } + bool continued() const { return at<5>().as_bool(); } + bool has_index() const { return at<6>().valid(); } + uint64_t index() const { return at<6>().as_uint64(); } +}; + +class HeapGraph : public ::protozero::Message { + public: + using Decoder = HeapGraph_Decoder; + enum : int32_t { + kPidFieldNumber = 1, + kObjectsFieldNumber = 2, + kRootsFieldNumber = 7, + kTypesFieldNumber = 9, + kFieldNamesFieldNumber = 4, + kLocationNamesFieldNumber = 8, + kContinuedFieldNumber = 5, + kIndexFieldNumber = 6, + }; + static constexpr const char* GetName() { return ".perfetto.protos.HeapGraph"; } + + + using FieldMetadata_Pid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + HeapGraph>; + + static constexpr FieldMetadata_Pid kPid{}; + void set_pid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Objects = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + HeapGraphObject, + HeapGraph>; + + static constexpr FieldMetadata_Objects kObjects{}; + template T* add_objects() { + return BeginNestedMessage(2); + } + + + using FieldMetadata_Roots = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + HeapGraphRoot, + HeapGraph>; + + static constexpr FieldMetadata_Roots kRoots{}; + template T* add_roots() { + return BeginNestedMessage(7); + } + + + using FieldMetadata_Types = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + HeapGraphType, + HeapGraph>; + + static constexpr FieldMetadata_Types kTypes{}; + template T* add_types() { + return BeginNestedMessage(9); + } + + + using FieldMetadata_FieldNames = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + InternedString, + HeapGraph>; + + static constexpr FieldMetadata_FieldNames kFieldNames{}; + template T* add_field_names() { + return BeginNestedMessage(4); + } + + + using FieldMetadata_LocationNames = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + InternedString, + HeapGraph>; + + static constexpr FieldMetadata_LocationNames kLocationNames{}; + template T* add_location_names() { + return BeginNestedMessage(8); + } + + + using FieldMetadata_Continued = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + HeapGraph>; + + static constexpr FieldMetadata_Continued kContinued{}; + void set_continued(bool value) { + static constexpr uint32_t field_id = FieldMetadata_Continued::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Index = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + HeapGraph>; + + static constexpr FieldMetadata_Index kIndex{}; + void set_index(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Index::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class HeapGraphObject_Decoder : public ::protozero::TypedProtoDecoder { + public: + HeapGraphObject_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit HeapGraphObject_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit HeapGraphObject_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_id() const { return at<1>().valid(); } + uint64_t id() const { return at<1>().as_uint64(); } + bool has_id_delta() const { return at<7>().valid(); } + uint64_t id_delta() const { return at<7>().as_uint64(); } + bool has_type_id() const { return at<2>().valid(); } + uint64_t type_id() const { return at<2>().as_uint64(); } + bool has_self_size() const { return at<3>().valid(); } + uint64_t self_size() const { return at<3>().as_uint64(); } + bool has_reference_field_id_base() const { return at<6>().valid(); } + uint64_t reference_field_id_base() const { return at<6>().as_uint64(); } + bool has_reference_field_id() const { return at<4>().valid(); } + ::protozero::PackedRepeatedFieldIterator<::protozero::proto_utils::ProtoWireType::kVarInt, uint64_t> reference_field_id(bool* parse_error_ptr) const { return GetPackedRepeated<::protozero::proto_utils::ProtoWireType::kVarInt, uint64_t>(4, parse_error_ptr); } + bool has_reference_object_id() const { return at<5>().valid(); } + ::protozero::PackedRepeatedFieldIterator<::protozero::proto_utils::ProtoWireType::kVarInt, uint64_t> reference_object_id(bool* parse_error_ptr) const { return GetPackedRepeated<::protozero::proto_utils::ProtoWireType::kVarInt, uint64_t>(5, parse_error_ptr); } + bool has_native_allocation_registry_size_field() const { return at<8>().valid(); } + int64_t native_allocation_registry_size_field() const { return at<8>().as_int64(); } +}; + +class HeapGraphObject : public ::protozero::Message { + public: + using Decoder = HeapGraphObject_Decoder; + enum : int32_t { + kIdFieldNumber = 1, + kIdDeltaFieldNumber = 7, + kTypeIdFieldNumber = 2, + kSelfSizeFieldNumber = 3, + kReferenceFieldIdBaseFieldNumber = 6, + kReferenceFieldIdFieldNumber = 4, + kReferenceObjectIdFieldNumber = 5, + kNativeAllocationRegistrySizeFieldFieldNumber = 8, + }; + static constexpr const char* GetName() { return ".perfetto.protos.HeapGraphObject"; } + + + using FieldMetadata_Id = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + HeapGraphObject>; + + static constexpr FieldMetadata_Id kId{}; + void set_id(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_IdDelta = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + HeapGraphObject>; + + static constexpr FieldMetadata_IdDelta kIdDelta{}; + void set_id_delta(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_IdDelta::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TypeId = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + HeapGraphObject>; + + static constexpr FieldMetadata_TypeId kTypeId{}; + void set_type_id(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_TypeId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SelfSize = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + HeapGraphObject>; + + static constexpr FieldMetadata_SelfSize kSelfSize{}; + void set_self_size(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_SelfSize::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ReferenceFieldIdBase = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + HeapGraphObject>; + + static constexpr FieldMetadata_ReferenceFieldIdBase kReferenceFieldIdBase{}; + void set_reference_field_id_base(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_ReferenceFieldIdBase::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ReferenceFieldId = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kRepeatedPacked, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + HeapGraphObject>; + + static constexpr FieldMetadata_ReferenceFieldId kReferenceFieldId{}; + void set_reference_field_id(const ::protozero::PackedVarInt& packed_buffer) { + AppendBytes(FieldMetadata_ReferenceFieldId::kFieldId, packed_buffer.data(), + packed_buffer.size()); + } + + using FieldMetadata_ReferenceObjectId = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kRepeatedPacked, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + HeapGraphObject>; + + static constexpr FieldMetadata_ReferenceObjectId kReferenceObjectId{}; + void set_reference_object_id(const ::protozero::PackedVarInt& packed_buffer) { + AppendBytes(FieldMetadata_ReferenceObjectId::kFieldId, packed_buffer.data(), + packed_buffer.size()); + } + + using FieldMetadata_NativeAllocationRegistrySizeField = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + HeapGraphObject>; + + static constexpr FieldMetadata_NativeAllocationRegistrySizeField kNativeAllocationRegistrySizeField{}; + void set_native_allocation_registry_size_field(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_NativeAllocationRegistrySizeField::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } +}; + +class HeapGraphType_Decoder : public ::protozero::TypedProtoDecoder { + public: + HeapGraphType_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit HeapGraphType_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit HeapGraphType_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_id() const { return at<1>().valid(); } + uint64_t id() const { return at<1>().as_uint64(); } + bool has_location_id() const { return at<2>().valid(); } + uint64_t location_id() const { return at<2>().as_uint64(); } + bool has_class_name() const { return at<3>().valid(); } + ::protozero::ConstChars class_name() const { return at<3>().as_string(); } + bool has_object_size() const { return at<4>().valid(); } + uint64_t object_size() const { return at<4>().as_uint64(); } + bool has_superclass_id() const { return at<5>().valid(); } + uint64_t superclass_id() const { return at<5>().as_uint64(); } + bool has_reference_field_id() const { return at<6>().valid(); } + ::protozero::PackedRepeatedFieldIterator<::protozero::proto_utils::ProtoWireType::kVarInt, uint64_t> reference_field_id(bool* parse_error_ptr) const { return GetPackedRepeated<::protozero::proto_utils::ProtoWireType::kVarInt, uint64_t>(6, parse_error_ptr); } + bool has_kind() const { return at<7>().valid(); } + int32_t kind() const { return at<7>().as_int32(); } + bool has_classloader_id() const { return at<8>().valid(); } + uint64_t classloader_id() const { return at<8>().as_uint64(); } +}; + +class HeapGraphType : public ::protozero::Message { + public: + using Decoder = HeapGraphType_Decoder; + enum : int32_t { + kIdFieldNumber = 1, + kLocationIdFieldNumber = 2, + kClassNameFieldNumber = 3, + kObjectSizeFieldNumber = 4, + kSuperclassIdFieldNumber = 5, + kReferenceFieldIdFieldNumber = 6, + kKindFieldNumber = 7, + kClassloaderIdFieldNumber = 8, + }; + static constexpr const char* GetName() { return ".perfetto.protos.HeapGraphType"; } + + + using Kind = ::perfetto::protos::pbzero::HeapGraphType_Kind; + static inline const char* Kind_Name(Kind value) { + return ::perfetto::protos::pbzero::HeapGraphType_Kind_Name(value); + } + static inline const Kind KIND_UNKNOWN = Kind::KIND_UNKNOWN; + static inline const Kind KIND_NORMAL = Kind::KIND_NORMAL; + static inline const Kind KIND_NOREFERENCES = Kind::KIND_NOREFERENCES; + static inline const Kind KIND_STRING = Kind::KIND_STRING; + static inline const Kind KIND_ARRAY = Kind::KIND_ARRAY; + static inline const Kind KIND_CLASS = Kind::KIND_CLASS; + static inline const Kind KIND_CLASSLOADER = Kind::KIND_CLASSLOADER; + static inline const Kind KIND_DEXCACHE = Kind::KIND_DEXCACHE; + static inline const Kind KIND_SOFT_REFERENCE = Kind::KIND_SOFT_REFERENCE; + static inline const Kind KIND_WEAK_REFERENCE = Kind::KIND_WEAK_REFERENCE; + static inline const Kind KIND_FINALIZER_REFERENCE = Kind::KIND_FINALIZER_REFERENCE; + static inline const Kind KIND_PHANTOM_REFERENCE = Kind::KIND_PHANTOM_REFERENCE; + + using FieldMetadata_Id = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + HeapGraphType>; + + static constexpr FieldMetadata_Id kId{}; + void set_id(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_LocationId = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + HeapGraphType>; + + static constexpr FieldMetadata_LocationId kLocationId{}; + void set_location_id(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_LocationId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ClassName = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + HeapGraphType>; + + static constexpr FieldMetadata_ClassName kClassName{}; + void set_class_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_ClassName::kFieldId, data, size); + } + void set_class_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_ClassName::kFieldId, chars.data, chars.size); + } + void set_class_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_ClassName::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ObjectSize = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + HeapGraphType>; + + static constexpr FieldMetadata_ObjectSize kObjectSize{}; + void set_object_size(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_ObjectSize::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SuperclassId = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + HeapGraphType>; + + static constexpr FieldMetadata_SuperclassId kSuperclassId{}; + void set_superclass_id(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_SuperclassId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ReferenceFieldId = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kRepeatedPacked, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + HeapGraphType>; + + static constexpr FieldMetadata_ReferenceFieldId kReferenceFieldId{}; + void set_reference_field_id(const ::protozero::PackedVarInt& packed_buffer) { + AppendBytes(FieldMetadata_ReferenceFieldId::kFieldId, packed_buffer.data(), + packed_buffer.size()); + } + + using FieldMetadata_Kind = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + HeapGraphType_Kind, + HeapGraphType>; + + static constexpr FieldMetadata_Kind kKind{}; + void set_kind(HeapGraphType_Kind value) { + static constexpr uint32_t field_id = FieldMetadata_Kind::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ClassloaderId = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + HeapGraphType>; + + static constexpr FieldMetadata_ClassloaderId kClassloaderId{}; + void set_classloader_id(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_ClassloaderId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class HeapGraphRoot_Decoder : public ::protozero::TypedProtoDecoder { + public: + HeapGraphRoot_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit HeapGraphRoot_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit HeapGraphRoot_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_object_ids() const { return at<1>().valid(); } + ::protozero::PackedRepeatedFieldIterator<::protozero::proto_utils::ProtoWireType::kVarInt, uint64_t> object_ids(bool* parse_error_ptr) const { return GetPackedRepeated<::protozero::proto_utils::ProtoWireType::kVarInt, uint64_t>(1, parse_error_ptr); } + bool has_root_type() const { return at<2>().valid(); } + int32_t root_type() const { return at<2>().as_int32(); } +}; + +class HeapGraphRoot : public ::protozero::Message { + public: + using Decoder = HeapGraphRoot_Decoder; + enum : int32_t { + kObjectIdsFieldNumber = 1, + kRootTypeFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.HeapGraphRoot"; } + + + using Type = ::perfetto::protos::pbzero::HeapGraphRoot_Type; + static inline const char* Type_Name(Type value) { + return ::perfetto::protos::pbzero::HeapGraphRoot_Type_Name(value); + } + static inline const Type ROOT_UNKNOWN = Type::ROOT_UNKNOWN; + static inline const Type ROOT_JNI_GLOBAL = Type::ROOT_JNI_GLOBAL; + static inline const Type ROOT_JNI_LOCAL = Type::ROOT_JNI_LOCAL; + static inline const Type ROOT_JAVA_FRAME = Type::ROOT_JAVA_FRAME; + static inline const Type ROOT_NATIVE_STACK = Type::ROOT_NATIVE_STACK; + static inline const Type ROOT_STICKY_CLASS = Type::ROOT_STICKY_CLASS; + static inline const Type ROOT_THREAD_BLOCK = Type::ROOT_THREAD_BLOCK; + static inline const Type ROOT_MONITOR_USED = Type::ROOT_MONITOR_USED; + static inline const Type ROOT_THREAD_OBJECT = Type::ROOT_THREAD_OBJECT; + static inline const Type ROOT_INTERNED_STRING = Type::ROOT_INTERNED_STRING; + static inline const Type ROOT_FINALIZING = Type::ROOT_FINALIZING; + static inline const Type ROOT_DEBUGGER = Type::ROOT_DEBUGGER; + static inline const Type ROOT_REFERENCE_CLEANUP = Type::ROOT_REFERENCE_CLEANUP; + static inline const Type ROOT_VM_INTERNAL = Type::ROOT_VM_INTERNAL; + static inline const Type ROOT_JNI_MONITOR = Type::ROOT_JNI_MONITOR; + + using FieldMetadata_ObjectIds = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kRepeatedPacked, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + HeapGraphRoot>; + + static constexpr FieldMetadata_ObjectIds kObjectIds{}; + void set_object_ids(const ::protozero::PackedVarInt& packed_buffer) { + AppendBytes(FieldMetadata_ObjectIds::kFieldId, packed_buffer.data(), + packed_buffer.size()); + } + + using FieldMetadata_RootType = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + HeapGraphRoot_Type, + HeapGraphRoot>; + + static constexpr FieldMetadata_RootType kRootType{}; + void set_root_type(HeapGraphRoot_Type value) { + static constexpr uint32_t field_id = FieldMetadata_RootType::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } +}; + +class DeobfuscationMapping_Decoder : public ::protozero::TypedProtoDecoder { + public: + DeobfuscationMapping_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit DeobfuscationMapping_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit DeobfuscationMapping_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_package_name() const { return at<1>().valid(); } + ::protozero::ConstChars package_name() const { return at<1>().as_string(); } + bool has_version_code() const { return at<2>().valid(); } + int64_t version_code() const { return at<2>().as_int64(); } + bool has_obfuscated_classes() const { return at<3>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> obfuscated_classes() const { return GetRepeated<::protozero::ConstBytes>(3); } +}; + +class DeobfuscationMapping : public ::protozero::Message { + public: + using Decoder = DeobfuscationMapping_Decoder; + enum : int32_t { + kPackageNameFieldNumber = 1, + kVersionCodeFieldNumber = 2, + kObfuscatedClassesFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.DeobfuscationMapping"; } + + + using FieldMetadata_PackageName = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + DeobfuscationMapping>; + + static constexpr FieldMetadata_PackageName kPackageName{}; + void set_package_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_PackageName::kFieldId, data, size); + } + void set_package_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_PackageName::kFieldId, chars.data, chars.size); + } + void set_package_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_PackageName::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_VersionCode = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + DeobfuscationMapping>; + + static constexpr FieldMetadata_VersionCode kVersionCode{}; + void set_version_code(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_VersionCode::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ObfuscatedClasses = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ObfuscatedClass, + DeobfuscationMapping>; + + static constexpr FieldMetadata_ObfuscatedClasses kObfuscatedClasses{}; + template T* add_obfuscated_classes() { + return BeginNestedMessage(3); + } + +}; + +class ObfuscatedClass_Decoder : public ::protozero::TypedProtoDecoder { + public: + ObfuscatedClass_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ObfuscatedClass_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ObfuscatedClass_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_obfuscated_name() const { return at<1>().valid(); } + ::protozero::ConstChars obfuscated_name() const { return at<1>().as_string(); } + bool has_deobfuscated_name() const { return at<2>().valid(); } + ::protozero::ConstChars deobfuscated_name() const { return at<2>().as_string(); } + bool has_obfuscated_members() const { return at<3>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> obfuscated_members() const { return GetRepeated<::protozero::ConstBytes>(3); } + bool has_obfuscated_methods() const { return at<4>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> obfuscated_methods() const { return GetRepeated<::protozero::ConstBytes>(4); } +}; + +class ObfuscatedClass : public ::protozero::Message { + public: + using Decoder = ObfuscatedClass_Decoder; + enum : int32_t { + kObfuscatedNameFieldNumber = 1, + kDeobfuscatedNameFieldNumber = 2, + kObfuscatedMembersFieldNumber = 3, + kObfuscatedMethodsFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ObfuscatedClass"; } + + + using FieldMetadata_ObfuscatedName = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + ObfuscatedClass>; + + static constexpr FieldMetadata_ObfuscatedName kObfuscatedName{}; + void set_obfuscated_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_ObfuscatedName::kFieldId, data, size); + } + void set_obfuscated_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_ObfuscatedName::kFieldId, chars.data, chars.size); + } + void set_obfuscated_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_ObfuscatedName::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DeobfuscatedName = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + ObfuscatedClass>; + + static constexpr FieldMetadata_DeobfuscatedName kDeobfuscatedName{}; + void set_deobfuscated_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_DeobfuscatedName::kFieldId, data, size); + } + void set_deobfuscated_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_DeobfuscatedName::kFieldId, chars.data, chars.size); + } + void set_deobfuscated_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_DeobfuscatedName::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ObfuscatedMembers = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ObfuscatedMember, + ObfuscatedClass>; + + static constexpr FieldMetadata_ObfuscatedMembers kObfuscatedMembers{}; + template T* add_obfuscated_members() { + return BeginNestedMessage(3); + } + + + using FieldMetadata_ObfuscatedMethods = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ObfuscatedMember, + ObfuscatedClass>; + + static constexpr FieldMetadata_ObfuscatedMethods kObfuscatedMethods{}; + template T* add_obfuscated_methods() { + return BeginNestedMessage(4); + } + +}; + +class ObfuscatedMember_Decoder : public ::protozero::TypedProtoDecoder { + public: + ObfuscatedMember_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ObfuscatedMember_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ObfuscatedMember_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_obfuscated_name() const { return at<1>().valid(); } + ::protozero::ConstChars obfuscated_name() const { return at<1>().as_string(); } + bool has_deobfuscated_name() const { return at<2>().valid(); } + ::protozero::ConstChars deobfuscated_name() const { return at<2>().as_string(); } +}; + +class ObfuscatedMember : public ::protozero::Message { + public: + using Decoder = ObfuscatedMember_Decoder; + enum : int32_t { + kObfuscatedNameFieldNumber = 1, + kDeobfuscatedNameFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ObfuscatedMember"; } + + + using FieldMetadata_ObfuscatedName = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + ObfuscatedMember>; + + static constexpr FieldMetadata_ObfuscatedName kObfuscatedName{}; + void set_obfuscated_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_ObfuscatedName::kFieldId, data, size); + } + void set_obfuscated_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_ObfuscatedName::kFieldId, chars.data, chars.size); + } + void set_obfuscated_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_ObfuscatedName::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DeobfuscatedName = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + ObfuscatedMember>; + + static constexpr FieldMetadata_DeobfuscatedName kDeobfuscatedName{}; + void set_deobfuscated_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_DeobfuscatedName::kFieldId, data, size); + } + void set_deobfuscated_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_DeobfuscatedName::kFieldId, chars.data, chars.size); + } + void set_deobfuscated_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_DeobfuscatedName::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class PowerRails_Decoder : public ::protozero::TypedProtoDecoder { + public: + PowerRails_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit PowerRails_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit PowerRails_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_rail_descriptor() const { return at<1>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> rail_descriptor() const { return GetRepeated<::protozero::ConstBytes>(1); } + bool has_energy_data() const { return at<2>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> energy_data() const { return GetRepeated<::protozero::ConstBytes>(2); } +}; + +class PowerRails : public ::protozero::Message { + public: + using Decoder = PowerRails_Decoder; + enum : int32_t { + kRailDescriptorFieldNumber = 1, + kEnergyDataFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.PowerRails"; } + + using RailDescriptor = ::perfetto::protos::pbzero::PowerRails_RailDescriptor; + using EnergyData = ::perfetto::protos::pbzero::PowerRails_EnergyData; + + using FieldMetadata_RailDescriptor = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + PowerRails_RailDescriptor, + PowerRails>; + + static constexpr FieldMetadata_RailDescriptor kRailDescriptor{}; + template T* add_rail_descriptor() { + return BeginNestedMessage(1); + } + + + using FieldMetadata_EnergyData = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + PowerRails_EnergyData, + PowerRails>; + + static constexpr FieldMetadata_EnergyData kEnergyData{}; + template T* add_energy_data() { + return BeginNestedMessage(2); + } + +}; + +class PowerRails_EnergyData_Decoder : public ::protozero::TypedProtoDecoder { + public: + PowerRails_EnergyData_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit PowerRails_EnergyData_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit PowerRails_EnergyData_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_index() const { return at<1>().valid(); } + uint32_t index() const { return at<1>().as_uint32(); } + bool has_timestamp_ms() const { return at<2>().valid(); } + uint64_t timestamp_ms() const { return at<2>().as_uint64(); } + bool has_energy() const { return at<3>().valid(); } + uint64_t energy() const { return at<3>().as_uint64(); } +}; + +class PowerRails_EnergyData : public ::protozero::Message { + public: + using Decoder = PowerRails_EnergyData_Decoder; + enum : int32_t { + kIndexFieldNumber = 1, + kTimestampMsFieldNumber = 2, + kEnergyFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.PowerRails.EnergyData"; } + + + using FieldMetadata_Index = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + PowerRails_EnergyData>; + + static constexpr FieldMetadata_Index kIndex{}; + void set_index(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Index::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TimestampMs = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + PowerRails_EnergyData>; + + static constexpr FieldMetadata_TimestampMs kTimestampMs{}; + void set_timestamp_ms(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_TimestampMs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Energy = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + PowerRails_EnergyData>; + + static constexpr FieldMetadata_Energy kEnergy{}; + void set_energy(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Energy::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class PowerRails_RailDescriptor_Decoder : public ::protozero::TypedProtoDecoder { + public: + PowerRails_RailDescriptor_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit PowerRails_RailDescriptor_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit PowerRails_RailDescriptor_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_index() const { return at<1>().valid(); } + uint32_t index() const { return at<1>().as_uint32(); } + bool has_rail_name() const { return at<2>().valid(); } + ::protozero::ConstChars rail_name() const { return at<2>().as_string(); } + bool has_subsys_name() const { return at<3>().valid(); } + ::protozero::ConstChars subsys_name() const { return at<3>().as_string(); } + bool has_sampling_rate() const { return at<4>().valid(); } + uint32_t sampling_rate() const { return at<4>().as_uint32(); } +}; + +class PowerRails_RailDescriptor : public ::protozero::Message { + public: + using Decoder = PowerRails_RailDescriptor_Decoder; + enum : int32_t { + kIndexFieldNumber = 1, + kRailNameFieldNumber = 2, + kSubsysNameFieldNumber = 3, + kSamplingRateFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.PowerRails.RailDescriptor"; } + + + using FieldMetadata_Index = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + PowerRails_RailDescriptor>; + + static constexpr FieldMetadata_Index kIndex{}; + void set_index(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Index::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_RailName = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + PowerRails_RailDescriptor>; + + static constexpr FieldMetadata_RailName kRailName{}; + void set_rail_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_RailName::kFieldId, data, size); + } + void set_rail_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_RailName::kFieldId, chars.data, chars.size); + } + void set_rail_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_RailName::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SubsysName = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + PowerRails_RailDescriptor>; + + static constexpr FieldMetadata_SubsysName kSubsysName{}; + void set_subsys_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_SubsysName::kFieldId, data, size); + } + void set_subsys_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_SubsysName::kFieldId, chars.data, chars.size); + } + void set_subsys_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_SubsysName::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SamplingRate = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + PowerRails_RailDescriptor>; + + static constexpr FieldMetadata_SamplingRate kSamplingRate{}; + void set_sampling_rate(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_SamplingRate::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class BatteryCounters_Decoder : public ::protozero::TypedProtoDecoder { + public: + BatteryCounters_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit BatteryCounters_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit BatteryCounters_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_charge_counter_uah() const { return at<1>().valid(); } + int64_t charge_counter_uah() const { return at<1>().as_int64(); } + bool has_capacity_percent() const { return at<2>().valid(); } + float capacity_percent() const { return at<2>().as_float(); } + bool has_current_ua() const { return at<3>().valid(); } + int64_t current_ua() const { return at<3>().as_int64(); } + bool has_current_avg_ua() const { return at<4>().valid(); } + int64_t current_avg_ua() const { return at<4>().as_int64(); } + bool has_name() const { return at<5>().valid(); } + ::protozero::ConstChars name() const { return at<5>().as_string(); } + bool has_energy_counter_uwh() const { return at<6>().valid(); } + int64_t energy_counter_uwh() const { return at<6>().as_int64(); } + bool has_voltage_uv() const { return at<7>().valid(); } + int64_t voltage_uv() const { return at<7>().as_int64(); } +}; + +class BatteryCounters : public ::protozero::Message { + public: + using Decoder = BatteryCounters_Decoder; + enum : int32_t { + kChargeCounterUahFieldNumber = 1, + kCapacityPercentFieldNumber = 2, + kCurrentUaFieldNumber = 3, + kCurrentAvgUaFieldNumber = 4, + kNameFieldNumber = 5, + kEnergyCounterUwhFieldNumber = 6, + kVoltageUvFieldNumber = 7, + }; + static constexpr const char* GetName() { return ".perfetto.protos.BatteryCounters"; } + + + using FieldMetadata_ChargeCounterUah = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + BatteryCounters>; + + static constexpr FieldMetadata_ChargeCounterUah kChargeCounterUah{}; + void set_charge_counter_uah(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_ChargeCounterUah::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CapacityPercent = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + BatteryCounters>; + + static constexpr FieldMetadata_CapacityPercent kCapacityPercent{}; + void set_capacity_percent(float value) { + static constexpr uint32_t field_id = FieldMetadata_CapacityPercent::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CurrentUa = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + BatteryCounters>; + + static constexpr FieldMetadata_CurrentUa kCurrentUa{}; + void set_current_ua(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_CurrentUa::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CurrentAvgUa = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + BatteryCounters>; + + static constexpr FieldMetadata_CurrentAvgUa kCurrentAvgUa{}; + void set_current_avg_ua(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_CurrentAvgUa::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + BatteryCounters>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_EnergyCounterUwh = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + BatteryCounters>; + + static constexpr FieldMetadata_EnergyCounterUwh kEnergyCounterUwh{}; + void set_energy_counter_uwh(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_EnergyCounterUwh::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_VoltageUv = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + BatteryCounters>; + + static constexpr FieldMetadata_VoltageUv kVoltageUv{}; + void set_voltage_uv(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_VoltageUv::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } +}; + +class EntityStateResidency_Decoder : public ::protozero::TypedProtoDecoder { + public: + EntityStateResidency_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit EntityStateResidency_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit EntityStateResidency_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_power_entity_state() const { return at<1>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> power_entity_state() const { return GetRepeated<::protozero::ConstBytes>(1); } + bool has_residency() const { return at<2>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> residency() const { return GetRepeated<::protozero::ConstBytes>(2); } +}; + +class EntityStateResidency : public ::protozero::Message { + public: + using Decoder = EntityStateResidency_Decoder; + enum : int32_t { + kPowerEntityStateFieldNumber = 1, + kResidencyFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.EntityStateResidency"; } + + using PowerEntityState = ::perfetto::protos::pbzero::EntityStateResidency_PowerEntityState; + using StateResidency = ::perfetto::protos::pbzero::EntityStateResidency_StateResidency; + + using FieldMetadata_PowerEntityState = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + EntityStateResidency_PowerEntityState, + EntityStateResidency>; + + static constexpr FieldMetadata_PowerEntityState kPowerEntityState{}; + template T* add_power_entity_state() { + return BeginNestedMessage(1); + } + + + using FieldMetadata_Residency = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + EntityStateResidency_StateResidency, + EntityStateResidency>; + + static constexpr FieldMetadata_Residency kResidency{}; + template T* add_residency() { + return BeginNestedMessage(2); + } + +}; + +class EntityStateResidency_StateResidency_Decoder : public ::protozero::TypedProtoDecoder { + public: + EntityStateResidency_StateResidency_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit EntityStateResidency_StateResidency_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit EntityStateResidency_StateResidency_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_entity_index() const { return at<1>().valid(); } + int32_t entity_index() const { return at<1>().as_int32(); } + bool has_state_index() const { return at<2>().valid(); } + int32_t state_index() const { return at<2>().as_int32(); } + bool has_total_time_in_state_ms() const { return at<3>().valid(); } + uint64_t total_time_in_state_ms() const { return at<3>().as_uint64(); } + bool has_total_state_entry_count() const { return at<4>().valid(); } + uint64_t total_state_entry_count() const { return at<4>().as_uint64(); } + bool has_last_entry_timestamp_ms() const { return at<5>().valid(); } + uint64_t last_entry_timestamp_ms() const { return at<5>().as_uint64(); } +}; + +class EntityStateResidency_StateResidency : public ::protozero::Message { + public: + using Decoder = EntityStateResidency_StateResidency_Decoder; + enum : int32_t { + kEntityIndexFieldNumber = 1, + kStateIndexFieldNumber = 2, + kTotalTimeInStateMsFieldNumber = 3, + kTotalStateEntryCountFieldNumber = 4, + kLastEntryTimestampMsFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.EntityStateResidency.StateResidency"; } + + + using FieldMetadata_EntityIndex = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + EntityStateResidency_StateResidency>; + + static constexpr FieldMetadata_EntityIndex kEntityIndex{}; + void set_entity_index(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_EntityIndex::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_StateIndex = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + EntityStateResidency_StateResidency>; + + static constexpr FieldMetadata_StateIndex kStateIndex{}; + void set_state_index(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_StateIndex::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TotalTimeInStateMs = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + EntityStateResidency_StateResidency>; + + static constexpr FieldMetadata_TotalTimeInStateMs kTotalTimeInStateMs{}; + void set_total_time_in_state_ms(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_TotalTimeInStateMs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TotalStateEntryCount = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + EntityStateResidency_StateResidency>; + + static constexpr FieldMetadata_TotalStateEntryCount kTotalStateEntryCount{}; + void set_total_state_entry_count(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_TotalStateEntryCount::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_LastEntryTimestampMs = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + EntityStateResidency_StateResidency>; + + static constexpr FieldMetadata_LastEntryTimestampMs kLastEntryTimestampMs{}; + void set_last_entry_timestamp_ms(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_LastEntryTimestampMs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class EntityStateResidency_PowerEntityState_Decoder : public ::protozero::TypedProtoDecoder { + public: + EntityStateResidency_PowerEntityState_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit EntityStateResidency_PowerEntityState_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit EntityStateResidency_PowerEntityState_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_entity_index() const { return at<1>().valid(); } + int32_t entity_index() const { return at<1>().as_int32(); } + bool has_state_index() const { return at<2>().valid(); } + int32_t state_index() const { return at<2>().as_int32(); } + bool has_entity_name() const { return at<3>().valid(); } + ::protozero::ConstChars entity_name() const { return at<3>().as_string(); } + bool has_state_name() const { return at<4>().valid(); } + ::protozero::ConstChars state_name() const { return at<4>().as_string(); } +}; + +class EntityStateResidency_PowerEntityState : public ::protozero::Message { + public: + using Decoder = EntityStateResidency_PowerEntityState_Decoder; + enum : int32_t { + kEntityIndexFieldNumber = 1, + kStateIndexFieldNumber = 2, + kEntityNameFieldNumber = 3, + kStateNameFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.EntityStateResidency.PowerEntityState"; } + + + using FieldMetadata_EntityIndex = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + EntityStateResidency_PowerEntityState>; + + static constexpr FieldMetadata_EntityIndex kEntityIndex{}; + void set_entity_index(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_EntityIndex::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_StateIndex = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + EntityStateResidency_PowerEntityState>; + + static constexpr FieldMetadata_StateIndex kStateIndex{}; + void set_state_index(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_StateIndex::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_EntityName = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + EntityStateResidency_PowerEntityState>; + + static constexpr FieldMetadata_EntityName kEntityName{}; + void set_entity_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_EntityName::kFieldId, data, size); + } + void set_entity_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_EntityName::kFieldId, chars.data, chars.size); + } + void set_entity_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_EntityName::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_StateName = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + EntityStateResidency_PowerEntityState>; + + static constexpr FieldMetadata_StateName kStateName{}; + void set_state_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_StateName::kFieldId, data, size); + } + void set_state_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_StateName::kFieldId, chars.data, chars.size); + } + void set_state_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_StateName::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class AndroidEnergyEstimationBreakdown_Decoder : public ::protozero::TypedProtoDecoder { + public: + AndroidEnergyEstimationBreakdown_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit AndroidEnergyEstimationBreakdown_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit AndroidEnergyEstimationBreakdown_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_energy_consumer_descriptor() const { return at<1>().valid(); } + ::protozero::ConstBytes energy_consumer_descriptor() const { return at<1>().as_bytes(); } + bool has_energy_consumer_id() const { return at<2>().valid(); } + int32_t energy_consumer_id() const { return at<2>().as_int32(); } + bool has_energy_uws() const { return at<3>().valid(); } + int64_t energy_uws() const { return at<3>().as_int64(); } + bool has_per_uid_breakdown() const { return at<4>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> per_uid_breakdown() const { return GetRepeated<::protozero::ConstBytes>(4); } +}; + +class AndroidEnergyEstimationBreakdown : public ::protozero::Message { + public: + using Decoder = AndroidEnergyEstimationBreakdown_Decoder; + enum : int32_t { + kEnergyConsumerDescriptorFieldNumber = 1, + kEnergyConsumerIdFieldNumber = 2, + kEnergyUwsFieldNumber = 3, + kPerUidBreakdownFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.AndroidEnergyEstimationBreakdown"; } + + using EnergyUidBreakdown = ::perfetto::protos::pbzero::AndroidEnergyEstimationBreakdown_EnergyUidBreakdown; + + using FieldMetadata_EnergyConsumerDescriptor = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + AndroidEnergyConsumerDescriptor, + AndroidEnergyEstimationBreakdown>; + + static constexpr FieldMetadata_EnergyConsumerDescriptor kEnergyConsumerDescriptor{}; + template T* set_energy_consumer_descriptor() { + return BeginNestedMessage(1); + } + + + using FieldMetadata_EnergyConsumerId = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + AndroidEnergyEstimationBreakdown>; + + static constexpr FieldMetadata_EnergyConsumerId kEnergyConsumerId{}; + void set_energy_consumer_id(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_EnergyConsumerId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_EnergyUws = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + AndroidEnergyEstimationBreakdown>; + + static constexpr FieldMetadata_EnergyUws kEnergyUws{}; + void set_energy_uws(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_EnergyUws::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PerUidBreakdown = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + AndroidEnergyEstimationBreakdown_EnergyUidBreakdown, + AndroidEnergyEstimationBreakdown>; + + static constexpr FieldMetadata_PerUidBreakdown kPerUidBreakdown{}; + template T* add_per_uid_breakdown() { + return BeginNestedMessage(4); + } + +}; + +class AndroidEnergyEstimationBreakdown_EnergyUidBreakdown_Decoder : public ::protozero::TypedProtoDecoder { + public: + AndroidEnergyEstimationBreakdown_EnergyUidBreakdown_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit AndroidEnergyEstimationBreakdown_EnergyUidBreakdown_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit AndroidEnergyEstimationBreakdown_EnergyUidBreakdown_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_uid() const { return at<1>().valid(); } + int32_t uid() const { return at<1>().as_int32(); } + bool has_energy_uws() const { return at<2>().valid(); } + int64_t energy_uws() const { return at<2>().as_int64(); } +}; + +class AndroidEnergyEstimationBreakdown_EnergyUidBreakdown : public ::protozero::Message { + public: + using Decoder = AndroidEnergyEstimationBreakdown_EnergyUidBreakdown_Decoder; + enum : int32_t { + kUidFieldNumber = 1, + kEnergyUwsFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.AndroidEnergyEstimationBreakdown.EnergyUidBreakdown"; } + + + using FieldMetadata_Uid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + AndroidEnergyEstimationBreakdown_EnergyUidBreakdown>; + + static constexpr FieldMetadata_Uid kUid{}; + void set_uid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Uid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_EnergyUws = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + AndroidEnergyEstimationBreakdown_EnergyUidBreakdown>; + + static constexpr FieldMetadata_EnergyUws kEnergyUws{}; + void set_energy_uws(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_EnergyUws::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } +}; + +class AndroidEnergyConsumerDescriptor_Decoder : public ::protozero::TypedProtoDecoder { + public: + AndroidEnergyConsumerDescriptor_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit AndroidEnergyConsumerDescriptor_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit AndroidEnergyConsumerDescriptor_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_energy_consumers() const { return at<1>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> energy_consumers() const { return GetRepeated<::protozero::ConstBytes>(1); } +}; + +class AndroidEnergyConsumerDescriptor : public ::protozero::Message { + public: + using Decoder = AndroidEnergyConsumerDescriptor_Decoder; + enum : int32_t { + kEnergyConsumersFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.AndroidEnergyConsumerDescriptor"; } + + + using FieldMetadata_EnergyConsumers = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + AndroidEnergyConsumer, + AndroidEnergyConsumerDescriptor>; + + static constexpr FieldMetadata_EnergyConsumers kEnergyConsumers{}; + template T* add_energy_consumers() { + return BeginNestedMessage(1); + } + +}; + +class AndroidEnergyConsumer_Decoder : public ::protozero::TypedProtoDecoder { + public: + AndroidEnergyConsumer_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit AndroidEnergyConsumer_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit AndroidEnergyConsumer_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_energy_consumer_id() const { return at<1>().valid(); } + int32_t energy_consumer_id() const { return at<1>().as_int32(); } + bool has_ordinal() const { return at<2>().valid(); } + int32_t ordinal() const { return at<2>().as_int32(); } + bool has_type() const { return at<3>().valid(); } + ::protozero::ConstChars type() const { return at<3>().as_string(); } + bool has_name() const { return at<4>().valid(); } + ::protozero::ConstChars name() const { return at<4>().as_string(); } +}; + +class AndroidEnergyConsumer : public ::protozero::Message { + public: + using Decoder = AndroidEnergyConsumer_Decoder; + enum : int32_t { + kEnergyConsumerIdFieldNumber = 1, + kOrdinalFieldNumber = 2, + kTypeFieldNumber = 3, + kNameFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.AndroidEnergyConsumer"; } + + + using FieldMetadata_EnergyConsumerId = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + AndroidEnergyConsumer>; + + static constexpr FieldMetadata_EnergyConsumerId kEnergyConsumerId{}; + void set_energy_consumer_id(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_EnergyConsumerId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ordinal = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + AndroidEnergyConsumer>; + + static constexpr FieldMetadata_Ordinal kOrdinal{}; + void set_ordinal(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ordinal::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Type = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + AndroidEnergyConsumer>; + + static constexpr FieldMetadata_Type kType{}; + void set_type(const char* data, size_t size) { + AppendBytes(FieldMetadata_Type::kFieldId, data, size); + } + void set_type(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Type::kFieldId, chars.data, chars.size); + } + void set_type(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + AndroidEnergyConsumer>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class TracingServiceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + TracingServiceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TracingServiceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TracingServiceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_tracing_started() const { return at<2>().valid(); } + bool tracing_started() const { return at<2>().as_bool(); } + bool has_all_data_sources_started() const { return at<1>().valid(); } + bool all_data_sources_started() const { return at<1>().as_bool(); } + bool has_all_data_sources_flushed() const { return at<3>().valid(); } + bool all_data_sources_flushed() const { return at<3>().as_bool(); } + bool has_read_tracing_buffers_completed() const { return at<4>().valid(); } + bool read_tracing_buffers_completed() const { return at<4>().as_bool(); } + bool has_tracing_disabled() const { return at<5>().valid(); } + bool tracing_disabled() const { return at<5>().as_bool(); } + bool has_seized_for_bugreport() const { return at<6>().valid(); } + bool seized_for_bugreport() const { return at<6>().as_bool(); } +}; + +class TracingServiceEvent : public ::protozero::Message { + public: + using Decoder = TracingServiceEvent_Decoder; + enum : int32_t { + kTracingStartedFieldNumber = 2, + kAllDataSourcesStartedFieldNumber = 1, + kAllDataSourcesFlushedFieldNumber = 3, + kReadTracingBuffersCompletedFieldNumber = 4, + kTracingDisabledFieldNumber = 5, + kSeizedForBugreportFieldNumber = 6, + }; + static constexpr const char* GetName() { return ".perfetto.protos.TracingServiceEvent"; } + + + using FieldMetadata_TracingStarted = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + TracingServiceEvent>; + + static constexpr FieldMetadata_TracingStarted kTracingStarted{}; + void set_tracing_started(bool value) { + static constexpr uint32_t field_id = FieldMetadata_TracingStarted::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_AllDataSourcesStarted = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + TracingServiceEvent>; + + static constexpr FieldMetadata_AllDataSourcesStarted kAllDataSourcesStarted{}; + void set_all_data_sources_started(bool value) { + static constexpr uint32_t field_id = FieldMetadata_AllDataSourcesStarted::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_AllDataSourcesFlushed = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + TracingServiceEvent>; + + static constexpr FieldMetadata_AllDataSourcesFlushed kAllDataSourcesFlushed{}; + void set_all_data_sources_flushed(bool value) { + static constexpr uint32_t field_id = FieldMetadata_AllDataSourcesFlushed::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ReadTracingBuffersCompleted = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + TracingServiceEvent>; + + static constexpr FieldMetadata_ReadTracingBuffersCompleted kReadTracingBuffersCompleted{}; + void set_read_tracing_buffers_completed(bool value) { + static constexpr uint32_t field_id = FieldMetadata_ReadTracingBuffersCompleted::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TracingDisabled = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + TracingServiceEvent>; + + static constexpr FieldMetadata_TracingDisabled kTracingDisabled{}; + void set_tracing_disabled(bool value) { + static constexpr uint32_t field_id = FieldMetadata_TracingDisabled::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SeizedForBugreport = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + TracingServiceEvent>; + + static constexpr FieldMetadata_SeizedForBugreport kSeizedForBugreport{}; + void set_seized_for_bugreport(bool value) { + static constexpr uint32_t field_id = FieldMetadata_SeizedForBugreport::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } +}; + +class PerfettoMetatrace_Decoder : public ::protozero::TypedProtoDecoder { + public: + PerfettoMetatrace_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit PerfettoMetatrace_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit PerfettoMetatrace_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_event_id() const { return at<1>().valid(); } + uint32_t event_id() const { return at<1>().as_uint32(); } + bool has_counter_id() const { return at<2>().valid(); } + uint32_t counter_id() const { return at<2>().as_uint32(); } + bool has_event_name() const { return at<8>().valid(); } + ::protozero::ConstChars event_name() const { return at<8>().as_string(); } + bool has_event_name_iid() const { return at<11>().valid(); } + uint64_t event_name_iid() const { return at<11>().as_uint64(); } + bool has_counter_name() const { return at<9>().valid(); } + ::protozero::ConstChars counter_name() const { return at<9>().as_string(); } + bool has_event_duration_ns() const { return at<3>().valid(); } + uint64_t event_duration_ns() const { return at<3>().as_uint64(); } + bool has_counter_value() const { return at<4>().valid(); } + int32_t counter_value() const { return at<4>().as_int32(); } + bool has_thread_id() const { return at<5>().valid(); } + uint32_t thread_id() const { return at<5>().as_uint32(); } + bool has_has_overruns() const { return at<6>().valid(); } + bool has_overruns() const { return at<6>().as_bool(); } + bool has_args() const { return at<7>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> args() const { return GetRepeated<::protozero::ConstBytes>(7); } + bool has_interned_strings() const { return at<10>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> interned_strings() const { return GetRepeated<::protozero::ConstBytes>(10); } +}; + +class PerfettoMetatrace : public ::protozero::Message { + public: + using Decoder = PerfettoMetatrace_Decoder; + enum : int32_t { + kEventIdFieldNumber = 1, + kCounterIdFieldNumber = 2, + kEventNameFieldNumber = 8, + kEventNameIidFieldNumber = 11, + kCounterNameFieldNumber = 9, + kEventDurationNsFieldNumber = 3, + kCounterValueFieldNumber = 4, + kThreadIdFieldNumber = 5, + kHasOverrunsFieldNumber = 6, + kArgsFieldNumber = 7, + kInternedStringsFieldNumber = 10, + }; + static constexpr const char* GetName() { return ".perfetto.protos.PerfettoMetatrace"; } + + using Arg = ::perfetto::protos::pbzero::PerfettoMetatrace_Arg; + using InternedString = ::perfetto::protos::pbzero::PerfettoMetatrace_InternedString; + + using FieldMetadata_EventId = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + PerfettoMetatrace>; + + static constexpr FieldMetadata_EventId kEventId{}; + void set_event_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_EventId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CounterId = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + PerfettoMetatrace>; + + static constexpr FieldMetadata_CounterId kCounterId{}; + void set_counter_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_CounterId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_EventName = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + PerfettoMetatrace>; + + static constexpr FieldMetadata_EventName kEventName{}; + void set_event_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_EventName::kFieldId, data, size); + } + void set_event_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_EventName::kFieldId, chars.data, chars.size); + } + void set_event_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_EventName::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_EventNameIid = + ::protozero::proto_utils::FieldMetadata< + 11, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + PerfettoMetatrace>; + + static constexpr FieldMetadata_EventNameIid kEventNameIid{}; + void set_event_name_iid(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_EventNameIid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CounterName = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + PerfettoMetatrace>; + + static constexpr FieldMetadata_CounterName kCounterName{}; + void set_counter_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_CounterName::kFieldId, data, size); + } + void set_counter_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_CounterName::kFieldId, chars.data, chars.size); + } + void set_counter_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_CounterName::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_EventDurationNs = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + PerfettoMetatrace>; + + static constexpr FieldMetadata_EventDurationNs kEventDurationNs{}; + void set_event_duration_ns(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_EventDurationNs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CounterValue = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + PerfettoMetatrace>; + + static constexpr FieldMetadata_CounterValue kCounterValue{}; + void set_counter_value(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_CounterValue::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ThreadId = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + PerfettoMetatrace>; + + static constexpr FieldMetadata_ThreadId kThreadId{}; + void set_thread_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ThreadId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_HasOverruns = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + PerfettoMetatrace>; + + static constexpr FieldMetadata_HasOverruns kHasOverruns{}; + void set_has_overruns(bool value) { + static constexpr uint32_t field_id = FieldMetadata_HasOverruns::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Args = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + PerfettoMetatrace_Arg, + PerfettoMetatrace>; + + static constexpr FieldMetadata_Args kArgs{}; + template T* add_args() { + return BeginNestedMessage(7); + } + + + using FieldMetadata_InternedStrings = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + PerfettoMetatrace_InternedString, + PerfettoMetatrace>; + + static constexpr FieldMetadata_InternedStrings kInternedStrings{}; + template T* add_interned_strings() { + return BeginNestedMessage(10); + } + +}; + +class PerfettoMetatrace_InternedString_Decoder : public ::protozero::TypedProtoDecoder { + public: + PerfettoMetatrace_InternedString_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit PerfettoMetatrace_InternedString_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit PerfettoMetatrace_InternedString_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_iid() const { return at<1>().valid(); } + uint64_t iid() const { return at<1>().as_uint64(); } + bool has_value() const { return at<2>().valid(); } + ::protozero::ConstChars value() const { return at<2>().as_string(); } +}; + +class PerfettoMetatrace_InternedString : public ::protozero::Message { + public: + using Decoder = PerfettoMetatrace_InternedString_Decoder; + enum : int32_t { + kIidFieldNumber = 1, + kValueFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.PerfettoMetatrace.InternedString"; } + + + using FieldMetadata_Iid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + PerfettoMetatrace_InternedString>; + + static constexpr FieldMetadata_Iid kIid{}; + void set_iid(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Iid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Value = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + PerfettoMetatrace_InternedString>; + + static constexpr FieldMetadata_Value kValue{}; + void set_value(const char* data, size_t size) { + AppendBytes(FieldMetadata_Value::kFieldId, data, size); + } + void set_value(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Value::kFieldId, chars.data, chars.size); + } + void set_value(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class PerfettoMetatrace_Arg_Decoder : public ::protozero::TypedProtoDecoder { + public: + PerfettoMetatrace_Arg_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit PerfettoMetatrace_Arg_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit PerfettoMetatrace_Arg_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_key() const { return at<1>().valid(); } + ::protozero::ConstChars key() const { return at<1>().as_string(); } + bool has_key_iid() const { return at<3>().valid(); } + uint64_t key_iid() const { return at<3>().as_uint64(); } + bool has_value() const { return at<2>().valid(); } + ::protozero::ConstChars value() const { return at<2>().as_string(); } + bool has_value_iid() const { return at<4>().valid(); } + uint64_t value_iid() const { return at<4>().as_uint64(); } +}; + +class PerfettoMetatrace_Arg : public ::protozero::Message { + public: + using Decoder = PerfettoMetatrace_Arg_Decoder; + enum : int32_t { + kKeyFieldNumber = 1, + kKeyIidFieldNumber = 3, + kValueFieldNumber = 2, + kValueIidFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.PerfettoMetatrace.Arg"; } + + + using FieldMetadata_Key = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + PerfettoMetatrace_Arg>; + + static constexpr FieldMetadata_Key kKey{}; + void set_key(const char* data, size_t size) { + AppendBytes(FieldMetadata_Key::kFieldId, data, size); + } + void set_key(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Key::kFieldId, chars.data, chars.size); + } + void set_key(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Key::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_KeyIid = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + PerfettoMetatrace_Arg>; + + static constexpr FieldMetadata_KeyIid kKeyIid{}; + void set_key_iid(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_KeyIid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Value = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + PerfettoMetatrace_Arg>; + + static constexpr FieldMetadata_Value kValue{}; + void set_value(const char* data, size_t size) { + AppendBytes(FieldMetadata_Value::kFieldId, data, size); + } + void set_value(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Value::kFieldId, chars.data, chars.size); + } + void set_value(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ValueIid = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + PerfettoMetatrace_Arg>; + + static constexpr FieldMetadata_ValueIid kValueIid{}; + void set_value_iid(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_ValueIid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class MemoryTrackerSnapshot_Decoder : public ::protozero::TypedProtoDecoder { + public: + MemoryTrackerSnapshot_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MemoryTrackerSnapshot_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MemoryTrackerSnapshot_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_global_dump_id() const { return at<1>().valid(); } + uint64_t global_dump_id() const { return at<1>().as_uint64(); } + bool has_level_of_detail() const { return at<2>().valid(); } + int32_t level_of_detail() const { return at<2>().as_int32(); } + bool has_process_memory_dumps() const { return at<3>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> process_memory_dumps() const { return GetRepeated<::protozero::ConstBytes>(3); } +}; + +class MemoryTrackerSnapshot : public ::protozero::Message { + public: + using Decoder = MemoryTrackerSnapshot_Decoder; + enum : int32_t { + kGlobalDumpIdFieldNumber = 1, + kLevelOfDetailFieldNumber = 2, + kProcessMemoryDumpsFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MemoryTrackerSnapshot"; } + + using ProcessSnapshot = ::perfetto::protos::pbzero::MemoryTrackerSnapshot_ProcessSnapshot; + + using LevelOfDetail = ::perfetto::protos::pbzero::MemoryTrackerSnapshot_LevelOfDetail; + static inline const char* LevelOfDetail_Name(LevelOfDetail value) { + return ::perfetto::protos::pbzero::MemoryTrackerSnapshot_LevelOfDetail_Name(value); + } + static inline const LevelOfDetail DETAIL_FULL = LevelOfDetail::DETAIL_FULL; + static inline const LevelOfDetail DETAIL_LIGHT = LevelOfDetail::DETAIL_LIGHT; + static inline const LevelOfDetail DETAIL_BACKGROUND = LevelOfDetail::DETAIL_BACKGROUND; + + using FieldMetadata_GlobalDumpId = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MemoryTrackerSnapshot>; + + static constexpr FieldMetadata_GlobalDumpId kGlobalDumpId{}; + void set_global_dump_id(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_GlobalDumpId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_LevelOfDetail = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + MemoryTrackerSnapshot_LevelOfDetail, + MemoryTrackerSnapshot>; + + static constexpr FieldMetadata_LevelOfDetail kLevelOfDetail{}; + void set_level_of_detail(MemoryTrackerSnapshot_LevelOfDetail value) { + static constexpr uint32_t field_id = FieldMetadata_LevelOfDetail::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ProcessMemoryDumps = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MemoryTrackerSnapshot_ProcessSnapshot, + MemoryTrackerSnapshot>; + + static constexpr FieldMetadata_ProcessMemoryDumps kProcessMemoryDumps{}; + template T* add_process_memory_dumps() { + return BeginNestedMessage(3); + } + +}; + +class MemoryTrackerSnapshot_ProcessSnapshot_Decoder : public ::protozero::TypedProtoDecoder { + public: + MemoryTrackerSnapshot_ProcessSnapshot_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MemoryTrackerSnapshot_ProcessSnapshot_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MemoryTrackerSnapshot_ProcessSnapshot_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_pid() const { return at<1>().valid(); } + int32_t pid() const { return at<1>().as_int32(); } + bool has_allocator_dumps() const { return at<2>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> allocator_dumps() const { return GetRepeated<::protozero::ConstBytes>(2); } + bool has_memory_edges() const { return at<3>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> memory_edges() const { return GetRepeated<::protozero::ConstBytes>(3); } +}; + +class MemoryTrackerSnapshot_ProcessSnapshot : public ::protozero::Message { + public: + using Decoder = MemoryTrackerSnapshot_ProcessSnapshot_Decoder; + enum : int32_t { + kPidFieldNumber = 1, + kAllocatorDumpsFieldNumber = 2, + kMemoryEdgesFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MemoryTrackerSnapshot.ProcessSnapshot"; } + + using MemoryNode = ::perfetto::protos::pbzero::MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode; + using MemoryEdge = ::perfetto::protos::pbzero::MemoryTrackerSnapshot_ProcessSnapshot_MemoryEdge; + + using FieldMetadata_Pid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MemoryTrackerSnapshot_ProcessSnapshot>; + + static constexpr FieldMetadata_Pid kPid{}; + void set_pid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_AllocatorDumps = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode, + MemoryTrackerSnapshot_ProcessSnapshot>; + + static constexpr FieldMetadata_AllocatorDumps kAllocatorDumps{}; + template T* add_allocator_dumps() { + return BeginNestedMessage(2); + } + + + using FieldMetadata_MemoryEdges = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MemoryTrackerSnapshot_ProcessSnapshot_MemoryEdge, + MemoryTrackerSnapshot_ProcessSnapshot>; + + static constexpr FieldMetadata_MemoryEdges kMemoryEdges{}; + template T* add_memory_edges() { + return BeginNestedMessage(3); + } + +}; + +class MemoryTrackerSnapshot_ProcessSnapshot_MemoryEdge_Decoder : public ::protozero::TypedProtoDecoder { + public: + MemoryTrackerSnapshot_ProcessSnapshot_MemoryEdge_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MemoryTrackerSnapshot_ProcessSnapshot_MemoryEdge_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MemoryTrackerSnapshot_ProcessSnapshot_MemoryEdge_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_source_id() const { return at<1>().valid(); } + uint64_t source_id() const { return at<1>().as_uint64(); } + bool has_target_id() const { return at<2>().valid(); } + uint64_t target_id() const { return at<2>().as_uint64(); } + bool has_importance() const { return at<3>().valid(); } + uint32_t importance() const { return at<3>().as_uint32(); } + bool has_overridable() const { return at<4>().valid(); } + bool overridable() const { return at<4>().as_bool(); } +}; + +class MemoryTrackerSnapshot_ProcessSnapshot_MemoryEdge : public ::protozero::Message { + public: + using Decoder = MemoryTrackerSnapshot_ProcessSnapshot_MemoryEdge_Decoder; + enum : int32_t { + kSourceIdFieldNumber = 1, + kTargetIdFieldNumber = 2, + kImportanceFieldNumber = 3, + kOverridableFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MemoryTrackerSnapshot.ProcessSnapshot.MemoryEdge"; } + + + using FieldMetadata_SourceId = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MemoryTrackerSnapshot_ProcessSnapshot_MemoryEdge>; + + static constexpr FieldMetadata_SourceId kSourceId{}; + void set_source_id(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_SourceId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TargetId = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MemoryTrackerSnapshot_ProcessSnapshot_MemoryEdge>; + + static constexpr FieldMetadata_TargetId kTargetId{}; + void set_target_id(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_TargetId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Importance = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MemoryTrackerSnapshot_ProcessSnapshot_MemoryEdge>; + + static constexpr FieldMetadata_Importance kImportance{}; + void set_importance(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Importance::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Overridable = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + MemoryTrackerSnapshot_ProcessSnapshot_MemoryEdge>; + + static constexpr FieldMetadata_Overridable kOverridable{}; + void set_overridable(bool value) { + static constexpr uint32_t field_id = FieldMetadata_Overridable::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } +}; + +class MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_Decoder : public ::protozero::TypedProtoDecoder { + public: + MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_id() const { return at<1>().valid(); } + uint64_t id() const { return at<1>().as_uint64(); } + bool has_absolute_name() const { return at<2>().valid(); } + ::protozero::ConstChars absolute_name() const { return at<2>().as_string(); } + bool has_weak() const { return at<3>().valid(); } + bool weak() const { return at<3>().as_bool(); } + bool has_size_bytes() const { return at<4>().valid(); } + uint64_t size_bytes() const { return at<4>().as_uint64(); } + bool has_entries() const { return at<5>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> entries() const { return GetRepeated<::protozero::ConstBytes>(5); } +}; + +class MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode : public ::protozero::Message { + public: + using Decoder = MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_Decoder; + enum : int32_t { + kIdFieldNumber = 1, + kAbsoluteNameFieldNumber = 2, + kWeakFieldNumber = 3, + kSizeBytesFieldNumber = 4, + kEntriesFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MemoryTrackerSnapshot.ProcessSnapshot.MemoryNode"; } + + using MemoryNodeEntry = ::perfetto::protos::pbzero::MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry; + + using FieldMetadata_Id = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode>; + + static constexpr FieldMetadata_Id kId{}; + void set_id(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_AbsoluteName = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode>; + + static constexpr FieldMetadata_AbsoluteName kAbsoluteName{}; + void set_absolute_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_AbsoluteName::kFieldId, data, size); + } + void set_absolute_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_AbsoluteName::kFieldId, chars.data, chars.size); + } + void set_absolute_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_AbsoluteName::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Weak = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode>; + + static constexpr FieldMetadata_Weak kWeak{}; + void set_weak(bool value) { + static constexpr uint32_t field_id = FieldMetadata_Weak::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SizeBytes = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode>; + + static constexpr FieldMetadata_SizeBytes kSizeBytes{}; + void set_size_bytes(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_SizeBytes::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Entries = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry, + MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode>; + + static constexpr FieldMetadata_Entries kEntries{}; + template T* add_entries() { + return BeginNestedMessage(5); + } + +}; + +class MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry_Decoder : public ::protozero::TypedProtoDecoder { + public: + MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_name() const { return at<1>().valid(); } + ::protozero::ConstChars name() const { return at<1>().as_string(); } + bool has_units() const { return at<2>().valid(); } + int32_t units() const { return at<2>().as_int32(); } + bool has_value_uint64() const { return at<3>().valid(); } + uint64_t value_uint64() const { return at<3>().as_uint64(); } + bool has_value_string() const { return at<4>().valid(); } + ::protozero::ConstChars value_string() const { return at<4>().as_string(); } +}; + +class MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry : public ::protozero::Message { + public: + using Decoder = MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry_Decoder; + enum : int32_t { + kNameFieldNumber = 1, + kUnitsFieldNumber = 2, + kValueUint64FieldNumber = 3, + kValueStringFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MemoryTrackerSnapshot.ProcessSnapshot.MemoryNode.MemoryNodeEntry"; } + + + using Units = ::perfetto::protos::pbzero::MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry_Units; + static inline const char* Units_Name(Units value) { + return ::perfetto::protos::pbzero::MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry_Units_Name(value); + } + static inline const Units UNSPECIFIED = Units::UNSPECIFIED; + static inline const Units BYTES = Units::BYTES; + static inline const Units COUNT = Units::COUNT; + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Units = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry_Units, + MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry>; + + static constexpr FieldMetadata_Units kUnits{}; + void set_units(MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry_Units value) { + static constexpr uint32_t field_id = FieldMetadata_Units::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ValueUint64 = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry>; + + static constexpr FieldMetadata_ValueUint64 kValueUint64{}; + void set_value_uint64(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_ValueUint64::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ValueString = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + MemoryTrackerSnapshot_ProcessSnapshot_MemoryNode_MemoryNodeEntry>; + + static constexpr FieldMetadata_ValueString kValueString{}; + void set_value_string(const char* data, size_t size) { + AppendBytes(FieldMetadata_ValueString::kFieldId, data, size); + } + void set_value_string(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_ValueString::kFieldId, chars.data, chars.size); + } + void set_value_string(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_ValueString::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class InternedData_Decoder : public ::protozero::TypedProtoDecoder { + public: + InternedData_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit InternedData_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit InternedData_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_event_categories() const { return at<1>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> event_categories() const { return GetRepeated<::protozero::ConstBytes>(1); } + bool has_event_names() const { return at<2>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> event_names() const { return GetRepeated<::protozero::ConstBytes>(2); } + bool has_debug_annotation_names() const { return at<3>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> debug_annotation_names() const { return GetRepeated<::protozero::ConstBytes>(3); } + bool has_debug_annotation_value_type_names() const { return at<27>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> debug_annotation_value_type_names() const { return GetRepeated<::protozero::ConstBytes>(27); } + bool has_source_locations() const { return at<4>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> source_locations() const { return GetRepeated<::protozero::ConstBytes>(4); } + bool has_unsymbolized_source_locations() const { return at<28>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> unsymbolized_source_locations() const { return GetRepeated<::protozero::ConstBytes>(28); } + bool has_log_message_body() const { return at<20>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> log_message_body() const { return GetRepeated<::protozero::ConstBytes>(20); } + bool has_histogram_names() const { return at<25>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> histogram_names() const { return GetRepeated<::protozero::ConstBytes>(25); } + bool has_build_ids() const { return at<16>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> build_ids() const { return GetRepeated<::protozero::ConstBytes>(16); } + bool has_mapping_paths() const { return at<17>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> mapping_paths() const { return GetRepeated<::protozero::ConstBytes>(17); } + bool has_source_paths() const { return at<18>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> source_paths() const { return GetRepeated<::protozero::ConstBytes>(18); } + bool has_function_names() const { return at<5>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> function_names() const { return GetRepeated<::protozero::ConstBytes>(5); } + bool has_profiled_frame_symbols() const { return at<21>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> profiled_frame_symbols() const { return GetRepeated<::protozero::ConstBytes>(21); } + bool has_mappings() const { return at<19>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> mappings() const { return GetRepeated<::protozero::ConstBytes>(19); } + bool has_frames() const { return at<6>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> frames() const { return GetRepeated<::protozero::ConstBytes>(6); } + bool has_callstacks() const { return at<7>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> callstacks() const { return GetRepeated<::protozero::ConstBytes>(7); } + bool has_vulkan_memory_keys() const { return at<22>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> vulkan_memory_keys() const { return GetRepeated<::protozero::ConstBytes>(22); } + bool has_graphics_contexts() const { return at<23>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> graphics_contexts() const { return GetRepeated<::protozero::ConstBytes>(23); } + bool has_gpu_specifications() const { return at<24>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> gpu_specifications() const { return GetRepeated<::protozero::ConstBytes>(24); } + bool has_kernel_symbols() const { return at<26>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> kernel_symbols() const { return GetRepeated<::protozero::ConstBytes>(26); } + bool has_debug_annotation_string_values() const { return at<29>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> debug_annotation_string_values() const { return GetRepeated<::protozero::ConstBytes>(29); } + bool has_packet_context() const { return at<30>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> packet_context() const { return GetRepeated<::protozero::ConstBytes>(30); } + bool has_v8_js_function_name() const { return at<31>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> v8_js_function_name() const { return GetRepeated<::protozero::ConstBytes>(31); } + bool has_v8_js_function() const { return at<32>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> v8_js_function() const { return GetRepeated<::protozero::ConstBytes>(32); } + bool has_v8_js_script() const { return at<33>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> v8_js_script() const { return GetRepeated<::protozero::ConstBytes>(33); } + bool has_v8_wasm_script() const { return at<34>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> v8_wasm_script() const { return GetRepeated<::protozero::ConstBytes>(34); } + bool has_v8_isolate() const { return at<35>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> v8_isolate() const { return GetRepeated<::protozero::ConstBytes>(35); } + bool has_protolog_string_args() const { return at<36>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> protolog_string_args() const { return GetRepeated<::protozero::ConstBytes>(36); } + bool has_protolog_stacktrace() const { return at<37>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> protolog_stacktrace() const { return GetRepeated<::protozero::ConstBytes>(37); } +}; + +class InternedData : public ::protozero::Message { + public: + using Decoder = InternedData_Decoder; + enum : int32_t { + kEventCategoriesFieldNumber = 1, + kEventNamesFieldNumber = 2, + kDebugAnnotationNamesFieldNumber = 3, + kDebugAnnotationValueTypeNamesFieldNumber = 27, + kSourceLocationsFieldNumber = 4, + kUnsymbolizedSourceLocationsFieldNumber = 28, + kLogMessageBodyFieldNumber = 20, + kHistogramNamesFieldNumber = 25, + kBuildIdsFieldNumber = 16, + kMappingPathsFieldNumber = 17, + kSourcePathsFieldNumber = 18, + kFunctionNamesFieldNumber = 5, + kProfiledFrameSymbolsFieldNumber = 21, + kMappingsFieldNumber = 19, + kFramesFieldNumber = 6, + kCallstacksFieldNumber = 7, + kVulkanMemoryKeysFieldNumber = 22, + kGraphicsContextsFieldNumber = 23, + kGpuSpecificationsFieldNumber = 24, + kKernelSymbolsFieldNumber = 26, + kDebugAnnotationStringValuesFieldNumber = 29, + kPacketContextFieldNumber = 30, + kV8JsFunctionNameFieldNumber = 31, + kV8JsFunctionFieldNumber = 32, + kV8JsScriptFieldNumber = 33, + kV8WasmScriptFieldNumber = 34, + kV8IsolateFieldNumber = 35, + kProtologStringArgsFieldNumber = 36, + kProtologStacktraceFieldNumber = 37, + }; + static constexpr const char* GetName() { return ".perfetto.protos.InternedData"; } + + + using FieldMetadata_EventCategories = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + EventCategory, + InternedData>; + + static constexpr FieldMetadata_EventCategories kEventCategories{}; + template T* add_event_categories() { + return BeginNestedMessage(1); + } + + + using FieldMetadata_EventNames = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + EventName, + InternedData>; + + static constexpr FieldMetadata_EventNames kEventNames{}; + template T* add_event_names() { + return BeginNestedMessage(2); + } + + + using FieldMetadata_DebugAnnotationNames = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + DebugAnnotationName, + InternedData>; + + static constexpr FieldMetadata_DebugAnnotationNames kDebugAnnotationNames{}; + template T* add_debug_annotation_names() { + return BeginNestedMessage(3); + } + + + using FieldMetadata_DebugAnnotationValueTypeNames = + ::protozero::proto_utils::FieldMetadata< + 27, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + DebugAnnotationValueTypeName, + InternedData>; + + static constexpr FieldMetadata_DebugAnnotationValueTypeNames kDebugAnnotationValueTypeNames{}; + template T* add_debug_annotation_value_type_names() { + return BeginNestedMessage(27); + } + + + using FieldMetadata_SourceLocations = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + SourceLocation, + InternedData>; + + static constexpr FieldMetadata_SourceLocations kSourceLocations{}; + template T* add_source_locations() { + return BeginNestedMessage(4); + } + + + using FieldMetadata_UnsymbolizedSourceLocations = + ::protozero::proto_utils::FieldMetadata< + 28, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + UnsymbolizedSourceLocation, + InternedData>; + + static constexpr FieldMetadata_UnsymbolizedSourceLocations kUnsymbolizedSourceLocations{}; + template T* add_unsymbolized_source_locations() { + return BeginNestedMessage(28); + } + + + using FieldMetadata_LogMessageBody = + ::protozero::proto_utils::FieldMetadata< + 20, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + LogMessageBody, + InternedData>; + + static constexpr FieldMetadata_LogMessageBody kLogMessageBody{}; + template T* add_log_message_body() { + return BeginNestedMessage(20); + } + + + using FieldMetadata_HistogramNames = + ::protozero::proto_utils::FieldMetadata< + 25, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + HistogramName, + InternedData>; + + static constexpr FieldMetadata_HistogramNames kHistogramNames{}; + template T* add_histogram_names() { + return BeginNestedMessage(25); + } + + + using FieldMetadata_BuildIds = + ::protozero::proto_utils::FieldMetadata< + 16, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + InternedString, + InternedData>; + + static constexpr FieldMetadata_BuildIds kBuildIds{}; + template T* add_build_ids() { + return BeginNestedMessage(16); + } + + + using FieldMetadata_MappingPaths = + ::protozero::proto_utils::FieldMetadata< + 17, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + InternedString, + InternedData>; + + static constexpr FieldMetadata_MappingPaths kMappingPaths{}; + template T* add_mapping_paths() { + return BeginNestedMessage(17); + } + + + using FieldMetadata_SourcePaths = + ::protozero::proto_utils::FieldMetadata< + 18, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + InternedString, + InternedData>; + + static constexpr FieldMetadata_SourcePaths kSourcePaths{}; + template T* add_source_paths() { + return BeginNestedMessage(18); + } + + + using FieldMetadata_FunctionNames = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + InternedString, + InternedData>; + + static constexpr FieldMetadata_FunctionNames kFunctionNames{}; + template T* add_function_names() { + return BeginNestedMessage(5); + } + + + using FieldMetadata_ProfiledFrameSymbols = + ::protozero::proto_utils::FieldMetadata< + 21, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ProfiledFrameSymbols, + InternedData>; + + static constexpr FieldMetadata_ProfiledFrameSymbols kProfiledFrameSymbols{}; + template T* add_profiled_frame_symbols() { + return BeginNestedMessage(21); + } + + + using FieldMetadata_Mappings = + ::protozero::proto_utils::FieldMetadata< + 19, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Mapping, + InternedData>; + + static constexpr FieldMetadata_Mappings kMappings{}; + template T* add_mappings() { + return BeginNestedMessage(19); + } + + + using FieldMetadata_Frames = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Frame, + InternedData>; + + static constexpr FieldMetadata_Frames kFrames{}; + template T* add_frames() { + return BeginNestedMessage(6); + } + + + using FieldMetadata_Callstacks = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Callstack, + InternedData>; + + static constexpr FieldMetadata_Callstacks kCallstacks{}; + template T* add_callstacks() { + return BeginNestedMessage(7); + } + + + using FieldMetadata_VulkanMemoryKeys = + ::protozero::proto_utils::FieldMetadata< + 22, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + InternedString, + InternedData>; + + static constexpr FieldMetadata_VulkanMemoryKeys kVulkanMemoryKeys{}; + template T* add_vulkan_memory_keys() { + return BeginNestedMessage(22); + } + + + using FieldMetadata_GraphicsContexts = + ::protozero::proto_utils::FieldMetadata< + 23, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + InternedGraphicsContext, + InternedData>; + + static constexpr FieldMetadata_GraphicsContexts kGraphicsContexts{}; + template T* add_graphics_contexts() { + return BeginNestedMessage(23); + } + + + using FieldMetadata_GpuSpecifications = + ::protozero::proto_utils::FieldMetadata< + 24, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + InternedGpuRenderStageSpecification, + InternedData>; + + static constexpr FieldMetadata_GpuSpecifications kGpuSpecifications{}; + template T* add_gpu_specifications() { + return BeginNestedMessage(24); + } + + + using FieldMetadata_KernelSymbols = + ::protozero::proto_utils::FieldMetadata< + 26, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + InternedString, + InternedData>; + + static constexpr FieldMetadata_KernelSymbols kKernelSymbols{}; + template T* add_kernel_symbols() { + return BeginNestedMessage(26); + } + + + using FieldMetadata_DebugAnnotationStringValues = + ::protozero::proto_utils::FieldMetadata< + 29, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + InternedString, + InternedData>; + + static constexpr FieldMetadata_DebugAnnotationStringValues kDebugAnnotationStringValues{}; + template T* add_debug_annotation_string_values() { + return BeginNestedMessage(29); + } + + + using FieldMetadata_PacketContext = + ::protozero::proto_utils::FieldMetadata< + 30, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + NetworkPacketContext, + InternedData>; + + static constexpr FieldMetadata_PacketContext kPacketContext{}; + template T* add_packet_context() { + return BeginNestedMessage(30); + } + + + using FieldMetadata_V8JsFunctionName = + ::protozero::proto_utils::FieldMetadata< + 31, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + InternedV8String, + InternedData>; + + static constexpr FieldMetadata_V8JsFunctionName kV8JsFunctionName{}; + template T* add_v8_js_function_name() { + return BeginNestedMessage(31); + } + + + using FieldMetadata_V8JsFunction = + ::protozero::proto_utils::FieldMetadata< + 32, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + InternedV8JsFunction, + InternedData>; + + static constexpr FieldMetadata_V8JsFunction kV8JsFunction{}; + template T* add_v8_js_function() { + return BeginNestedMessage(32); + } + + + using FieldMetadata_V8JsScript = + ::protozero::proto_utils::FieldMetadata< + 33, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + InternedV8JsScript, + InternedData>; + + static constexpr FieldMetadata_V8JsScript kV8JsScript{}; + template T* add_v8_js_script() { + return BeginNestedMessage(33); + } + + + using FieldMetadata_V8WasmScript = + ::protozero::proto_utils::FieldMetadata< + 34, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + InternedV8WasmScript, + InternedData>; + + static constexpr FieldMetadata_V8WasmScript kV8WasmScript{}; + template T* add_v8_wasm_script() { + return BeginNestedMessage(34); + } + + + using FieldMetadata_V8Isolate = + ::protozero::proto_utils::FieldMetadata< + 35, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + InternedV8Isolate, + InternedData>; + + static constexpr FieldMetadata_V8Isolate kV8Isolate{}; + template T* add_v8_isolate() { + return BeginNestedMessage(35); + } + + + using FieldMetadata_ProtologStringArgs = + ::protozero::proto_utils::FieldMetadata< + 36, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + InternedString, + InternedData>; + + static constexpr FieldMetadata_ProtologStringArgs kProtologStringArgs{}; + template T* add_protolog_string_args() { + return BeginNestedMessage(36); + } + + + using FieldMetadata_ProtologStacktrace = + ::protozero::proto_utils::FieldMetadata< + 37, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + InternedString, + InternedData>; + + static constexpr FieldMetadata_ProtologStacktrace kProtologStacktrace{}; + template T* add_protolog_stacktrace() { + return BeginNestedMessage(37); + } + +}; + +class EventName_Decoder : public ::protozero::TypedProtoDecoder { + public: + EventName_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit EventName_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit EventName_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_iid() const { return at<1>().valid(); } + uint64_t iid() const { return at<1>().as_uint64(); } + bool has_name() const { return at<2>().valid(); } + ::protozero::ConstChars name() const { return at<2>().as_string(); } +}; + +class EventName : public ::protozero::Message { + public: + using Decoder = EventName_Decoder; + enum : int32_t { + kIidFieldNumber = 1, + kNameFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.EventName"; } + + + using FieldMetadata_Iid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + EventName>; + + static constexpr FieldMetadata_Iid kIid{}; + void set_iid(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Iid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + EventName>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class EventCategory_Decoder : public ::protozero::TypedProtoDecoder { + public: + EventCategory_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit EventCategory_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit EventCategory_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_iid() const { return at<1>().valid(); } + uint64_t iid() const { return at<1>().as_uint64(); } + bool has_name() const { return at<2>().valid(); } + ::protozero::ConstChars name() const { return at<2>().as_string(); } +}; + +class EventCategory : public ::protozero::Message { + public: + using Decoder = EventCategory_Decoder; + enum : int32_t { + kIidFieldNumber = 1, + kNameFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.EventCategory"; } + + + using FieldMetadata_Iid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + EventCategory>; + + static constexpr FieldMetadata_Iid kIid{}; + void set_iid(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Iid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + EventCategory>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class TrackEventDefaults_Decoder : public ::protozero::TypedProtoDecoder { + public: + TrackEventDefaults_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TrackEventDefaults_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TrackEventDefaults_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_track_uuid() const { return at<11>().valid(); } + uint64_t track_uuid() const { return at<11>().as_uint64(); } + bool has_extra_counter_track_uuids() const { return at<31>().valid(); } + ::protozero::RepeatedFieldIterator extra_counter_track_uuids() const { return GetRepeated(31); } + bool has_extra_double_counter_track_uuids() const { return at<45>().valid(); } + ::protozero::RepeatedFieldIterator extra_double_counter_track_uuids() const { return GetRepeated(45); } +}; + +class TrackEventDefaults : public ::protozero::Message { + public: + using Decoder = TrackEventDefaults_Decoder; + enum : int32_t { + kTrackUuidFieldNumber = 11, + kExtraCounterTrackUuidsFieldNumber = 31, + kExtraDoubleCounterTrackUuidsFieldNumber = 45, + }; + static constexpr const char* GetName() { return ".perfetto.protos.TrackEventDefaults"; } + + + using FieldMetadata_TrackUuid = + ::protozero::proto_utils::FieldMetadata< + 11, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TrackEventDefaults>; + + static constexpr FieldMetadata_TrackUuid kTrackUuid{}; + void set_track_uuid(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_TrackUuid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ExtraCounterTrackUuids = + ::protozero::proto_utils::FieldMetadata< + 31, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TrackEventDefaults>; + + static constexpr FieldMetadata_ExtraCounterTrackUuids kExtraCounterTrackUuids{}; + void add_extra_counter_track_uuids(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_ExtraCounterTrackUuids::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ExtraDoubleCounterTrackUuids = + ::protozero::proto_utils::FieldMetadata< + 45, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TrackEventDefaults>; + + static constexpr FieldMetadata_ExtraDoubleCounterTrackUuids kExtraDoubleCounterTrackUuids{}; + void add_extra_double_counter_track_uuids(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_ExtraDoubleCounterTrackUuids::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class TrackEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + TrackEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TrackEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TrackEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_category_iids() const { return at<3>().valid(); } + ::protozero::RepeatedFieldIterator category_iids() const { return GetRepeated(3); } + bool has_categories() const { return at<22>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstChars> categories() const { return GetRepeated<::protozero::ConstChars>(22); } + bool has_name_iid() const { return at<10>().valid(); } + uint64_t name_iid() const { return at<10>().as_uint64(); } + bool has_name() const { return at<23>().valid(); } + ::protozero::ConstChars name() const { return at<23>().as_string(); } + bool has_type() const { return at<9>().valid(); } + int32_t type() const { return at<9>().as_int32(); } + bool has_track_uuid() const { return at<11>().valid(); } + uint64_t track_uuid() const { return at<11>().as_uint64(); } + bool has_counter_value() const { return at<30>().valid(); } + int64_t counter_value() const { return at<30>().as_int64(); } + bool has_double_counter_value() const { return at<44>().valid(); } + double double_counter_value() const { return at<44>().as_double(); } + bool has_extra_counter_track_uuids() const { return at<31>().valid(); } + ::protozero::RepeatedFieldIterator extra_counter_track_uuids() const { return GetRepeated(31); } + bool has_extra_counter_values() const { return at<12>().valid(); } + ::protozero::RepeatedFieldIterator extra_counter_values() const { return GetRepeated(12); } + bool has_extra_double_counter_track_uuids() const { return at<45>().valid(); } + ::protozero::RepeatedFieldIterator extra_double_counter_track_uuids() const { return GetRepeated(45); } + bool has_extra_double_counter_values() const { return at<46>().valid(); } + ::protozero::RepeatedFieldIterator extra_double_counter_values() const { return GetRepeated(46); } + bool has_flow_ids_old() const { return at<36>().valid(); } + ::protozero::RepeatedFieldIterator flow_ids_old() const { return GetRepeated(36); } + bool has_flow_ids() const { return at<47>().valid(); } + ::protozero::RepeatedFieldIterator flow_ids() const { return GetRepeated(47); } + bool has_terminating_flow_ids_old() const { return at<42>().valid(); } + ::protozero::RepeatedFieldIterator terminating_flow_ids_old() const { return GetRepeated(42); } + bool has_terminating_flow_ids() const { return at<48>().valid(); } + ::protozero::RepeatedFieldIterator terminating_flow_ids() const { return GetRepeated(48); } + bool has_debug_annotations() const { return at<4>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> debug_annotations() const { return GetRepeated<::protozero::ConstBytes>(4); } + bool has_task_execution() const { return at<5>().valid(); } + ::protozero::ConstBytes task_execution() const { return at<5>().as_bytes(); } + bool has_log_message() const { return at<21>().valid(); } + ::protozero::ConstBytes log_message() const { return at<21>().as_bytes(); } + bool has_cc_scheduler_state() const { return at<24>().valid(); } + ::protozero::ConstBytes cc_scheduler_state() const { return at<24>().as_bytes(); } + bool has_chrome_user_event() const { return at<25>().valid(); } + ::protozero::ConstBytes chrome_user_event() const { return at<25>().as_bytes(); } + bool has_chrome_keyed_service() const { return at<26>().valid(); } + ::protozero::ConstBytes chrome_keyed_service() const { return at<26>().as_bytes(); } + bool has_chrome_legacy_ipc() const { return at<27>().valid(); } + ::protozero::ConstBytes chrome_legacy_ipc() const { return at<27>().as_bytes(); } + bool has_chrome_histogram_sample() const { return at<28>().valid(); } + ::protozero::ConstBytes chrome_histogram_sample() const { return at<28>().as_bytes(); } + bool has_chrome_latency_info() const { return at<29>().valid(); } + ::protozero::ConstBytes chrome_latency_info() const { return at<29>().as_bytes(); } + bool has_chrome_frame_reporter() const { return at<32>().valid(); } + ::protozero::ConstBytes chrome_frame_reporter() const { return at<32>().as_bytes(); } + bool has_chrome_application_state_info() const { return at<39>().valid(); } + ::protozero::ConstBytes chrome_application_state_info() const { return at<39>().as_bytes(); } + bool has_chrome_renderer_scheduler_state() const { return at<40>().valid(); } + ::protozero::ConstBytes chrome_renderer_scheduler_state() const { return at<40>().as_bytes(); } + bool has_chrome_window_handle_event_info() const { return at<41>().valid(); } + ::protozero::ConstBytes chrome_window_handle_event_info() const { return at<41>().as_bytes(); } + bool has_chrome_content_settings_event_info() const { return at<43>().valid(); } + ::protozero::ConstBytes chrome_content_settings_event_info() const { return at<43>().as_bytes(); } + bool has_chrome_active_processes() const { return at<49>().valid(); } + ::protozero::ConstBytes chrome_active_processes() const { return at<49>().as_bytes(); } + bool has_screenshot() const { return at<50>().valid(); } + ::protozero::ConstBytes screenshot() const { return at<50>().as_bytes(); } + bool has_pixel_modem_event_insight() const { return at<51>().valid(); } + ::protozero::ConstBytes pixel_modem_event_insight() const { return at<51>().as_bytes(); } + bool has_source_location() const { return at<33>().valid(); } + ::protozero::ConstBytes source_location() const { return at<33>().as_bytes(); } + bool has_source_location_iid() const { return at<34>().valid(); } + uint64_t source_location_iid() const { return at<34>().as_uint64(); } + bool has_chrome_message_pump() const { return at<35>().valid(); } + ::protozero::ConstBytes chrome_message_pump() const { return at<35>().as_bytes(); } + bool has_chrome_mojo_event_info() const { return at<38>().valid(); } + ::protozero::ConstBytes chrome_mojo_event_info() const { return at<38>().as_bytes(); } + bool has_timestamp_delta_us() const { return at<1>().valid(); } + int64_t timestamp_delta_us() const { return at<1>().as_int64(); } + bool has_timestamp_absolute_us() const { return at<16>().valid(); } + int64_t timestamp_absolute_us() const { return at<16>().as_int64(); } + bool has_thread_time_delta_us() const { return at<2>().valid(); } + int64_t thread_time_delta_us() const { return at<2>().as_int64(); } + bool has_thread_time_absolute_us() const { return at<17>().valid(); } + int64_t thread_time_absolute_us() const { return at<17>().as_int64(); } + bool has_thread_instruction_count_delta() const { return at<8>().valid(); } + int64_t thread_instruction_count_delta() const { return at<8>().as_int64(); } + bool has_thread_instruction_count_absolute() const { return at<20>().valid(); } + int64_t thread_instruction_count_absolute() const { return at<20>().as_int64(); } + bool has_legacy_event() const { return at<6>().valid(); } + ::protozero::ConstBytes legacy_event() const { return at<6>().as_bytes(); } +}; + +class TrackEvent : public ::protozero::Message { + public: + using Decoder = TrackEvent_Decoder; + enum : int32_t { + kCategoryIidsFieldNumber = 3, + kCategoriesFieldNumber = 22, + kNameIidFieldNumber = 10, + kNameFieldNumber = 23, + kTypeFieldNumber = 9, + kTrackUuidFieldNumber = 11, + kCounterValueFieldNumber = 30, + kDoubleCounterValueFieldNumber = 44, + kExtraCounterTrackUuidsFieldNumber = 31, + kExtraCounterValuesFieldNumber = 12, + kExtraDoubleCounterTrackUuidsFieldNumber = 45, + kExtraDoubleCounterValuesFieldNumber = 46, + kFlowIdsOldFieldNumber = 36, + kFlowIdsFieldNumber = 47, + kTerminatingFlowIdsOldFieldNumber = 42, + kTerminatingFlowIdsFieldNumber = 48, + kDebugAnnotationsFieldNumber = 4, + kTaskExecutionFieldNumber = 5, + kLogMessageFieldNumber = 21, + kCcSchedulerStateFieldNumber = 24, + kChromeUserEventFieldNumber = 25, + kChromeKeyedServiceFieldNumber = 26, + kChromeLegacyIpcFieldNumber = 27, + kChromeHistogramSampleFieldNumber = 28, + kChromeLatencyInfoFieldNumber = 29, + kChromeFrameReporterFieldNumber = 32, + kChromeApplicationStateInfoFieldNumber = 39, + kChromeRendererSchedulerStateFieldNumber = 40, + kChromeWindowHandleEventInfoFieldNumber = 41, + kChromeContentSettingsEventInfoFieldNumber = 43, + kChromeActiveProcessesFieldNumber = 49, + kScreenshotFieldNumber = 50, + kPixelModemEventInsightFieldNumber = 51, + kSourceLocationFieldNumber = 33, + kSourceLocationIidFieldNumber = 34, + kChromeMessagePumpFieldNumber = 35, + kChromeMojoEventInfoFieldNumber = 38, + kTimestampDeltaUsFieldNumber = 1, + kTimestampAbsoluteUsFieldNumber = 16, + kThreadTimeDeltaUsFieldNumber = 2, + kThreadTimeAbsoluteUsFieldNumber = 17, + kThreadInstructionCountDeltaFieldNumber = 8, + kThreadInstructionCountAbsoluteFieldNumber = 20, + kLegacyEventFieldNumber = 6, + }; + static constexpr const char* GetName() { return ".perfetto.protos.TrackEvent"; } + + using LegacyEvent = ::perfetto::protos::pbzero::TrackEvent_LegacyEvent; + + using Type = ::perfetto::protos::pbzero::TrackEvent_Type; + static inline const char* Type_Name(Type value) { + return ::perfetto::protos::pbzero::TrackEvent_Type_Name(value); + } + static inline const Type TYPE_UNSPECIFIED = Type::TYPE_UNSPECIFIED; + static inline const Type TYPE_SLICE_BEGIN = Type::TYPE_SLICE_BEGIN; + static inline const Type TYPE_SLICE_END = Type::TYPE_SLICE_END; + static inline const Type TYPE_INSTANT = Type::TYPE_INSTANT; + static inline const Type TYPE_COUNTER = Type::TYPE_COUNTER; + + using FieldMetadata_CategoryIids = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TrackEvent>; + + static constexpr FieldMetadata_CategoryIids kCategoryIids{}; + void add_category_iids(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_CategoryIids::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Categories = + ::protozero::proto_utils::FieldMetadata< + 22, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + TrackEvent>; + + static constexpr FieldMetadata_Categories kCategories{}; + void add_categories(const char* data, size_t size) { + AppendBytes(FieldMetadata_Categories::kFieldId, data, size); + } + void add_categories(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Categories::kFieldId, chars.data, chars.size); + } + void add_categories(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Categories::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NameIid = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TrackEvent>; + + static constexpr FieldMetadata_NameIid kNameIid{}; + void set_name_iid(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_NameIid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 23, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + TrackEvent>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Type = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + TrackEvent_Type, + TrackEvent>; + + static constexpr FieldMetadata_Type kType{}; + void set_type(TrackEvent_Type value) { + static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TrackUuid = + ::protozero::proto_utils::FieldMetadata< + 11, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TrackEvent>; + + static constexpr FieldMetadata_TrackUuid kTrackUuid{}; + void set_track_uuid(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_TrackUuid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CounterValue = + ::protozero::proto_utils::FieldMetadata< + 30, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + TrackEvent>; + + static constexpr FieldMetadata_CounterValue kCounterValue{}; + void set_counter_value(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_CounterValue::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DoubleCounterValue = + ::protozero::proto_utils::FieldMetadata< + 44, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kDouble, + double, + TrackEvent>; + + static constexpr FieldMetadata_DoubleCounterValue kDoubleCounterValue{}; + void set_double_counter_value(double value) { + static constexpr uint32_t field_id = FieldMetadata_DoubleCounterValue::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kDouble> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ExtraCounterTrackUuids = + ::protozero::proto_utils::FieldMetadata< + 31, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TrackEvent>; + + static constexpr FieldMetadata_ExtraCounterTrackUuids kExtraCounterTrackUuids{}; + void add_extra_counter_track_uuids(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_ExtraCounterTrackUuids::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ExtraCounterValues = + ::protozero::proto_utils::FieldMetadata< + 12, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + TrackEvent>; + + static constexpr FieldMetadata_ExtraCounterValues kExtraCounterValues{}; + void add_extra_counter_values(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_ExtraCounterValues::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ExtraDoubleCounterTrackUuids = + ::protozero::proto_utils::FieldMetadata< + 45, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TrackEvent>; + + static constexpr FieldMetadata_ExtraDoubleCounterTrackUuids kExtraDoubleCounterTrackUuids{}; + void add_extra_double_counter_track_uuids(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_ExtraDoubleCounterTrackUuids::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ExtraDoubleCounterValues = + ::protozero::proto_utils::FieldMetadata< + 46, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kDouble, + double, + TrackEvent>; + + static constexpr FieldMetadata_ExtraDoubleCounterValues kExtraDoubleCounterValues{}; + void add_extra_double_counter_values(double value) { + static constexpr uint32_t field_id = FieldMetadata_ExtraDoubleCounterValues::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kDouble> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FlowIdsOld = + ::protozero::proto_utils::FieldMetadata< + 36, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TrackEvent>; + + static constexpr FieldMetadata_FlowIdsOld kFlowIdsOld{}; + void add_flow_ids_old(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_FlowIdsOld::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FlowIds = + ::protozero::proto_utils::FieldMetadata< + 47, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kFixed64, + uint64_t, + TrackEvent>; + + static constexpr FieldMetadata_FlowIds kFlowIds{}; + void add_flow_ids(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_FlowIds::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFixed64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TerminatingFlowIdsOld = + ::protozero::proto_utils::FieldMetadata< + 42, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TrackEvent>; + + static constexpr FieldMetadata_TerminatingFlowIdsOld kTerminatingFlowIdsOld{}; + void add_terminating_flow_ids_old(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_TerminatingFlowIdsOld::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TerminatingFlowIds = + ::protozero::proto_utils::FieldMetadata< + 48, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kFixed64, + uint64_t, + TrackEvent>; + + static constexpr FieldMetadata_TerminatingFlowIds kTerminatingFlowIds{}; + void add_terminating_flow_ids(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_TerminatingFlowIds::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFixed64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DebugAnnotations = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + DebugAnnotation, + TrackEvent>; + + static constexpr FieldMetadata_DebugAnnotations kDebugAnnotations{}; + template T* add_debug_annotations() { + return BeginNestedMessage(4); + } + + + using FieldMetadata_TaskExecution = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TaskExecution, + TrackEvent>; + + static constexpr FieldMetadata_TaskExecution kTaskExecution{}; + template T* set_task_execution() { + return BeginNestedMessage(5); + } + + + using FieldMetadata_LogMessage = + ::protozero::proto_utils::FieldMetadata< + 21, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + LogMessage, + TrackEvent>; + + static constexpr FieldMetadata_LogMessage kLogMessage{}; + template T* set_log_message() { + return BeginNestedMessage(21); + } + + + using FieldMetadata_CcSchedulerState = + ::protozero::proto_utils::FieldMetadata< + 24, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ChromeCompositorSchedulerState, + TrackEvent>; + + static constexpr FieldMetadata_CcSchedulerState kCcSchedulerState{}; + template T* set_cc_scheduler_state() { + return BeginNestedMessage(24); + } + + + using FieldMetadata_ChromeUserEvent = + ::protozero::proto_utils::FieldMetadata< + 25, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ChromeUserEvent, + TrackEvent>; + + static constexpr FieldMetadata_ChromeUserEvent kChromeUserEvent{}; + template T* set_chrome_user_event() { + return BeginNestedMessage(25); + } + + + using FieldMetadata_ChromeKeyedService = + ::protozero::proto_utils::FieldMetadata< + 26, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ChromeKeyedService, + TrackEvent>; + + static constexpr FieldMetadata_ChromeKeyedService kChromeKeyedService{}; + template T* set_chrome_keyed_service() { + return BeginNestedMessage(26); + } + + + using FieldMetadata_ChromeLegacyIpc = + ::protozero::proto_utils::FieldMetadata< + 27, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ChromeLegacyIpc, + TrackEvent>; + + static constexpr FieldMetadata_ChromeLegacyIpc kChromeLegacyIpc{}; + template T* set_chrome_legacy_ipc() { + return BeginNestedMessage(27); + } + + + using FieldMetadata_ChromeHistogramSample = + ::protozero::proto_utils::FieldMetadata< + 28, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ChromeHistogramSample, + TrackEvent>; + + static constexpr FieldMetadata_ChromeHistogramSample kChromeHistogramSample{}; + template T* set_chrome_histogram_sample() { + return BeginNestedMessage(28); + } + + + using FieldMetadata_ChromeLatencyInfo = + ::protozero::proto_utils::FieldMetadata< + 29, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ChromeLatencyInfo, + TrackEvent>; + + static constexpr FieldMetadata_ChromeLatencyInfo kChromeLatencyInfo{}; + template T* set_chrome_latency_info() { + return BeginNestedMessage(29); + } + + + using FieldMetadata_ChromeFrameReporter = + ::protozero::proto_utils::FieldMetadata< + 32, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ChromeFrameReporter, + TrackEvent>; + + static constexpr FieldMetadata_ChromeFrameReporter kChromeFrameReporter{}; + template T* set_chrome_frame_reporter() { + return BeginNestedMessage(32); + } + + + using FieldMetadata_ChromeApplicationStateInfo = + ::protozero::proto_utils::FieldMetadata< + 39, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ChromeApplicationStateInfo, + TrackEvent>; + + static constexpr FieldMetadata_ChromeApplicationStateInfo kChromeApplicationStateInfo{}; + template T* set_chrome_application_state_info() { + return BeginNestedMessage(39); + } + + + using FieldMetadata_ChromeRendererSchedulerState = + ::protozero::proto_utils::FieldMetadata< + 40, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ChromeRendererSchedulerState, + TrackEvent>; + + static constexpr FieldMetadata_ChromeRendererSchedulerState kChromeRendererSchedulerState{}; + template T* set_chrome_renderer_scheduler_state() { + return BeginNestedMessage(40); + } + + + using FieldMetadata_ChromeWindowHandleEventInfo = + ::protozero::proto_utils::FieldMetadata< + 41, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ChromeWindowHandleEventInfo, + TrackEvent>; + + static constexpr FieldMetadata_ChromeWindowHandleEventInfo kChromeWindowHandleEventInfo{}; + template T* set_chrome_window_handle_event_info() { + return BeginNestedMessage(41); + } + + + using FieldMetadata_ChromeContentSettingsEventInfo = + ::protozero::proto_utils::FieldMetadata< + 43, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ChromeContentSettingsEventInfo, + TrackEvent>; + + static constexpr FieldMetadata_ChromeContentSettingsEventInfo kChromeContentSettingsEventInfo{}; + template T* set_chrome_content_settings_event_info() { + return BeginNestedMessage(43); + } + + + using FieldMetadata_ChromeActiveProcesses = + ::protozero::proto_utils::FieldMetadata< + 49, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ChromeActiveProcesses, + TrackEvent>; + + static constexpr FieldMetadata_ChromeActiveProcesses kChromeActiveProcesses{}; + template T* set_chrome_active_processes() { + return BeginNestedMessage(49); + } + + + using FieldMetadata_Screenshot = + ::protozero::proto_utils::FieldMetadata< + 50, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Screenshot, + TrackEvent>; + + static constexpr FieldMetadata_Screenshot kScreenshot{}; + template T* set_screenshot() { + return BeginNestedMessage(50); + } + + + using FieldMetadata_PixelModemEventInsight = + ::protozero::proto_utils::FieldMetadata< + 51, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + PixelModemEventInsight, + TrackEvent>; + + static constexpr FieldMetadata_PixelModemEventInsight kPixelModemEventInsight{}; + template T* set_pixel_modem_event_insight() { + return BeginNestedMessage(51); + } + + + using FieldMetadata_SourceLocation = + ::protozero::proto_utils::FieldMetadata< + 33, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + SourceLocation, + TrackEvent>; + + static constexpr FieldMetadata_SourceLocation kSourceLocation{}; + template T* set_source_location() { + return BeginNestedMessage(33); + } + + + using FieldMetadata_SourceLocationIid = + ::protozero::proto_utils::FieldMetadata< + 34, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TrackEvent>; + + static constexpr FieldMetadata_SourceLocationIid kSourceLocationIid{}; + void set_source_location_iid(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_SourceLocationIid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ChromeMessagePump = + ::protozero::proto_utils::FieldMetadata< + 35, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ChromeMessagePump, + TrackEvent>; + + static constexpr FieldMetadata_ChromeMessagePump kChromeMessagePump{}; + template T* set_chrome_message_pump() { + return BeginNestedMessage(35); + } + + + using FieldMetadata_ChromeMojoEventInfo = + ::protozero::proto_utils::FieldMetadata< + 38, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ChromeMojoEventInfo, + TrackEvent>; + + static constexpr FieldMetadata_ChromeMojoEventInfo kChromeMojoEventInfo{}; + template T* set_chrome_mojo_event_info() { + return BeginNestedMessage(38); + } + + + using FieldMetadata_TimestampDeltaUs = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + TrackEvent>; + + static constexpr FieldMetadata_TimestampDeltaUs kTimestampDeltaUs{}; + void set_timestamp_delta_us(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_TimestampDeltaUs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TimestampAbsoluteUs = + ::protozero::proto_utils::FieldMetadata< + 16, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + TrackEvent>; + + static constexpr FieldMetadata_TimestampAbsoluteUs kTimestampAbsoluteUs{}; + void set_timestamp_absolute_us(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_TimestampAbsoluteUs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ThreadTimeDeltaUs = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + TrackEvent>; + + static constexpr FieldMetadata_ThreadTimeDeltaUs kThreadTimeDeltaUs{}; + void set_thread_time_delta_us(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_ThreadTimeDeltaUs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ThreadTimeAbsoluteUs = + ::protozero::proto_utils::FieldMetadata< + 17, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + TrackEvent>; + + static constexpr FieldMetadata_ThreadTimeAbsoluteUs kThreadTimeAbsoluteUs{}; + void set_thread_time_absolute_us(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_ThreadTimeAbsoluteUs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ThreadInstructionCountDelta = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + TrackEvent>; + + static constexpr FieldMetadata_ThreadInstructionCountDelta kThreadInstructionCountDelta{}; + void set_thread_instruction_count_delta(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_ThreadInstructionCountDelta::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ThreadInstructionCountAbsolute = + ::protozero::proto_utils::FieldMetadata< + 20, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + TrackEvent>; + + static constexpr FieldMetadata_ThreadInstructionCountAbsolute kThreadInstructionCountAbsolute{}; + void set_thread_instruction_count_absolute(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_ThreadInstructionCountAbsolute::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_LegacyEvent = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TrackEvent_LegacyEvent, + TrackEvent>; + + static constexpr FieldMetadata_LegacyEvent kLegacyEvent{}; + template T* set_legacy_event() { + return BeginNestedMessage(6); + } + +}; + +class TrackEvent_LegacyEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + TrackEvent_LegacyEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TrackEvent_LegacyEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TrackEvent_LegacyEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_name_iid() const { return at<1>().valid(); } + uint64_t name_iid() const { return at<1>().as_uint64(); } + bool has_phase() const { return at<2>().valid(); } + int32_t phase() const { return at<2>().as_int32(); } + bool has_duration_us() const { return at<3>().valid(); } + int64_t duration_us() const { return at<3>().as_int64(); } + bool has_thread_duration_us() const { return at<4>().valid(); } + int64_t thread_duration_us() const { return at<4>().as_int64(); } + bool has_thread_instruction_delta() const { return at<15>().valid(); } + int64_t thread_instruction_delta() const { return at<15>().as_int64(); } + bool has_unscoped_id() const { return at<6>().valid(); } + uint64_t unscoped_id() const { return at<6>().as_uint64(); } + bool has_local_id() const { return at<10>().valid(); } + uint64_t local_id() const { return at<10>().as_uint64(); } + bool has_global_id() const { return at<11>().valid(); } + uint64_t global_id() const { return at<11>().as_uint64(); } + bool has_id_scope() const { return at<7>().valid(); } + ::protozero::ConstChars id_scope() const { return at<7>().as_string(); } + bool has_use_async_tts() const { return at<9>().valid(); } + bool use_async_tts() const { return at<9>().as_bool(); } + bool has_bind_id() const { return at<8>().valid(); } + uint64_t bind_id() const { return at<8>().as_uint64(); } + bool has_bind_to_enclosing() const { return at<12>().valid(); } + bool bind_to_enclosing() const { return at<12>().as_bool(); } + bool has_flow_direction() const { return at<13>().valid(); } + int32_t flow_direction() const { return at<13>().as_int32(); } + bool has_instant_event_scope() const { return at<14>().valid(); } + int32_t instant_event_scope() const { return at<14>().as_int32(); } + bool has_pid_override() const { return at<18>().valid(); } + int32_t pid_override() const { return at<18>().as_int32(); } + bool has_tid_override() const { return at<19>().valid(); } + int32_t tid_override() const { return at<19>().as_int32(); } +}; + +class TrackEvent_LegacyEvent : public ::protozero::Message { + public: + using Decoder = TrackEvent_LegacyEvent_Decoder; + enum : int32_t { + kNameIidFieldNumber = 1, + kPhaseFieldNumber = 2, + kDurationUsFieldNumber = 3, + kThreadDurationUsFieldNumber = 4, + kThreadInstructionDeltaFieldNumber = 15, + kUnscopedIdFieldNumber = 6, + kLocalIdFieldNumber = 10, + kGlobalIdFieldNumber = 11, + kIdScopeFieldNumber = 7, + kUseAsyncTtsFieldNumber = 9, + kBindIdFieldNumber = 8, + kBindToEnclosingFieldNumber = 12, + kFlowDirectionFieldNumber = 13, + kInstantEventScopeFieldNumber = 14, + kPidOverrideFieldNumber = 18, + kTidOverrideFieldNumber = 19, + }; + static constexpr const char* GetName() { return ".perfetto.protos.TrackEvent.LegacyEvent"; } + + + using FlowDirection = ::perfetto::protos::pbzero::TrackEvent_LegacyEvent_FlowDirection; + static inline const char* FlowDirection_Name(FlowDirection value) { + return ::perfetto::protos::pbzero::TrackEvent_LegacyEvent_FlowDirection_Name(value); + } + + using InstantEventScope = ::perfetto::protos::pbzero::TrackEvent_LegacyEvent_InstantEventScope; + static inline const char* InstantEventScope_Name(InstantEventScope value) { + return ::perfetto::protos::pbzero::TrackEvent_LegacyEvent_InstantEventScope_Name(value); + } + static inline const FlowDirection FLOW_UNSPECIFIED = FlowDirection::FLOW_UNSPECIFIED; + static inline const FlowDirection FLOW_IN = FlowDirection::FLOW_IN; + static inline const FlowDirection FLOW_OUT = FlowDirection::FLOW_OUT; + static inline const FlowDirection FLOW_INOUT = FlowDirection::FLOW_INOUT; + static inline const InstantEventScope SCOPE_UNSPECIFIED = InstantEventScope::SCOPE_UNSPECIFIED; + static inline const InstantEventScope SCOPE_GLOBAL = InstantEventScope::SCOPE_GLOBAL; + static inline const InstantEventScope SCOPE_PROCESS = InstantEventScope::SCOPE_PROCESS; + static inline const InstantEventScope SCOPE_THREAD = InstantEventScope::SCOPE_THREAD; + + using FieldMetadata_NameIid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TrackEvent_LegacyEvent>; + + static constexpr FieldMetadata_NameIid kNameIid{}; + void set_name_iid(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_NameIid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Phase = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + TrackEvent_LegacyEvent>; + + static constexpr FieldMetadata_Phase kPhase{}; + void set_phase(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Phase::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DurationUs = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + TrackEvent_LegacyEvent>; + + static constexpr FieldMetadata_DurationUs kDurationUs{}; + void set_duration_us(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_DurationUs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ThreadDurationUs = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + TrackEvent_LegacyEvent>; + + static constexpr FieldMetadata_ThreadDurationUs kThreadDurationUs{}; + void set_thread_duration_us(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_ThreadDurationUs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ThreadInstructionDelta = + ::protozero::proto_utils::FieldMetadata< + 15, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + TrackEvent_LegacyEvent>; + + static constexpr FieldMetadata_ThreadInstructionDelta kThreadInstructionDelta{}; + void set_thread_instruction_delta(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_ThreadInstructionDelta::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_UnscopedId = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TrackEvent_LegacyEvent>; + + static constexpr FieldMetadata_UnscopedId kUnscopedId{}; + void set_unscoped_id(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_UnscopedId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_LocalId = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TrackEvent_LegacyEvent>; + + static constexpr FieldMetadata_LocalId kLocalId{}; + void set_local_id(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_LocalId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_GlobalId = + ::protozero::proto_utils::FieldMetadata< + 11, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TrackEvent_LegacyEvent>; + + static constexpr FieldMetadata_GlobalId kGlobalId{}; + void set_global_id(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_GlobalId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_IdScope = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + TrackEvent_LegacyEvent>; + + static constexpr FieldMetadata_IdScope kIdScope{}; + void set_id_scope(const char* data, size_t size) { + AppendBytes(FieldMetadata_IdScope::kFieldId, data, size); + } + void set_id_scope(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_IdScope::kFieldId, chars.data, chars.size); + } + void set_id_scope(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_IdScope::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_UseAsyncTts = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + TrackEvent_LegacyEvent>; + + static constexpr FieldMetadata_UseAsyncTts kUseAsyncTts{}; + void set_use_async_tts(bool value) { + static constexpr uint32_t field_id = FieldMetadata_UseAsyncTts::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_BindId = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TrackEvent_LegacyEvent>; + + static constexpr FieldMetadata_BindId kBindId{}; + void set_bind_id(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_BindId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_BindToEnclosing = + ::protozero::proto_utils::FieldMetadata< + 12, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + TrackEvent_LegacyEvent>; + + static constexpr FieldMetadata_BindToEnclosing kBindToEnclosing{}; + void set_bind_to_enclosing(bool value) { + static constexpr uint32_t field_id = FieldMetadata_BindToEnclosing::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FlowDirection = + ::protozero::proto_utils::FieldMetadata< + 13, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + TrackEvent_LegacyEvent_FlowDirection, + TrackEvent_LegacyEvent>; + + static constexpr FieldMetadata_FlowDirection kFlowDirection{}; + void set_flow_direction(TrackEvent_LegacyEvent_FlowDirection value) { + static constexpr uint32_t field_id = FieldMetadata_FlowDirection::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_InstantEventScope = + ::protozero::proto_utils::FieldMetadata< + 14, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + TrackEvent_LegacyEvent_InstantEventScope, + TrackEvent_LegacyEvent>; + + static constexpr FieldMetadata_InstantEventScope kInstantEventScope{}; + void set_instant_event_scope(TrackEvent_LegacyEvent_InstantEventScope value) { + static constexpr uint32_t field_id = FieldMetadata_InstantEventScope::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PidOverride = + ::protozero::proto_utils::FieldMetadata< + 18, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + TrackEvent_LegacyEvent>; + + static constexpr FieldMetadata_PidOverride kPidOverride{}; + void set_pid_override(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_PidOverride::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TidOverride = + ::protozero::proto_utils::FieldMetadata< + 19, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + TrackEvent_LegacyEvent>; + + static constexpr FieldMetadata_TidOverride kTidOverride{}; + void set_tid_override(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TidOverride::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class TaskExecution_Decoder : public ::protozero::TypedProtoDecoder { + public: + TaskExecution_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TaskExecution_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TaskExecution_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_posted_from_iid() const { return at<1>().valid(); } + uint64_t posted_from_iid() const { return at<1>().as_uint64(); } +}; + +class TaskExecution : public ::protozero::Message { + public: + using Decoder = TaskExecution_Decoder; + enum : int32_t { + kPostedFromIidFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.TaskExecution"; } + + + using FieldMetadata_PostedFromIid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TaskExecution>; + + static constexpr FieldMetadata_PostedFromIid kPostedFromIid{}; + void set_posted_from_iid(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_PostedFromIid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class Screenshot_Decoder : public ::protozero::TypedProtoDecoder { + public: + Screenshot_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Screenshot_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Screenshot_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_jpg_image() const { return at<1>().valid(); } + ::protozero::ConstBytes jpg_image() const { return at<1>().as_bytes(); } +}; + +class Screenshot : public ::protozero::Message { + public: + using Decoder = Screenshot_Decoder; + enum : int32_t { + kJpgImageFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Screenshot"; } + + + using FieldMetadata_JpgImage = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBytes, + std::string, + Screenshot>; + + static constexpr FieldMetadata_JpgImage kJpgImage{}; + void set_jpg_image(const uint8_t* data, size_t size) { + AppendBytes(FieldMetadata_JpgImage::kFieldId, data, size); + } + void set_jpg_image(::protozero::ConstBytes bytes) { + AppendBytes(FieldMetadata_JpgImage::kFieldId, bytes.data, bytes.size); + } + void set_jpg_image(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_JpgImage::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBytes> + ::Append(*this, field_id, value); + } +}; + +class PixelModemEventInsight_Decoder : public ::protozero::TypedProtoDecoder { + public: + PixelModemEventInsight_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit PixelModemEventInsight_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit PixelModemEventInsight_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_detokenized_message() const { return at<1>().valid(); } + ::protozero::ConstChars detokenized_message() const { return at<1>().as_string(); } +}; + +class PixelModemEventInsight : public ::protozero::Message { + public: + using Decoder = PixelModemEventInsight_Decoder; + enum : int32_t { + kDetokenizedMessageFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.PixelModemEventInsight"; } + + + using FieldMetadata_DetokenizedMessage = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + PixelModemEventInsight>; + + static constexpr FieldMetadata_DetokenizedMessage kDetokenizedMessage{}; + void set_detokenized_message(const char* data, size_t size) { + AppendBytes(FieldMetadata_DetokenizedMessage::kFieldId, data, size); + } + void set_detokenized_message(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_DetokenizedMessage::kFieldId, chars.data, chars.size); + } + void set_detokenized_message(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_DetokenizedMessage::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class ChromeWindowHandleEventInfo_Decoder : public ::protozero::TypedProtoDecoder { + public: + ChromeWindowHandleEventInfo_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ChromeWindowHandleEventInfo_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ChromeWindowHandleEventInfo_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dpi() const { return at<1>().valid(); } + uint32_t dpi() const { return at<1>().as_uint32(); } + bool has_message_id() const { return at<2>().valid(); } + uint32_t message_id() const { return at<2>().as_uint32(); } + bool has_hwnd_ptr() const { return at<3>().valid(); } + uint64_t hwnd_ptr() const { return at<3>().as_uint64(); } +}; + +class ChromeWindowHandleEventInfo : public ::protozero::Message { + public: + using Decoder = ChromeWindowHandleEventInfo_Decoder; + enum : int32_t { + kDpiFieldNumber = 1, + kMessageIdFieldNumber = 2, + kHwndPtrFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ChromeWindowHandleEventInfo"; } + + + using FieldMetadata_Dpi = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + ChromeWindowHandleEventInfo>; + + static constexpr FieldMetadata_Dpi kDpi{}; + void set_dpi(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dpi::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_MessageId = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + ChromeWindowHandleEventInfo>; + + static constexpr FieldMetadata_MessageId kMessageId{}; + void set_message_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_MessageId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_HwndPtr = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFixed64, + uint64_t, + ChromeWindowHandleEventInfo>; + + static constexpr FieldMetadata_HwndPtr kHwndPtr{}; + void set_hwnd_ptr(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_HwndPtr::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFixed64> + ::Append(*this, field_id, value); + } +}; + +class ChromeUserEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + ChromeUserEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ChromeUserEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ChromeUserEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_action() const { return at<1>().valid(); } + ::protozero::ConstChars action() const { return at<1>().as_string(); } + bool has_action_hash() const { return at<2>().valid(); } + uint64_t action_hash() const { return at<2>().as_uint64(); } +}; + +class ChromeUserEvent : public ::protozero::Message { + public: + using Decoder = ChromeUserEvent_Decoder; + enum : int32_t { + kActionFieldNumber = 1, + kActionHashFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ChromeUserEvent"; } + + + using FieldMetadata_Action = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + ChromeUserEvent>; + + static constexpr FieldMetadata_Action kAction{}; + void set_action(const char* data, size_t size) { + AppendBytes(FieldMetadata_Action::kFieldId, data, size); + } + void set_action(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Action::kFieldId, chars.data, chars.size); + } + void set_action(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Action::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ActionHash = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + ChromeUserEvent>; + + static constexpr FieldMetadata_ActionHash kActionHash{}; + void set_action_hash(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_ActionHash::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class ChromeRendererSchedulerState_Decoder : public ::protozero::TypedProtoDecoder { + public: + ChromeRendererSchedulerState_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ChromeRendererSchedulerState_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ChromeRendererSchedulerState_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_rail_mode() const { return at<1>().valid(); } + int32_t rail_mode() const { return at<1>().as_int32(); } + bool has_is_backgrounded() const { return at<2>().valid(); } + bool is_backgrounded() const { return at<2>().as_bool(); } + bool has_is_hidden() const { return at<3>().valid(); } + bool is_hidden() const { return at<3>().as_bool(); } +}; + +class ChromeRendererSchedulerState : public ::protozero::Message { + public: + using Decoder = ChromeRendererSchedulerState_Decoder; + enum : int32_t { + kRailModeFieldNumber = 1, + kIsBackgroundedFieldNumber = 2, + kIsHiddenFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ChromeRendererSchedulerState"; } + + + using FieldMetadata_RailMode = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + ChromeRAILMode, + ChromeRendererSchedulerState>; + + static constexpr FieldMetadata_RailMode kRailMode{}; + void set_rail_mode(ChromeRAILMode value) { + static constexpr uint32_t field_id = FieldMetadata_RailMode::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_IsBackgrounded = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + ChromeRendererSchedulerState>; + + static constexpr FieldMetadata_IsBackgrounded kIsBackgrounded{}; + void set_is_backgrounded(bool value) { + static constexpr uint32_t field_id = FieldMetadata_IsBackgrounded::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_IsHidden = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + ChromeRendererSchedulerState>; + + static constexpr FieldMetadata_IsHidden kIsHidden{}; + void set_is_hidden(bool value) { + static constexpr uint32_t field_id = FieldMetadata_IsHidden::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } +}; + +class ChromeMojoEventInfo_Decoder : public ::protozero::TypedProtoDecoder { + public: + ChromeMojoEventInfo_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ChromeMojoEventInfo_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ChromeMojoEventInfo_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_watcher_notify_interface_tag() const { return at<1>().valid(); } + ::protozero::ConstChars watcher_notify_interface_tag() const { return at<1>().as_string(); } + bool has_ipc_hash() const { return at<2>().valid(); } + uint32_t ipc_hash() const { return at<2>().as_uint32(); } + bool has_mojo_interface_tag() const { return at<3>().valid(); } + ::protozero::ConstChars mojo_interface_tag() const { return at<3>().as_string(); } + bool has_mojo_interface_method_iid() const { return at<4>().valid(); } + uint64_t mojo_interface_method_iid() const { return at<4>().as_uint64(); } + bool has_is_reply() const { return at<5>().valid(); } + bool is_reply() const { return at<5>().as_bool(); } + bool has_payload_size() const { return at<6>().valid(); } + uint64_t payload_size() const { return at<6>().as_uint64(); } + bool has_data_num_bytes() const { return at<7>().valid(); } + uint64_t data_num_bytes() const { return at<7>().as_uint64(); } +}; + +class ChromeMojoEventInfo : public ::protozero::Message { + public: + using Decoder = ChromeMojoEventInfo_Decoder; + enum : int32_t { + kWatcherNotifyInterfaceTagFieldNumber = 1, + kIpcHashFieldNumber = 2, + kMojoInterfaceTagFieldNumber = 3, + kMojoInterfaceMethodIidFieldNumber = 4, + kIsReplyFieldNumber = 5, + kPayloadSizeFieldNumber = 6, + kDataNumBytesFieldNumber = 7, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ChromeMojoEventInfo"; } + + + using FieldMetadata_WatcherNotifyInterfaceTag = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + ChromeMojoEventInfo>; + + static constexpr FieldMetadata_WatcherNotifyInterfaceTag kWatcherNotifyInterfaceTag{}; + void set_watcher_notify_interface_tag(const char* data, size_t size) { + AppendBytes(FieldMetadata_WatcherNotifyInterfaceTag::kFieldId, data, size); + } + void set_watcher_notify_interface_tag(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_WatcherNotifyInterfaceTag::kFieldId, chars.data, chars.size); + } + void set_watcher_notify_interface_tag(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_WatcherNotifyInterfaceTag::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_IpcHash = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + ChromeMojoEventInfo>; + + static constexpr FieldMetadata_IpcHash kIpcHash{}; + void set_ipc_hash(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_IpcHash::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_MojoInterfaceTag = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + ChromeMojoEventInfo>; + + static constexpr FieldMetadata_MojoInterfaceTag kMojoInterfaceTag{}; + void set_mojo_interface_tag(const char* data, size_t size) { + AppendBytes(FieldMetadata_MojoInterfaceTag::kFieldId, data, size); + } + void set_mojo_interface_tag(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_MojoInterfaceTag::kFieldId, chars.data, chars.size); + } + void set_mojo_interface_tag(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_MojoInterfaceTag::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_MojoInterfaceMethodIid = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + ChromeMojoEventInfo>; + + static constexpr FieldMetadata_MojoInterfaceMethodIid kMojoInterfaceMethodIid{}; + void set_mojo_interface_method_iid(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_MojoInterfaceMethodIid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_IsReply = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + ChromeMojoEventInfo>; + + static constexpr FieldMetadata_IsReply kIsReply{}; + void set_is_reply(bool value) { + static constexpr uint32_t field_id = FieldMetadata_IsReply::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PayloadSize = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + ChromeMojoEventInfo>; + + static constexpr FieldMetadata_PayloadSize kPayloadSize{}; + void set_payload_size(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_PayloadSize::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DataNumBytes = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + ChromeMojoEventInfo>; + + static constexpr FieldMetadata_DataNumBytes kDataNumBytes{}; + void set_data_num_bytes(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_DataNumBytes::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class ChromeMessagePump_Decoder : public ::protozero::TypedProtoDecoder { + public: + ChromeMessagePump_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ChromeMessagePump_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ChromeMessagePump_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_sent_messages_in_queue() const { return at<1>().valid(); } + bool sent_messages_in_queue() const { return at<1>().as_bool(); } + bool has_io_handler_location_iid() const { return at<2>().valid(); } + uint64_t io_handler_location_iid() const { return at<2>().as_uint64(); } +}; + +class ChromeMessagePump : public ::protozero::Message { + public: + using Decoder = ChromeMessagePump_Decoder; + enum : int32_t { + kSentMessagesInQueueFieldNumber = 1, + kIoHandlerLocationIidFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ChromeMessagePump"; } + + + using FieldMetadata_SentMessagesInQueue = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + ChromeMessagePump>; + + static constexpr FieldMetadata_SentMessagesInQueue kSentMessagesInQueue{}; + void set_sent_messages_in_queue(bool value) { + static constexpr uint32_t field_id = FieldMetadata_SentMessagesInQueue::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_IoHandlerLocationIid = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + ChromeMessagePump>; + + static constexpr FieldMetadata_IoHandlerLocationIid kIoHandlerLocationIid{}; + void set_io_handler_location_iid(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_IoHandlerLocationIid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class ChromeLegacyIpc_Decoder : public ::protozero::TypedProtoDecoder { + public: + ChromeLegacyIpc_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ChromeLegacyIpc_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ChromeLegacyIpc_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_message_class() const { return at<1>().valid(); } + int32_t message_class() const { return at<1>().as_int32(); } + bool has_message_line() const { return at<2>().valid(); } + uint32_t message_line() const { return at<2>().as_uint32(); } +}; + +class ChromeLegacyIpc : public ::protozero::Message { + public: + using Decoder = ChromeLegacyIpc_Decoder; + enum : int32_t { + kMessageClassFieldNumber = 1, + kMessageLineFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ChromeLegacyIpc"; } + + + using MessageClass = ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass; + static inline const char* MessageClass_Name(MessageClass value) { + return ::perfetto::protos::pbzero::ChromeLegacyIpc_MessageClass_Name(value); + } + static inline const MessageClass CLASS_UNSPECIFIED = MessageClass::CLASS_UNSPECIFIED; + static inline const MessageClass CLASS_AUTOMATION = MessageClass::CLASS_AUTOMATION; + static inline const MessageClass CLASS_FRAME = MessageClass::CLASS_FRAME; + static inline const MessageClass CLASS_PAGE = MessageClass::CLASS_PAGE; + static inline const MessageClass CLASS_VIEW = MessageClass::CLASS_VIEW; + static inline const MessageClass CLASS_WIDGET = MessageClass::CLASS_WIDGET; + static inline const MessageClass CLASS_INPUT = MessageClass::CLASS_INPUT; + static inline const MessageClass CLASS_TEST = MessageClass::CLASS_TEST; + static inline const MessageClass CLASS_WORKER = MessageClass::CLASS_WORKER; + static inline const MessageClass CLASS_NACL = MessageClass::CLASS_NACL; + static inline const MessageClass CLASS_GPU_CHANNEL = MessageClass::CLASS_GPU_CHANNEL; + static inline const MessageClass CLASS_MEDIA = MessageClass::CLASS_MEDIA; + static inline const MessageClass CLASS_PPAPI = MessageClass::CLASS_PPAPI; + static inline const MessageClass CLASS_CHROME = MessageClass::CLASS_CHROME; + static inline const MessageClass CLASS_DRAG = MessageClass::CLASS_DRAG; + static inline const MessageClass CLASS_PRINT = MessageClass::CLASS_PRINT; + static inline const MessageClass CLASS_EXTENSION = MessageClass::CLASS_EXTENSION; + static inline const MessageClass CLASS_TEXT_INPUT_CLIENT = MessageClass::CLASS_TEXT_INPUT_CLIENT; + static inline const MessageClass CLASS_BLINK_TEST = MessageClass::CLASS_BLINK_TEST; + static inline const MessageClass CLASS_ACCESSIBILITY = MessageClass::CLASS_ACCESSIBILITY; + static inline const MessageClass CLASS_PRERENDER = MessageClass::CLASS_PRERENDER; + static inline const MessageClass CLASS_CHROMOTING = MessageClass::CLASS_CHROMOTING; + static inline const MessageClass CLASS_BROWSER_PLUGIN = MessageClass::CLASS_BROWSER_PLUGIN; + static inline const MessageClass CLASS_ANDROID_WEB_VIEW = MessageClass::CLASS_ANDROID_WEB_VIEW; + static inline const MessageClass CLASS_NACL_HOST = MessageClass::CLASS_NACL_HOST; + static inline const MessageClass CLASS_ENCRYPTED_MEDIA = MessageClass::CLASS_ENCRYPTED_MEDIA; + static inline const MessageClass CLASS_CAST = MessageClass::CLASS_CAST; + static inline const MessageClass CLASS_GIN_JAVA_BRIDGE = MessageClass::CLASS_GIN_JAVA_BRIDGE; + static inline const MessageClass CLASS_CHROME_UTILITY_PRINTING = MessageClass::CLASS_CHROME_UTILITY_PRINTING; + static inline const MessageClass CLASS_OZONE_GPU = MessageClass::CLASS_OZONE_GPU; + static inline const MessageClass CLASS_WEB_TEST = MessageClass::CLASS_WEB_TEST; + static inline const MessageClass CLASS_NETWORK_HINTS = MessageClass::CLASS_NETWORK_HINTS; + static inline const MessageClass CLASS_EXTENSIONS_GUEST_VIEW = MessageClass::CLASS_EXTENSIONS_GUEST_VIEW; + static inline const MessageClass CLASS_GUEST_VIEW = MessageClass::CLASS_GUEST_VIEW; + static inline const MessageClass CLASS_MEDIA_PLAYER_DELEGATE = MessageClass::CLASS_MEDIA_PLAYER_DELEGATE; + static inline const MessageClass CLASS_EXTENSION_WORKER = MessageClass::CLASS_EXTENSION_WORKER; + static inline const MessageClass CLASS_SUBRESOURCE_FILTER = MessageClass::CLASS_SUBRESOURCE_FILTER; + static inline const MessageClass CLASS_UNFREEZABLE_FRAME = MessageClass::CLASS_UNFREEZABLE_FRAME; + + using FieldMetadata_MessageClass = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + ChromeLegacyIpc_MessageClass, + ChromeLegacyIpc>; + + static constexpr FieldMetadata_MessageClass kMessageClass{}; + void set_message_class(ChromeLegacyIpc_MessageClass value) { + static constexpr uint32_t field_id = FieldMetadata_MessageClass::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_MessageLine = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + ChromeLegacyIpc>; + + static constexpr FieldMetadata_MessageLine kMessageLine{}; + void set_message_line(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_MessageLine::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class ChromeLatencyInfo_Decoder : public ::protozero::TypedProtoDecoder { + public: + ChromeLatencyInfo_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ChromeLatencyInfo_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ChromeLatencyInfo_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_trace_id() const { return at<1>().valid(); } + int64_t trace_id() const { return at<1>().as_int64(); } + bool has_step() const { return at<2>().valid(); } + int32_t step() const { return at<2>().as_int32(); } + bool has_frame_tree_node_id() const { return at<3>().valid(); } + int32_t frame_tree_node_id() const { return at<3>().as_int32(); } + bool has_component_info() const { return at<4>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> component_info() const { return GetRepeated<::protozero::ConstBytes>(4); } + bool has_is_coalesced() const { return at<5>().valid(); } + bool is_coalesced() const { return at<5>().as_bool(); } + bool has_gesture_scroll_id() const { return at<6>().valid(); } + int64_t gesture_scroll_id() const { return at<6>().as_int64(); } + bool has_touch_id() const { return at<7>().valid(); } + int64_t touch_id() const { return at<7>().as_int64(); } +}; + +class ChromeLatencyInfo : public ::protozero::Message { + public: + using Decoder = ChromeLatencyInfo_Decoder; + enum : int32_t { + kTraceIdFieldNumber = 1, + kStepFieldNumber = 2, + kFrameTreeNodeIdFieldNumber = 3, + kComponentInfoFieldNumber = 4, + kIsCoalescedFieldNumber = 5, + kGestureScrollIdFieldNumber = 6, + kTouchIdFieldNumber = 7, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ChromeLatencyInfo"; } + + using ComponentInfo = ::perfetto::protos::pbzero::ChromeLatencyInfo_ComponentInfo; + + using Step = ::perfetto::protos::pbzero::ChromeLatencyInfo_Step; + static inline const char* Step_Name(Step value) { + return ::perfetto::protos::pbzero::ChromeLatencyInfo_Step_Name(value); + } + + using LatencyComponentType = ::perfetto::protos::pbzero::ChromeLatencyInfo_LatencyComponentType; + static inline const char* LatencyComponentType_Name(LatencyComponentType value) { + return ::perfetto::protos::pbzero::ChromeLatencyInfo_LatencyComponentType_Name(value); + } + static inline const Step STEP_UNSPECIFIED = Step::STEP_UNSPECIFIED; + static inline const Step STEP_SEND_INPUT_EVENT_UI = Step::STEP_SEND_INPUT_EVENT_UI; + static inline const Step STEP_HANDLE_INPUT_EVENT_IMPL = Step::STEP_HANDLE_INPUT_EVENT_IMPL; + static inline const Step STEP_DID_HANDLE_INPUT_AND_OVERSCROLL = Step::STEP_DID_HANDLE_INPUT_AND_OVERSCROLL; + static inline const Step STEP_HANDLE_INPUT_EVENT_MAIN = Step::STEP_HANDLE_INPUT_EVENT_MAIN; + static inline const Step STEP_MAIN_THREAD_SCROLL_UPDATE = Step::STEP_MAIN_THREAD_SCROLL_UPDATE; + static inline const Step STEP_HANDLE_INPUT_EVENT_MAIN_COMMIT = Step::STEP_HANDLE_INPUT_EVENT_MAIN_COMMIT; + static inline const Step STEP_HANDLED_INPUT_EVENT_MAIN_OR_IMPL = Step::STEP_HANDLED_INPUT_EVENT_MAIN_OR_IMPL; + static inline const Step STEP_HANDLED_INPUT_EVENT_IMPL = Step::STEP_HANDLED_INPUT_EVENT_IMPL; + static inline const Step STEP_SWAP_BUFFERS = Step::STEP_SWAP_BUFFERS; + static inline const Step STEP_DRAW_AND_SWAP = Step::STEP_DRAW_AND_SWAP; + static inline const Step STEP_FINISHED_SWAP_BUFFERS = Step::STEP_FINISHED_SWAP_BUFFERS; + static inline const LatencyComponentType COMPONENT_UNSPECIFIED = LatencyComponentType::COMPONENT_UNSPECIFIED; + static inline const LatencyComponentType COMPONENT_INPUT_EVENT_LATENCY_BEGIN_RWH = LatencyComponentType::COMPONENT_INPUT_EVENT_LATENCY_BEGIN_RWH; + static inline const LatencyComponentType COMPONENT_INPUT_EVENT_LATENCY_SCROLL_UPDATE_ORIGINAL = LatencyComponentType::COMPONENT_INPUT_EVENT_LATENCY_SCROLL_UPDATE_ORIGINAL; + static inline const LatencyComponentType COMPONENT_INPUT_EVENT_LATENCY_FIRST_SCROLL_UPDATE_ORIGINAL = LatencyComponentType::COMPONENT_INPUT_EVENT_LATENCY_FIRST_SCROLL_UPDATE_ORIGINAL; + static inline const LatencyComponentType COMPONENT_INPUT_EVENT_LATENCY_ORIGINAL = LatencyComponentType::COMPONENT_INPUT_EVENT_LATENCY_ORIGINAL; + static inline const LatencyComponentType COMPONENT_INPUT_EVENT_LATENCY_UI = LatencyComponentType::COMPONENT_INPUT_EVENT_LATENCY_UI; + static inline const LatencyComponentType COMPONENT_INPUT_EVENT_LATENCY_RENDERER_MAIN = LatencyComponentType::COMPONENT_INPUT_EVENT_LATENCY_RENDERER_MAIN; + static inline const LatencyComponentType COMPONENT_INPUT_EVENT_LATENCY_RENDERING_SCHEDULED_MAIN = LatencyComponentType::COMPONENT_INPUT_EVENT_LATENCY_RENDERING_SCHEDULED_MAIN; + static inline const LatencyComponentType COMPONENT_INPUT_EVENT_LATENCY_RENDERING_SCHEDULED_IMPL = LatencyComponentType::COMPONENT_INPUT_EVENT_LATENCY_RENDERING_SCHEDULED_IMPL; + static inline const LatencyComponentType COMPONENT_INPUT_EVENT_LATENCY_SCROLL_UPDATE_LAST_EVENT = LatencyComponentType::COMPONENT_INPUT_EVENT_LATENCY_SCROLL_UPDATE_LAST_EVENT; + static inline const LatencyComponentType COMPONENT_INPUT_EVENT_LATENCY_ACK_RWH = LatencyComponentType::COMPONENT_INPUT_EVENT_LATENCY_ACK_RWH; + static inline const LatencyComponentType COMPONENT_INPUT_EVENT_LATENCY_RENDERER_SWAP = LatencyComponentType::COMPONENT_INPUT_EVENT_LATENCY_RENDERER_SWAP; + static inline const LatencyComponentType COMPONENT_DISPLAY_COMPOSITOR_RECEIVED_FRAME = LatencyComponentType::COMPONENT_DISPLAY_COMPOSITOR_RECEIVED_FRAME; + static inline const LatencyComponentType COMPONENT_INPUT_EVENT_GPU_SWAP_BUFFER = LatencyComponentType::COMPONENT_INPUT_EVENT_GPU_SWAP_BUFFER; + static inline const LatencyComponentType COMPONENT_INPUT_EVENT_LATENCY_FRAME_SWAP = LatencyComponentType::COMPONENT_INPUT_EVENT_LATENCY_FRAME_SWAP; + + using FieldMetadata_TraceId = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + ChromeLatencyInfo>; + + static constexpr FieldMetadata_TraceId kTraceId{}; + void set_trace_id(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_TraceId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Step = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + ChromeLatencyInfo_Step, + ChromeLatencyInfo>; + + static constexpr FieldMetadata_Step kStep{}; + void set_step(ChromeLatencyInfo_Step value) { + static constexpr uint32_t field_id = FieldMetadata_Step::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FrameTreeNodeId = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + ChromeLatencyInfo>; + + static constexpr FieldMetadata_FrameTreeNodeId kFrameTreeNodeId{}; + void set_frame_tree_node_id(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_FrameTreeNodeId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ComponentInfo = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ChromeLatencyInfo_ComponentInfo, + ChromeLatencyInfo>; + + static constexpr FieldMetadata_ComponentInfo kComponentInfo{}; + template T* add_component_info() { + return BeginNestedMessage(4); + } + + + using FieldMetadata_IsCoalesced = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + ChromeLatencyInfo>; + + static constexpr FieldMetadata_IsCoalesced kIsCoalesced{}; + void set_is_coalesced(bool value) { + static constexpr uint32_t field_id = FieldMetadata_IsCoalesced::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_GestureScrollId = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + ChromeLatencyInfo>; + + static constexpr FieldMetadata_GestureScrollId kGestureScrollId{}; + void set_gesture_scroll_id(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_GestureScrollId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TouchId = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + ChromeLatencyInfo>; + + static constexpr FieldMetadata_TouchId kTouchId{}; + void set_touch_id(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_TouchId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } +}; + +class ChromeLatencyInfo_ComponentInfo_Decoder : public ::protozero::TypedProtoDecoder { + public: + ChromeLatencyInfo_ComponentInfo_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ChromeLatencyInfo_ComponentInfo_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ChromeLatencyInfo_ComponentInfo_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_component_type() const { return at<1>().valid(); } + int32_t component_type() const { return at<1>().as_int32(); } + bool has_time_us() const { return at<2>().valid(); } + uint64_t time_us() const { return at<2>().as_uint64(); } +}; + +class ChromeLatencyInfo_ComponentInfo : public ::protozero::Message { + public: + using Decoder = ChromeLatencyInfo_ComponentInfo_Decoder; + enum : int32_t { + kComponentTypeFieldNumber = 1, + kTimeUsFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ChromeLatencyInfo.ComponentInfo"; } + + + using FieldMetadata_ComponentType = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + ChromeLatencyInfo_LatencyComponentType, + ChromeLatencyInfo_ComponentInfo>; + + static constexpr FieldMetadata_ComponentType kComponentType{}; + void set_component_type(ChromeLatencyInfo_LatencyComponentType value) { + static constexpr uint32_t field_id = FieldMetadata_ComponentType::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TimeUs = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + ChromeLatencyInfo_ComponentInfo>; + + static constexpr FieldMetadata_TimeUs kTimeUs{}; + void set_time_us(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_TimeUs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class ChromeKeyedService_Decoder : public ::protozero::TypedProtoDecoder { + public: + ChromeKeyedService_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ChromeKeyedService_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ChromeKeyedService_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_name() const { return at<1>().valid(); } + ::protozero::ConstChars name() const { return at<1>().as_string(); } +}; + +class ChromeKeyedService : public ::protozero::Message { + public: + using Decoder = ChromeKeyedService_Decoder; + enum : int32_t { + kNameFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ChromeKeyedService"; } + + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + ChromeKeyedService>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class ChromeFrameReporter_Decoder : public ::protozero::TypedProtoDecoder { + public: + ChromeFrameReporter_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ChromeFrameReporter_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ChromeFrameReporter_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_state() const { return at<1>().valid(); } + int32_t state() const { return at<1>().as_int32(); } + bool has_reason() const { return at<2>().valid(); } + int32_t reason() const { return at<2>().as_int32(); } + bool has_frame_source() const { return at<3>().valid(); } + uint64_t frame_source() const { return at<3>().as_uint64(); } + bool has_frame_sequence() const { return at<4>().valid(); } + uint64_t frame_sequence() const { return at<4>().as_uint64(); } + bool has_affects_smoothness() const { return at<5>().valid(); } + bool affects_smoothness() const { return at<5>().as_bool(); } + bool has_scroll_state() const { return at<6>().valid(); } + int32_t scroll_state() const { return at<6>().as_int32(); } + bool has_has_main_animation() const { return at<7>().valid(); } + bool has_main_animation() const { return at<7>().as_bool(); } + bool has_has_compositor_animation() const { return at<8>().valid(); } + bool has_compositor_animation() const { return at<8>().as_bool(); } + bool has_has_smooth_input_main() const { return at<9>().valid(); } + bool has_smooth_input_main() const { return at<9>().as_bool(); } + bool has_has_missing_content() const { return at<10>().valid(); } + bool has_missing_content() const { return at<10>().as_bool(); } + bool has_layer_tree_host_id() const { return at<11>().valid(); } + uint64_t layer_tree_host_id() const { return at<11>().as_uint64(); } + bool has_has_high_latency() const { return at<12>().valid(); } + bool has_high_latency() const { return at<12>().as_bool(); } + bool has_frame_type() const { return at<13>().valid(); } + int32_t frame_type() const { return at<13>().as_int32(); } + bool has_high_latency_contribution_stage() const { return at<14>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstChars> high_latency_contribution_stage() const { return GetRepeated<::protozero::ConstChars>(14); } +}; + +class ChromeFrameReporter : public ::protozero::Message { + public: + using Decoder = ChromeFrameReporter_Decoder; + enum : int32_t { + kStateFieldNumber = 1, + kReasonFieldNumber = 2, + kFrameSourceFieldNumber = 3, + kFrameSequenceFieldNumber = 4, + kAffectsSmoothnessFieldNumber = 5, + kScrollStateFieldNumber = 6, + kHasMainAnimationFieldNumber = 7, + kHasCompositorAnimationFieldNumber = 8, + kHasSmoothInputMainFieldNumber = 9, + kHasMissingContentFieldNumber = 10, + kLayerTreeHostIdFieldNumber = 11, + kHasHighLatencyFieldNumber = 12, + kFrameTypeFieldNumber = 13, + kHighLatencyContributionStageFieldNumber = 14, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ChromeFrameReporter"; } + + + using State = ::perfetto::protos::pbzero::ChromeFrameReporter_State; + static inline const char* State_Name(State value) { + return ::perfetto::protos::pbzero::ChromeFrameReporter_State_Name(value); + } + + using FrameDropReason = ::perfetto::protos::pbzero::ChromeFrameReporter_FrameDropReason; + static inline const char* FrameDropReason_Name(FrameDropReason value) { + return ::perfetto::protos::pbzero::ChromeFrameReporter_FrameDropReason_Name(value); + } + + using ScrollState = ::perfetto::protos::pbzero::ChromeFrameReporter_ScrollState; + static inline const char* ScrollState_Name(ScrollState value) { + return ::perfetto::protos::pbzero::ChromeFrameReporter_ScrollState_Name(value); + } + + using FrameType = ::perfetto::protos::pbzero::ChromeFrameReporter_FrameType; + static inline const char* FrameType_Name(FrameType value) { + return ::perfetto::protos::pbzero::ChromeFrameReporter_FrameType_Name(value); + } + static inline const State STATE_NO_UPDATE_DESIRED = State::STATE_NO_UPDATE_DESIRED; + static inline const State STATE_PRESENTED_ALL = State::STATE_PRESENTED_ALL; + static inline const State STATE_PRESENTED_PARTIAL = State::STATE_PRESENTED_PARTIAL; + static inline const State STATE_DROPPED = State::STATE_DROPPED; + static inline const FrameDropReason REASON_UNSPECIFIED = FrameDropReason::REASON_UNSPECIFIED; + static inline const FrameDropReason REASON_DISPLAY_COMPOSITOR = FrameDropReason::REASON_DISPLAY_COMPOSITOR; + static inline const FrameDropReason REASON_MAIN_THREAD = FrameDropReason::REASON_MAIN_THREAD; + static inline const FrameDropReason REASON_CLIENT_COMPOSITOR = FrameDropReason::REASON_CLIENT_COMPOSITOR; + static inline const ScrollState SCROLL_NONE = ScrollState::SCROLL_NONE; + static inline const ScrollState SCROLL_MAIN_THREAD = ScrollState::SCROLL_MAIN_THREAD; + static inline const ScrollState SCROLL_COMPOSITOR_THREAD = ScrollState::SCROLL_COMPOSITOR_THREAD; + static inline const ScrollState SCROLL_UNKNOWN = ScrollState::SCROLL_UNKNOWN; + static inline const FrameType FORKED = FrameType::FORKED; + static inline const FrameType BACKFILL = FrameType::BACKFILL; + + using FieldMetadata_State = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + ChromeFrameReporter_State, + ChromeFrameReporter>; + + static constexpr FieldMetadata_State kState{}; + void set_state(ChromeFrameReporter_State value) { + static constexpr uint32_t field_id = FieldMetadata_State::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Reason = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + ChromeFrameReporter_FrameDropReason, + ChromeFrameReporter>; + + static constexpr FieldMetadata_Reason kReason{}; + void set_reason(ChromeFrameReporter_FrameDropReason value) { + static constexpr uint32_t field_id = FieldMetadata_Reason::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FrameSource = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + ChromeFrameReporter>; + + static constexpr FieldMetadata_FrameSource kFrameSource{}; + void set_frame_source(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_FrameSource::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FrameSequence = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + ChromeFrameReporter>; + + static constexpr FieldMetadata_FrameSequence kFrameSequence{}; + void set_frame_sequence(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_FrameSequence::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_AffectsSmoothness = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + ChromeFrameReporter>; + + static constexpr FieldMetadata_AffectsSmoothness kAffectsSmoothness{}; + void set_affects_smoothness(bool value) { + static constexpr uint32_t field_id = FieldMetadata_AffectsSmoothness::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ScrollState = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + ChromeFrameReporter_ScrollState, + ChromeFrameReporter>; + + static constexpr FieldMetadata_ScrollState kScrollState{}; + void set_scroll_state(ChromeFrameReporter_ScrollState value) { + static constexpr uint32_t field_id = FieldMetadata_ScrollState::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_HasMainAnimation = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + ChromeFrameReporter>; + + static constexpr FieldMetadata_HasMainAnimation kHasMainAnimation{}; + void set_has_main_animation(bool value) { + static constexpr uint32_t field_id = FieldMetadata_HasMainAnimation::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_HasCompositorAnimation = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + ChromeFrameReporter>; + + static constexpr FieldMetadata_HasCompositorAnimation kHasCompositorAnimation{}; + void set_has_compositor_animation(bool value) { + static constexpr uint32_t field_id = FieldMetadata_HasCompositorAnimation::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_HasSmoothInputMain = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + ChromeFrameReporter>; + + static constexpr FieldMetadata_HasSmoothInputMain kHasSmoothInputMain{}; + void set_has_smooth_input_main(bool value) { + static constexpr uint32_t field_id = FieldMetadata_HasSmoothInputMain::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_HasMissingContent = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + ChromeFrameReporter>; + + static constexpr FieldMetadata_HasMissingContent kHasMissingContent{}; + void set_has_missing_content(bool value) { + static constexpr uint32_t field_id = FieldMetadata_HasMissingContent::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_LayerTreeHostId = + ::protozero::proto_utils::FieldMetadata< + 11, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + ChromeFrameReporter>; + + static constexpr FieldMetadata_LayerTreeHostId kLayerTreeHostId{}; + void set_layer_tree_host_id(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_LayerTreeHostId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_HasHighLatency = + ::protozero::proto_utils::FieldMetadata< + 12, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + ChromeFrameReporter>; + + static constexpr FieldMetadata_HasHighLatency kHasHighLatency{}; + void set_has_high_latency(bool value) { + static constexpr uint32_t field_id = FieldMetadata_HasHighLatency::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FrameType = + ::protozero::proto_utils::FieldMetadata< + 13, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + ChromeFrameReporter_FrameType, + ChromeFrameReporter>; + + static constexpr FieldMetadata_FrameType kFrameType{}; + void set_frame_type(ChromeFrameReporter_FrameType value) { + static constexpr uint32_t field_id = FieldMetadata_FrameType::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_HighLatencyContributionStage = + ::protozero::proto_utils::FieldMetadata< + 14, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + ChromeFrameReporter>; + + static constexpr FieldMetadata_HighLatencyContributionStage kHighLatencyContributionStage{}; + void add_high_latency_contribution_stage(const char* data, size_t size) { + AppendBytes(FieldMetadata_HighLatencyContributionStage::kFieldId, data, size); + } + void add_high_latency_contribution_stage(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_HighLatencyContributionStage::kFieldId, chars.data, chars.size); + } + void add_high_latency_contribution_stage(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_HighLatencyContributionStage::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class ChromeContentSettingsEventInfo_Decoder : public ::protozero::TypedProtoDecoder { + public: + ChromeContentSettingsEventInfo_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ChromeContentSettingsEventInfo_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ChromeContentSettingsEventInfo_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_number_of_exceptions() const { return at<1>().valid(); } + uint32_t number_of_exceptions() const { return at<1>().as_uint32(); } +}; + +class ChromeContentSettingsEventInfo : public ::protozero::Message { + public: + using Decoder = ChromeContentSettingsEventInfo_Decoder; + enum : int32_t { + kNumberOfExceptionsFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ChromeContentSettingsEventInfo"; } + + + using FieldMetadata_NumberOfExceptions = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + ChromeContentSettingsEventInfo>; + + static constexpr FieldMetadata_NumberOfExceptions kNumberOfExceptions{}; + void set_number_of_exceptions(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_NumberOfExceptions::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class CompositorTimingHistory_Decoder : public ::protozero::TypedProtoDecoder { + public: + CompositorTimingHistory_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit CompositorTimingHistory_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit CompositorTimingHistory_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_begin_main_frame_queue_critical_estimate_delta_us() const { return at<1>().valid(); } + int64_t begin_main_frame_queue_critical_estimate_delta_us() const { return at<1>().as_int64(); } + bool has_begin_main_frame_queue_not_critical_estimate_delta_us() const { return at<2>().valid(); } + int64_t begin_main_frame_queue_not_critical_estimate_delta_us() const { return at<2>().as_int64(); } + bool has_begin_main_frame_start_to_ready_to_commit_estimate_delta_us() const { return at<3>().valid(); } + int64_t begin_main_frame_start_to_ready_to_commit_estimate_delta_us() const { return at<3>().as_int64(); } + bool has_commit_to_ready_to_activate_estimate_delta_us() const { return at<4>().valid(); } + int64_t commit_to_ready_to_activate_estimate_delta_us() const { return at<4>().as_int64(); } + bool has_prepare_tiles_estimate_delta_us() const { return at<5>().valid(); } + int64_t prepare_tiles_estimate_delta_us() const { return at<5>().as_int64(); } + bool has_activate_estimate_delta_us() const { return at<6>().valid(); } + int64_t activate_estimate_delta_us() const { return at<6>().as_int64(); } + bool has_draw_estimate_delta_us() const { return at<7>().valid(); } + int64_t draw_estimate_delta_us() const { return at<7>().as_int64(); } +}; + +class CompositorTimingHistory : public ::protozero::Message { + public: + using Decoder = CompositorTimingHistory_Decoder; + enum : int32_t { + kBeginMainFrameQueueCriticalEstimateDeltaUsFieldNumber = 1, + kBeginMainFrameQueueNotCriticalEstimateDeltaUsFieldNumber = 2, + kBeginMainFrameStartToReadyToCommitEstimateDeltaUsFieldNumber = 3, + kCommitToReadyToActivateEstimateDeltaUsFieldNumber = 4, + kPrepareTilesEstimateDeltaUsFieldNumber = 5, + kActivateEstimateDeltaUsFieldNumber = 6, + kDrawEstimateDeltaUsFieldNumber = 7, + }; + static constexpr const char* GetName() { return ".perfetto.protos.CompositorTimingHistory"; } + + + using FieldMetadata_BeginMainFrameQueueCriticalEstimateDeltaUs = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + CompositorTimingHistory>; + + static constexpr FieldMetadata_BeginMainFrameQueueCriticalEstimateDeltaUs kBeginMainFrameQueueCriticalEstimateDeltaUs{}; + void set_begin_main_frame_queue_critical_estimate_delta_us(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_BeginMainFrameQueueCriticalEstimateDeltaUs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_BeginMainFrameQueueNotCriticalEstimateDeltaUs = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + CompositorTimingHistory>; + + static constexpr FieldMetadata_BeginMainFrameQueueNotCriticalEstimateDeltaUs kBeginMainFrameQueueNotCriticalEstimateDeltaUs{}; + void set_begin_main_frame_queue_not_critical_estimate_delta_us(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_BeginMainFrameQueueNotCriticalEstimateDeltaUs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_BeginMainFrameStartToReadyToCommitEstimateDeltaUs = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + CompositorTimingHistory>; + + static constexpr FieldMetadata_BeginMainFrameStartToReadyToCommitEstimateDeltaUs kBeginMainFrameStartToReadyToCommitEstimateDeltaUs{}; + void set_begin_main_frame_start_to_ready_to_commit_estimate_delta_us(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_BeginMainFrameStartToReadyToCommitEstimateDeltaUs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CommitToReadyToActivateEstimateDeltaUs = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + CompositorTimingHistory>; + + static constexpr FieldMetadata_CommitToReadyToActivateEstimateDeltaUs kCommitToReadyToActivateEstimateDeltaUs{}; + void set_commit_to_ready_to_activate_estimate_delta_us(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_CommitToReadyToActivateEstimateDeltaUs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PrepareTilesEstimateDeltaUs = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + CompositorTimingHistory>; + + static constexpr FieldMetadata_PrepareTilesEstimateDeltaUs kPrepareTilesEstimateDeltaUs{}; + void set_prepare_tiles_estimate_delta_us(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_PrepareTilesEstimateDeltaUs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ActivateEstimateDeltaUs = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + CompositorTimingHistory>; + + static constexpr FieldMetadata_ActivateEstimateDeltaUs kActivateEstimateDeltaUs{}; + void set_activate_estimate_delta_us(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_ActivateEstimateDeltaUs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DrawEstimateDeltaUs = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + CompositorTimingHistory>; + + static constexpr FieldMetadata_DrawEstimateDeltaUs kDrawEstimateDeltaUs{}; + void set_draw_estimate_delta_us(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_DrawEstimateDeltaUs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } +}; + +class BeginFrameSourceState_Decoder : public ::protozero::TypedProtoDecoder { + public: + BeginFrameSourceState_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit BeginFrameSourceState_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit BeginFrameSourceState_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_source_id() const { return at<1>().valid(); } + uint32_t source_id() const { return at<1>().as_uint32(); } + bool has_paused() const { return at<2>().valid(); } + bool paused() const { return at<2>().as_bool(); } + bool has_num_observers() const { return at<3>().valid(); } + uint32_t num_observers() const { return at<3>().as_uint32(); } + bool has_last_begin_frame_args() const { return at<4>().valid(); } + ::protozero::ConstBytes last_begin_frame_args() const { return at<4>().as_bytes(); } +}; + +class BeginFrameSourceState : public ::protozero::Message { + public: + using Decoder = BeginFrameSourceState_Decoder; + enum : int32_t { + kSourceIdFieldNumber = 1, + kPausedFieldNumber = 2, + kNumObserversFieldNumber = 3, + kLastBeginFrameArgsFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.BeginFrameSourceState"; } + + + using FieldMetadata_SourceId = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + BeginFrameSourceState>; + + static constexpr FieldMetadata_SourceId kSourceId{}; + void set_source_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_SourceId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Paused = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + BeginFrameSourceState>; + + static constexpr FieldMetadata_Paused kPaused{}; + void set_paused(bool value) { + static constexpr uint32_t field_id = FieldMetadata_Paused::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NumObservers = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + BeginFrameSourceState>; + + static constexpr FieldMetadata_NumObservers kNumObservers{}; + void set_num_observers(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_NumObservers::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_LastBeginFrameArgs = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + BeginFrameArgs, + BeginFrameSourceState>; + + static constexpr FieldMetadata_LastBeginFrameArgs kLastBeginFrameArgs{}; + template T* set_last_begin_frame_args() { + return BeginNestedMessage(4); + } + +}; + +class BeginFrameObserverState_Decoder : public ::protozero::TypedProtoDecoder { + public: + BeginFrameObserverState_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit BeginFrameObserverState_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit BeginFrameObserverState_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dropped_begin_frame_args() const { return at<1>().valid(); } + int64_t dropped_begin_frame_args() const { return at<1>().as_int64(); } + bool has_last_begin_frame_args() const { return at<2>().valid(); } + ::protozero::ConstBytes last_begin_frame_args() const { return at<2>().as_bytes(); } +}; + +class BeginFrameObserverState : public ::protozero::Message { + public: + using Decoder = BeginFrameObserverState_Decoder; + enum : int32_t { + kDroppedBeginFrameArgsFieldNumber = 1, + kLastBeginFrameArgsFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.BeginFrameObserverState"; } + + + using FieldMetadata_DroppedBeginFrameArgs = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + BeginFrameObserverState>; + + static constexpr FieldMetadata_DroppedBeginFrameArgs kDroppedBeginFrameArgs{}; + void set_dropped_begin_frame_args(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_DroppedBeginFrameArgs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_LastBeginFrameArgs = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + BeginFrameArgs, + BeginFrameObserverState>; + + static constexpr FieldMetadata_LastBeginFrameArgs kLastBeginFrameArgs{}; + template T* set_last_begin_frame_args() { + return BeginNestedMessage(2); + } + +}; + +class BeginImplFrameArgs_Decoder : public ::protozero::TypedProtoDecoder { + public: + BeginImplFrameArgs_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit BeginImplFrameArgs_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit BeginImplFrameArgs_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_updated_at_us() const { return at<1>().valid(); } + int64_t updated_at_us() const { return at<1>().as_int64(); } + bool has_finished_at_us() const { return at<2>().valid(); } + int64_t finished_at_us() const { return at<2>().as_int64(); } + bool has_state() const { return at<3>().valid(); } + int32_t state() const { return at<3>().as_int32(); } + bool has_current_args() const { return at<4>().valid(); } + ::protozero::ConstBytes current_args() const { return at<4>().as_bytes(); } + bool has_last_args() const { return at<5>().valid(); } + ::protozero::ConstBytes last_args() const { return at<5>().as_bytes(); } + bool has_timestamps_in_us() const { return at<6>().valid(); } + ::protozero::ConstBytes timestamps_in_us() const { return at<6>().as_bytes(); } +}; + +class BeginImplFrameArgs : public ::protozero::Message { + public: + using Decoder = BeginImplFrameArgs_Decoder; + enum : int32_t { + kUpdatedAtUsFieldNumber = 1, + kFinishedAtUsFieldNumber = 2, + kStateFieldNumber = 3, + kCurrentArgsFieldNumber = 4, + kLastArgsFieldNumber = 5, + kTimestampsInUsFieldNumber = 6, + }; + static constexpr const char* GetName() { return ".perfetto.protos.BeginImplFrameArgs"; } + + using TimestampsInUs = ::perfetto::protos::pbzero::BeginImplFrameArgs_TimestampsInUs; + + using State = ::perfetto::protos::pbzero::BeginImplFrameArgs_State; + static inline const char* State_Name(State value) { + return ::perfetto::protos::pbzero::BeginImplFrameArgs_State_Name(value); + } + static inline const State BEGIN_FRAME_FINISHED = State::BEGIN_FRAME_FINISHED; + static inline const State BEGIN_FRAME_USING = State::BEGIN_FRAME_USING; + + using FieldMetadata_UpdatedAtUs = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + BeginImplFrameArgs>; + + static constexpr FieldMetadata_UpdatedAtUs kUpdatedAtUs{}; + void set_updated_at_us(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_UpdatedAtUs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FinishedAtUs = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + BeginImplFrameArgs>; + + static constexpr FieldMetadata_FinishedAtUs kFinishedAtUs{}; + void set_finished_at_us(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_FinishedAtUs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_State = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + BeginImplFrameArgs_State, + BeginImplFrameArgs>; + + static constexpr FieldMetadata_State kState{}; + void set_state(BeginImplFrameArgs_State value) { + static constexpr uint32_t field_id = FieldMetadata_State::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CurrentArgs = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + BeginFrameArgs, + BeginImplFrameArgs>; + + static constexpr FieldMetadata_CurrentArgs kCurrentArgs{}; + template T* set_current_args() { + return BeginNestedMessage(4); + } + + + using FieldMetadata_LastArgs = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + BeginFrameArgs, + BeginImplFrameArgs>; + + static constexpr FieldMetadata_LastArgs kLastArgs{}; + template T* set_last_args() { + return BeginNestedMessage(5); + } + + + using FieldMetadata_TimestampsInUs = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + BeginImplFrameArgs_TimestampsInUs, + BeginImplFrameArgs>; + + static constexpr FieldMetadata_TimestampsInUs kTimestampsInUs{}; + template T* set_timestamps_in_us() { + return BeginNestedMessage(6); + } + +}; + +class BeginImplFrameArgs_TimestampsInUs_Decoder : public ::protozero::TypedProtoDecoder { + public: + BeginImplFrameArgs_TimestampsInUs_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit BeginImplFrameArgs_TimestampsInUs_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit BeginImplFrameArgs_TimestampsInUs_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_interval_delta() const { return at<1>().valid(); } + int64_t interval_delta() const { return at<1>().as_int64(); } + bool has_now_to_deadline_delta() const { return at<2>().valid(); } + int64_t now_to_deadline_delta() const { return at<2>().as_int64(); } + bool has_frame_time_to_now_delta() const { return at<3>().valid(); } + int64_t frame_time_to_now_delta() const { return at<3>().as_int64(); } + bool has_frame_time_to_deadline_delta() const { return at<4>().valid(); } + int64_t frame_time_to_deadline_delta() const { return at<4>().as_int64(); } + bool has_now() const { return at<5>().valid(); } + int64_t now() const { return at<5>().as_int64(); } + bool has_frame_time() const { return at<6>().valid(); } + int64_t frame_time() const { return at<6>().as_int64(); } + bool has_deadline() const { return at<7>().valid(); } + int64_t deadline() const { return at<7>().as_int64(); } +}; + +class BeginImplFrameArgs_TimestampsInUs : public ::protozero::Message { + public: + using Decoder = BeginImplFrameArgs_TimestampsInUs_Decoder; + enum : int32_t { + kIntervalDeltaFieldNumber = 1, + kNowToDeadlineDeltaFieldNumber = 2, + kFrameTimeToNowDeltaFieldNumber = 3, + kFrameTimeToDeadlineDeltaFieldNumber = 4, + kNowFieldNumber = 5, + kFrameTimeFieldNumber = 6, + kDeadlineFieldNumber = 7, + }; + static constexpr const char* GetName() { return ".perfetto.protos.BeginImplFrameArgs.TimestampsInUs"; } + + + using FieldMetadata_IntervalDelta = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + BeginImplFrameArgs_TimestampsInUs>; + + static constexpr FieldMetadata_IntervalDelta kIntervalDelta{}; + void set_interval_delta(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_IntervalDelta::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NowToDeadlineDelta = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + BeginImplFrameArgs_TimestampsInUs>; + + static constexpr FieldMetadata_NowToDeadlineDelta kNowToDeadlineDelta{}; + void set_now_to_deadline_delta(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_NowToDeadlineDelta::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FrameTimeToNowDelta = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + BeginImplFrameArgs_TimestampsInUs>; + + static constexpr FieldMetadata_FrameTimeToNowDelta kFrameTimeToNowDelta{}; + void set_frame_time_to_now_delta(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_FrameTimeToNowDelta::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FrameTimeToDeadlineDelta = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + BeginImplFrameArgs_TimestampsInUs>; + + static constexpr FieldMetadata_FrameTimeToDeadlineDelta kFrameTimeToDeadlineDelta{}; + void set_frame_time_to_deadline_delta(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_FrameTimeToDeadlineDelta::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Now = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + BeginImplFrameArgs_TimestampsInUs>; + + static constexpr FieldMetadata_Now kNow{}; + void set_now(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Now::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FrameTime = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + BeginImplFrameArgs_TimestampsInUs>; + + static constexpr FieldMetadata_FrameTime kFrameTime{}; + void set_frame_time(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_FrameTime::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Deadline = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + BeginImplFrameArgs_TimestampsInUs>; + + static constexpr FieldMetadata_Deadline kDeadline{}; + void set_deadline(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Deadline::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } +}; + +class BeginFrameArgs_Decoder : public ::protozero::TypedProtoDecoder { + public: + BeginFrameArgs_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit BeginFrameArgs_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit BeginFrameArgs_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_type() const { return at<1>().valid(); } + int32_t type() const { return at<1>().as_int32(); } + bool has_source_id() const { return at<2>().valid(); } + uint64_t source_id() const { return at<2>().as_uint64(); } + bool has_sequence_number() const { return at<3>().valid(); } + uint64_t sequence_number() const { return at<3>().as_uint64(); } + bool has_frame_time_us() const { return at<4>().valid(); } + int64_t frame_time_us() const { return at<4>().as_int64(); } + bool has_deadline_us() const { return at<5>().valid(); } + int64_t deadline_us() const { return at<5>().as_int64(); } + bool has_interval_delta_us() const { return at<6>().valid(); } + int64_t interval_delta_us() const { return at<6>().as_int64(); } + bool has_on_critical_path() const { return at<7>().valid(); } + bool on_critical_path() const { return at<7>().as_bool(); } + bool has_animate_only() const { return at<8>().valid(); } + bool animate_only() const { return at<8>().as_bool(); } + bool has_source_location_iid() const { return at<9>().valid(); } + uint64_t source_location_iid() const { return at<9>().as_uint64(); } + bool has_source_location() const { return at<10>().valid(); } + ::protozero::ConstBytes source_location() const { return at<10>().as_bytes(); } + bool has_frames_throttled_since_last() const { return at<12>().valid(); } + int64_t frames_throttled_since_last() const { return at<12>().as_int64(); } +}; + +class BeginFrameArgs : public ::protozero::Message { + public: + using Decoder = BeginFrameArgs_Decoder; + enum : int32_t { + kTypeFieldNumber = 1, + kSourceIdFieldNumber = 2, + kSequenceNumberFieldNumber = 3, + kFrameTimeUsFieldNumber = 4, + kDeadlineUsFieldNumber = 5, + kIntervalDeltaUsFieldNumber = 6, + kOnCriticalPathFieldNumber = 7, + kAnimateOnlyFieldNumber = 8, + kSourceLocationIidFieldNumber = 9, + kSourceLocationFieldNumber = 10, + kFramesThrottledSinceLastFieldNumber = 12, + }; + static constexpr const char* GetName() { return ".perfetto.protos.BeginFrameArgs"; } + + + using BeginFrameArgsType = ::perfetto::protos::pbzero::BeginFrameArgs_BeginFrameArgsType; + static inline const char* BeginFrameArgsType_Name(BeginFrameArgsType value) { + return ::perfetto::protos::pbzero::BeginFrameArgs_BeginFrameArgsType_Name(value); + } + static inline const BeginFrameArgsType BEGIN_FRAME_ARGS_TYPE_UNSPECIFIED = BeginFrameArgsType::BEGIN_FRAME_ARGS_TYPE_UNSPECIFIED; + static inline const BeginFrameArgsType BEGIN_FRAME_ARGS_TYPE_INVALID = BeginFrameArgsType::BEGIN_FRAME_ARGS_TYPE_INVALID; + static inline const BeginFrameArgsType BEGIN_FRAME_ARGS_TYPE_NORMAL = BeginFrameArgsType::BEGIN_FRAME_ARGS_TYPE_NORMAL; + static inline const BeginFrameArgsType BEGIN_FRAME_ARGS_TYPE_MISSED = BeginFrameArgsType::BEGIN_FRAME_ARGS_TYPE_MISSED; + + using FieldMetadata_Type = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + BeginFrameArgs_BeginFrameArgsType, + BeginFrameArgs>; + + static constexpr FieldMetadata_Type kType{}; + void set_type(BeginFrameArgs_BeginFrameArgsType value) { + static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SourceId = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + BeginFrameArgs>; + + static constexpr FieldMetadata_SourceId kSourceId{}; + void set_source_id(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_SourceId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SequenceNumber = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + BeginFrameArgs>; + + static constexpr FieldMetadata_SequenceNumber kSequenceNumber{}; + void set_sequence_number(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_SequenceNumber::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FrameTimeUs = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + BeginFrameArgs>; + + static constexpr FieldMetadata_FrameTimeUs kFrameTimeUs{}; + void set_frame_time_us(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_FrameTimeUs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DeadlineUs = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + BeginFrameArgs>; + + static constexpr FieldMetadata_DeadlineUs kDeadlineUs{}; + void set_deadline_us(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_DeadlineUs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_IntervalDeltaUs = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + BeginFrameArgs>; + + static constexpr FieldMetadata_IntervalDeltaUs kIntervalDeltaUs{}; + void set_interval_delta_us(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_IntervalDeltaUs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_OnCriticalPath = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + BeginFrameArgs>; + + static constexpr FieldMetadata_OnCriticalPath kOnCriticalPath{}; + void set_on_critical_path(bool value) { + static constexpr uint32_t field_id = FieldMetadata_OnCriticalPath::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_AnimateOnly = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + BeginFrameArgs>; + + static constexpr FieldMetadata_AnimateOnly kAnimateOnly{}; + void set_animate_only(bool value) { + static constexpr uint32_t field_id = FieldMetadata_AnimateOnly::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SourceLocationIid = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + BeginFrameArgs>; + + static constexpr FieldMetadata_SourceLocationIid kSourceLocationIid{}; + void set_source_location_iid(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_SourceLocationIid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SourceLocation = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + SourceLocation, + BeginFrameArgs>; + + static constexpr FieldMetadata_SourceLocation kSourceLocation{}; + template T* set_source_location() { + return BeginNestedMessage(10); + } + + + using FieldMetadata_FramesThrottledSinceLast = + ::protozero::proto_utils::FieldMetadata< + 12, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + BeginFrameArgs>; + + static constexpr FieldMetadata_FramesThrottledSinceLast kFramesThrottledSinceLast{}; + void set_frames_throttled_since_last(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_FramesThrottledSinceLast::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } +}; + +class ChromeCompositorStateMachine_Decoder : public ::protozero::TypedProtoDecoder { + public: + ChromeCompositorStateMachine_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ChromeCompositorStateMachine_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ChromeCompositorStateMachine_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_major_state() const { return at<1>().valid(); } + ::protozero::ConstBytes major_state() const { return at<1>().as_bytes(); } + bool has_minor_state() const { return at<2>().valid(); } + ::protozero::ConstBytes minor_state() const { return at<2>().as_bytes(); } +}; + +class ChromeCompositorStateMachine : public ::protozero::Message { + public: + using Decoder = ChromeCompositorStateMachine_Decoder; + enum : int32_t { + kMajorStateFieldNumber = 1, + kMinorStateFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ChromeCompositorStateMachine"; } + + using MajorState = ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState; + using MinorState = ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MinorState; + + using FieldMetadata_MajorState = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ChromeCompositorStateMachine_MajorState, + ChromeCompositorStateMachine>; + + static constexpr FieldMetadata_MajorState kMajorState{}; + template T* set_major_state() { + return BeginNestedMessage(1); + } + + + using FieldMetadata_MinorState = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ChromeCompositorStateMachine_MinorState, + ChromeCompositorStateMachine>; + + static constexpr FieldMetadata_MinorState kMinorState{}; + template T* set_minor_state() { + return BeginNestedMessage(2); + } + +}; + +class ChromeCompositorStateMachine_MinorState_Decoder : public ::protozero::TypedProtoDecoder { + public: + ChromeCompositorStateMachine_MinorState_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ChromeCompositorStateMachine_MinorState_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ChromeCompositorStateMachine_MinorState_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_commit_count() const { return at<1>().valid(); } + int32_t commit_count() const { return at<1>().as_int32(); } + bool has_current_frame_number() const { return at<2>().valid(); } + int32_t current_frame_number() const { return at<2>().as_int32(); } + bool has_last_frame_number_submit_performed() const { return at<3>().valid(); } + int32_t last_frame_number_submit_performed() const { return at<3>().as_int32(); } + bool has_last_frame_number_draw_performed() const { return at<4>().valid(); } + int32_t last_frame_number_draw_performed() const { return at<4>().as_int32(); } + bool has_last_frame_number_begin_main_frame_sent() const { return at<5>().valid(); } + int32_t last_frame_number_begin_main_frame_sent() const { return at<5>().as_int32(); } + bool has_did_draw() const { return at<6>().valid(); } + bool did_draw() const { return at<6>().as_bool(); } + bool has_did_send_begin_main_frame_for_current_frame() const { return at<7>().valid(); } + bool did_send_begin_main_frame_for_current_frame() const { return at<7>().as_bool(); } + bool has_did_notify_begin_main_frame_not_expected_until() const { return at<8>().valid(); } + bool did_notify_begin_main_frame_not_expected_until() const { return at<8>().as_bool(); } + bool has_did_notify_begin_main_frame_not_expected_soon() const { return at<9>().valid(); } + bool did_notify_begin_main_frame_not_expected_soon() const { return at<9>().as_bool(); } + bool has_wants_begin_main_frame_not_expected() const { return at<10>().valid(); } + bool wants_begin_main_frame_not_expected() const { return at<10>().as_bool(); } + bool has_did_commit_during_frame() const { return at<11>().valid(); } + bool did_commit_during_frame() const { return at<11>().as_bool(); } + bool has_did_invalidate_layer_tree_frame_sink() const { return at<12>().valid(); } + bool did_invalidate_layer_tree_frame_sink() const { return at<12>().as_bool(); } + bool has_did_perform_impl_side_invalidaion() const { return at<13>().valid(); } + bool did_perform_impl_side_invalidaion() const { return at<13>().as_bool(); } + bool has_did_prepare_tiles() const { return at<14>().valid(); } + bool did_prepare_tiles() const { return at<14>().as_bool(); } + bool has_consecutive_checkerboard_animations() const { return at<15>().valid(); } + int32_t consecutive_checkerboard_animations() const { return at<15>().as_int32(); } + bool has_pending_submit_frames() const { return at<16>().valid(); } + int32_t pending_submit_frames() const { return at<16>().as_int32(); } + bool has_submit_frames_with_current_layer_tree_frame_sink() const { return at<17>().valid(); } + int32_t submit_frames_with_current_layer_tree_frame_sink() const { return at<17>().as_int32(); } + bool has_needs_redraw() const { return at<18>().valid(); } + bool needs_redraw() const { return at<18>().as_bool(); } + bool has_needs_prepare_tiles() const { return at<19>().valid(); } + bool needs_prepare_tiles() const { return at<19>().as_bool(); } + bool has_needs_begin_main_frame() const { return at<20>().valid(); } + bool needs_begin_main_frame() const { return at<20>().as_bool(); } + bool has_needs_one_begin_impl_frame() const { return at<21>().valid(); } + bool needs_one_begin_impl_frame() const { return at<21>().as_bool(); } + bool has_visible() const { return at<22>().valid(); } + bool visible() const { return at<22>().as_bool(); } + bool has_begin_frame_source_paused() const { return at<23>().valid(); } + bool begin_frame_source_paused() const { return at<23>().as_bool(); } + bool has_can_draw() const { return at<24>().valid(); } + bool can_draw() const { return at<24>().as_bool(); } + bool has_resourceless_draw() const { return at<25>().valid(); } + bool resourceless_draw() const { return at<25>().as_bool(); } + bool has_has_pending_tree() const { return at<26>().valid(); } + bool has_pending_tree() const { return at<26>().as_bool(); } + bool has_pending_tree_is_ready_for_activation() const { return at<27>().valid(); } + bool pending_tree_is_ready_for_activation() const { return at<27>().as_bool(); } + bool has_active_tree_needs_first_draw() const { return at<28>().valid(); } + bool active_tree_needs_first_draw() const { return at<28>().as_bool(); } + bool has_active_tree_is_ready_to_draw() const { return at<29>().valid(); } + bool active_tree_is_ready_to_draw() const { return at<29>().as_bool(); } + bool has_did_create_and_initialize_first_layer_tree_frame_sink() const { return at<30>().valid(); } + bool did_create_and_initialize_first_layer_tree_frame_sink() const { return at<30>().as_bool(); } + bool has_tree_priority() const { return at<31>().valid(); } + int32_t tree_priority() const { return at<31>().as_int32(); } + bool has_scroll_handler_state() const { return at<32>().valid(); } + int32_t scroll_handler_state() const { return at<32>().as_int32(); } + bool has_critical_begin_main_frame_to_activate_is_fast() const { return at<33>().valid(); } + bool critical_begin_main_frame_to_activate_is_fast() const { return at<33>().as_bool(); } + bool has_main_thread_missed_last_deadline() const { return at<34>().valid(); } + bool main_thread_missed_last_deadline() const { return at<34>().as_bool(); } + bool has_video_needs_begin_frames() const { return at<36>().valid(); } + bool video_needs_begin_frames() const { return at<36>().as_bool(); } + bool has_defer_begin_main_frame() const { return at<37>().valid(); } + bool defer_begin_main_frame() const { return at<37>().as_bool(); } + bool has_last_commit_had_no_updates() const { return at<38>().valid(); } + bool last_commit_had_no_updates() const { return at<38>().as_bool(); } + bool has_did_draw_in_last_frame() const { return at<39>().valid(); } + bool did_draw_in_last_frame() const { return at<39>().as_bool(); } + bool has_did_submit_in_last_frame() const { return at<40>().valid(); } + bool did_submit_in_last_frame() const { return at<40>().as_bool(); } + bool has_needs_impl_side_invalidation() const { return at<41>().valid(); } + bool needs_impl_side_invalidation() const { return at<41>().as_bool(); } + bool has_current_pending_tree_is_impl_side() const { return at<42>().valid(); } + bool current_pending_tree_is_impl_side() const { return at<42>().as_bool(); } + bool has_previous_pending_tree_was_impl_side() const { return at<43>().valid(); } + bool previous_pending_tree_was_impl_side() const { return at<43>().as_bool(); } + bool has_processing_animation_worklets_for_active_tree() const { return at<44>().valid(); } + bool processing_animation_worklets_for_active_tree() const { return at<44>().as_bool(); } + bool has_processing_animation_worklets_for_pending_tree() const { return at<45>().valid(); } + bool processing_animation_worklets_for_pending_tree() const { return at<45>().as_bool(); } + bool has_processing_paint_worklets_for_pending_tree() const { return at<46>().valid(); } + bool processing_paint_worklets_for_pending_tree() const { return at<46>().as_bool(); } +}; + +class ChromeCompositorStateMachine_MinorState : public ::protozero::Message { + public: + using Decoder = ChromeCompositorStateMachine_MinorState_Decoder; + enum : int32_t { + kCommitCountFieldNumber = 1, + kCurrentFrameNumberFieldNumber = 2, + kLastFrameNumberSubmitPerformedFieldNumber = 3, + kLastFrameNumberDrawPerformedFieldNumber = 4, + kLastFrameNumberBeginMainFrameSentFieldNumber = 5, + kDidDrawFieldNumber = 6, + kDidSendBeginMainFrameForCurrentFrameFieldNumber = 7, + kDidNotifyBeginMainFrameNotExpectedUntilFieldNumber = 8, + kDidNotifyBeginMainFrameNotExpectedSoonFieldNumber = 9, + kWantsBeginMainFrameNotExpectedFieldNumber = 10, + kDidCommitDuringFrameFieldNumber = 11, + kDidInvalidateLayerTreeFrameSinkFieldNumber = 12, + kDidPerformImplSideInvalidaionFieldNumber = 13, + kDidPrepareTilesFieldNumber = 14, + kConsecutiveCheckerboardAnimationsFieldNumber = 15, + kPendingSubmitFramesFieldNumber = 16, + kSubmitFramesWithCurrentLayerTreeFrameSinkFieldNumber = 17, + kNeedsRedrawFieldNumber = 18, + kNeedsPrepareTilesFieldNumber = 19, + kNeedsBeginMainFrameFieldNumber = 20, + kNeedsOneBeginImplFrameFieldNumber = 21, + kVisibleFieldNumber = 22, + kBeginFrameSourcePausedFieldNumber = 23, + kCanDrawFieldNumber = 24, + kResourcelessDrawFieldNumber = 25, + kHasPendingTreeFieldNumber = 26, + kPendingTreeIsReadyForActivationFieldNumber = 27, + kActiveTreeNeedsFirstDrawFieldNumber = 28, + kActiveTreeIsReadyToDrawFieldNumber = 29, + kDidCreateAndInitializeFirstLayerTreeFrameSinkFieldNumber = 30, + kTreePriorityFieldNumber = 31, + kScrollHandlerStateFieldNumber = 32, + kCriticalBeginMainFrameToActivateIsFastFieldNumber = 33, + kMainThreadMissedLastDeadlineFieldNumber = 34, + kVideoNeedsBeginFramesFieldNumber = 36, + kDeferBeginMainFrameFieldNumber = 37, + kLastCommitHadNoUpdatesFieldNumber = 38, + kDidDrawInLastFrameFieldNumber = 39, + kDidSubmitInLastFrameFieldNumber = 40, + kNeedsImplSideInvalidationFieldNumber = 41, + kCurrentPendingTreeIsImplSideFieldNumber = 42, + kPreviousPendingTreeWasImplSideFieldNumber = 43, + kProcessingAnimationWorkletsForActiveTreeFieldNumber = 44, + kProcessingAnimationWorkletsForPendingTreeFieldNumber = 45, + kProcessingPaintWorkletsForPendingTreeFieldNumber = 46, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ChromeCompositorStateMachine.MinorState"; } + + + using TreePriority = ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MinorState_TreePriority; + static inline const char* TreePriority_Name(TreePriority value) { + return ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MinorState_TreePriority_Name(value); + } + + using ScrollHandlerState = ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MinorState_ScrollHandlerState; + static inline const char* ScrollHandlerState_Name(ScrollHandlerState value) { + return ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MinorState_ScrollHandlerState_Name(value); + } + static inline const TreePriority TREE_PRIORITY_UNSPECIFIED = TreePriority::TREE_PRIORITY_UNSPECIFIED; + static inline const TreePriority TREE_PRIORITY_SAME_PRIORITY_FOR_BOTH_TREES = TreePriority::TREE_PRIORITY_SAME_PRIORITY_FOR_BOTH_TREES; + static inline const TreePriority TREE_PRIORITY_SMOOTHNESS_TAKES_PRIORITY = TreePriority::TREE_PRIORITY_SMOOTHNESS_TAKES_PRIORITY; + static inline const TreePriority TREE_PRIORITY_NEW_CONTENT_TAKES_PRIORITY = TreePriority::TREE_PRIORITY_NEW_CONTENT_TAKES_PRIORITY; + static inline const ScrollHandlerState SCROLL_HANDLER_UNSPECIFIED = ScrollHandlerState::SCROLL_HANDLER_UNSPECIFIED; + static inline const ScrollHandlerState SCROLL_AFFECTS_SCROLL_HANDLER = ScrollHandlerState::SCROLL_AFFECTS_SCROLL_HANDLER; + static inline const ScrollHandlerState SCROLL_DOES_NOT_AFFECT_SCROLL_HANDLER = ScrollHandlerState::SCROLL_DOES_NOT_AFFECT_SCROLL_HANDLER; + + using FieldMetadata_CommitCount = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + ChromeCompositorStateMachine_MinorState>; + + static constexpr FieldMetadata_CommitCount kCommitCount{}; + void set_commit_count(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_CommitCount::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CurrentFrameNumber = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + ChromeCompositorStateMachine_MinorState>; + + static constexpr FieldMetadata_CurrentFrameNumber kCurrentFrameNumber{}; + void set_current_frame_number(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_CurrentFrameNumber::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_LastFrameNumberSubmitPerformed = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + ChromeCompositorStateMachine_MinorState>; + + static constexpr FieldMetadata_LastFrameNumberSubmitPerformed kLastFrameNumberSubmitPerformed{}; + void set_last_frame_number_submit_performed(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_LastFrameNumberSubmitPerformed::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_LastFrameNumberDrawPerformed = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + ChromeCompositorStateMachine_MinorState>; + + static constexpr FieldMetadata_LastFrameNumberDrawPerformed kLastFrameNumberDrawPerformed{}; + void set_last_frame_number_draw_performed(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_LastFrameNumberDrawPerformed::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_LastFrameNumberBeginMainFrameSent = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + ChromeCompositorStateMachine_MinorState>; + + static constexpr FieldMetadata_LastFrameNumberBeginMainFrameSent kLastFrameNumberBeginMainFrameSent{}; + void set_last_frame_number_begin_main_frame_sent(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_LastFrameNumberBeginMainFrameSent::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DidDraw = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + ChromeCompositorStateMachine_MinorState>; + + static constexpr FieldMetadata_DidDraw kDidDraw{}; + void set_did_draw(bool value) { + static constexpr uint32_t field_id = FieldMetadata_DidDraw::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DidSendBeginMainFrameForCurrentFrame = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + ChromeCompositorStateMachine_MinorState>; + + static constexpr FieldMetadata_DidSendBeginMainFrameForCurrentFrame kDidSendBeginMainFrameForCurrentFrame{}; + void set_did_send_begin_main_frame_for_current_frame(bool value) { + static constexpr uint32_t field_id = FieldMetadata_DidSendBeginMainFrameForCurrentFrame::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DidNotifyBeginMainFrameNotExpectedUntil = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + ChromeCompositorStateMachine_MinorState>; + + static constexpr FieldMetadata_DidNotifyBeginMainFrameNotExpectedUntil kDidNotifyBeginMainFrameNotExpectedUntil{}; + void set_did_notify_begin_main_frame_not_expected_until(bool value) { + static constexpr uint32_t field_id = FieldMetadata_DidNotifyBeginMainFrameNotExpectedUntil::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DidNotifyBeginMainFrameNotExpectedSoon = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + ChromeCompositorStateMachine_MinorState>; + + static constexpr FieldMetadata_DidNotifyBeginMainFrameNotExpectedSoon kDidNotifyBeginMainFrameNotExpectedSoon{}; + void set_did_notify_begin_main_frame_not_expected_soon(bool value) { + static constexpr uint32_t field_id = FieldMetadata_DidNotifyBeginMainFrameNotExpectedSoon::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_WantsBeginMainFrameNotExpected = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + ChromeCompositorStateMachine_MinorState>; + + static constexpr FieldMetadata_WantsBeginMainFrameNotExpected kWantsBeginMainFrameNotExpected{}; + void set_wants_begin_main_frame_not_expected(bool value) { + static constexpr uint32_t field_id = FieldMetadata_WantsBeginMainFrameNotExpected::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DidCommitDuringFrame = + ::protozero::proto_utils::FieldMetadata< + 11, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + ChromeCompositorStateMachine_MinorState>; + + static constexpr FieldMetadata_DidCommitDuringFrame kDidCommitDuringFrame{}; + void set_did_commit_during_frame(bool value) { + static constexpr uint32_t field_id = FieldMetadata_DidCommitDuringFrame::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DidInvalidateLayerTreeFrameSink = + ::protozero::proto_utils::FieldMetadata< + 12, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + ChromeCompositorStateMachine_MinorState>; + + static constexpr FieldMetadata_DidInvalidateLayerTreeFrameSink kDidInvalidateLayerTreeFrameSink{}; + void set_did_invalidate_layer_tree_frame_sink(bool value) { + static constexpr uint32_t field_id = FieldMetadata_DidInvalidateLayerTreeFrameSink::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DidPerformImplSideInvalidaion = + ::protozero::proto_utils::FieldMetadata< + 13, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + ChromeCompositorStateMachine_MinorState>; + + static constexpr FieldMetadata_DidPerformImplSideInvalidaion kDidPerformImplSideInvalidaion{}; + void set_did_perform_impl_side_invalidaion(bool value) { + static constexpr uint32_t field_id = FieldMetadata_DidPerformImplSideInvalidaion::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DidPrepareTiles = + ::protozero::proto_utils::FieldMetadata< + 14, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + ChromeCompositorStateMachine_MinorState>; + + static constexpr FieldMetadata_DidPrepareTiles kDidPrepareTiles{}; + void set_did_prepare_tiles(bool value) { + static constexpr uint32_t field_id = FieldMetadata_DidPrepareTiles::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ConsecutiveCheckerboardAnimations = + ::protozero::proto_utils::FieldMetadata< + 15, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + ChromeCompositorStateMachine_MinorState>; + + static constexpr FieldMetadata_ConsecutiveCheckerboardAnimations kConsecutiveCheckerboardAnimations{}; + void set_consecutive_checkerboard_animations(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ConsecutiveCheckerboardAnimations::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PendingSubmitFrames = + ::protozero::proto_utils::FieldMetadata< + 16, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + ChromeCompositorStateMachine_MinorState>; + + static constexpr FieldMetadata_PendingSubmitFrames kPendingSubmitFrames{}; + void set_pending_submit_frames(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_PendingSubmitFrames::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SubmitFramesWithCurrentLayerTreeFrameSink = + ::protozero::proto_utils::FieldMetadata< + 17, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + ChromeCompositorStateMachine_MinorState>; + + static constexpr FieldMetadata_SubmitFramesWithCurrentLayerTreeFrameSink kSubmitFramesWithCurrentLayerTreeFrameSink{}; + void set_submit_frames_with_current_layer_tree_frame_sink(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_SubmitFramesWithCurrentLayerTreeFrameSink::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NeedsRedraw = + ::protozero::proto_utils::FieldMetadata< + 18, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + ChromeCompositorStateMachine_MinorState>; + + static constexpr FieldMetadata_NeedsRedraw kNeedsRedraw{}; + void set_needs_redraw(bool value) { + static constexpr uint32_t field_id = FieldMetadata_NeedsRedraw::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NeedsPrepareTiles = + ::protozero::proto_utils::FieldMetadata< + 19, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + ChromeCompositorStateMachine_MinorState>; + + static constexpr FieldMetadata_NeedsPrepareTiles kNeedsPrepareTiles{}; + void set_needs_prepare_tiles(bool value) { + static constexpr uint32_t field_id = FieldMetadata_NeedsPrepareTiles::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NeedsBeginMainFrame = + ::protozero::proto_utils::FieldMetadata< + 20, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + ChromeCompositorStateMachine_MinorState>; + + static constexpr FieldMetadata_NeedsBeginMainFrame kNeedsBeginMainFrame{}; + void set_needs_begin_main_frame(bool value) { + static constexpr uint32_t field_id = FieldMetadata_NeedsBeginMainFrame::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NeedsOneBeginImplFrame = + ::protozero::proto_utils::FieldMetadata< + 21, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + ChromeCompositorStateMachine_MinorState>; + + static constexpr FieldMetadata_NeedsOneBeginImplFrame kNeedsOneBeginImplFrame{}; + void set_needs_one_begin_impl_frame(bool value) { + static constexpr uint32_t field_id = FieldMetadata_NeedsOneBeginImplFrame::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Visible = + ::protozero::proto_utils::FieldMetadata< + 22, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + ChromeCompositorStateMachine_MinorState>; + + static constexpr FieldMetadata_Visible kVisible{}; + void set_visible(bool value) { + static constexpr uint32_t field_id = FieldMetadata_Visible::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_BeginFrameSourcePaused = + ::protozero::proto_utils::FieldMetadata< + 23, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + ChromeCompositorStateMachine_MinorState>; + + static constexpr FieldMetadata_BeginFrameSourcePaused kBeginFrameSourcePaused{}; + void set_begin_frame_source_paused(bool value) { + static constexpr uint32_t field_id = FieldMetadata_BeginFrameSourcePaused::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CanDraw = + ::protozero::proto_utils::FieldMetadata< + 24, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + ChromeCompositorStateMachine_MinorState>; + + static constexpr FieldMetadata_CanDraw kCanDraw{}; + void set_can_draw(bool value) { + static constexpr uint32_t field_id = FieldMetadata_CanDraw::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ResourcelessDraw = + ::protozero::proto_utils::FieldMetadata< + 25, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + ChromeCompositorStateMachine_MinorState>; + + static constexpr FieldMetadata_ResourcelessDraw kResourcelessDraw{}; + void set_resourceless_draw(bool value) { + static constexpr uint32_t field_id = FieldMetadata_ResourcelessDraw::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_HasPendingTree = + ::protozero::proto_utils::FieldMetadata< + 26, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + ChromeCompositorStateMachine_MinorState>; + + static constexpr FieldMetadata_HasPendingTree kHasPendingTree{}; + void set_has_pending_tree(bool value) { + static constexpr uint32_t field_id = FieldMetadata_HasPendingTree::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PendingTreeIsReadyForActivation = + ::protozero::proto_utils::FieldMetadata< + 27, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + ChromeCompositorStateMachine_MinorState>; + + static constexpr FieldMetadata_PendingTreeIsReadyForActivation kPendingTreeIsReadyForActivation{}; + void set_pending_tree_is_ready_for_activation(bool value) { + static constexpr uint32_t field_id = FieldMetadata_PendingTreeIsReadyForActivation::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ActiveTreeNeedsFirstDraw = + ::protozero::proto_utils::FieldMetadata< + 28, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + ChromeCompositorStateMachine_MinorState>; + + static constexpr FieldMetadata_ActiveTreeNeedsFirstDraw kActiveTreeNeedsFirstDraw{}; + void set_active_tree_needs_first_draw(bool value) { + static constexpr uint32_t field_id = FieldMetadata_ActiveTreeNeedsFirstDraw::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ActiveTreeIsReadyToDraw = + ::protozero::proto_utils::FieldMetadata< + 29, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + ChromeCompositorStateMachine_MinorState>; + + static constexpr FieldMetadata_ActiveTreeIsReadyToDraw kActiveTreeIsReadyToDraw{}; + void set_active_tree_is_ready_to_draw(bool value) { + static constexpr uint32_t field_id = FieldMetadata_ActiveTreeIsReadyToDraw::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DidCreateAndInitializeFirstLayerTreeFrameSink = + ::protozero::proto_utils::FieldMetadata< + 30, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + ChromeCompositorStateMachine_MinorState>; + + static constexpr FieldMetadata_DidCreateAndInitializeFirstLayerTreeFrameSink kDidCreateAndInitializeFirstLayerTreeFrameSink{}; + void set_did_create_and_initialize_first_layer_tree_frame_sink(bool value) { + static constexpr uint32_t field_id = FieldMetadata_DidCreateAndInitializeFirstLayerTreeFrameSink::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TreePriority = + ::protozero::proto_utils::FieldMetadata< + 31, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + ChromeCompositorStateMachine_MinorState_TreePriority, + ChromeCompositorStateMachine_MinorState>; + + static constexpr FieldMetadata_TreePriority kTreePriority{}; + void set_tree_priority(ChromeCompositorStateMachine_MinorState_TreePriority value) { + static constexpr uint32_t field_id = FieldMetadata_TreePriority::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ScrollHandlerState = + ::protozero::proto_utils::FieldMetadata< + 32, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + ChromeCompositorStateMachine_MinorState_ScrollHandlerState, + ChromeCompositorStateMachine_MinorState>; + + static constexpr FieldMetadata_ScrollHandlerState kScrollHandlerState{}; + void set_scroll_handler_state(ChromeCompositorStateMachine_MinorState_ScrollHandlerState value) { + static constexpr uint32_t field_id = FieldMetadata_ScrollHandlerState::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CriticalBeginMainFrameToActivateIsFast = + ::protozero::proto_utils::FieldMetadata< + 33, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + ChromeCompositorStateMachine_MinorState>; + + static constexpr FieldMetadata_CriticalBeginMainFrameToActivateIsFast kCriticalBeginMainFrameToActivateIsFast{}; + void set_critical_begin_main_frame_to_activate_is_fast(bool value) { + static constexpr uint32_t field_id = FieldMetadata_CriticalBeginMainFrameToActivateIsFast::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_MainThreadMissedLastDeadline = + ::protozero::proto_utils::FieldMetadata< + 34, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + ChromeCompositorStateMachine_MinorState>; + + static constexpr FieldMetadata_MainThreadMissedLastDeadline kMainThreadMissedLastDeadline{}; + void set_main_thread_missed_last_deadline(bool value) { + static constexpr uint32_t field_id = FieldMetadata_MainThreadMissedLastDeadline::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_VideoNeedsBeginFrames = + ::protozero::proto_utils::FieldMetadata< + 36, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + ChromeCompositorStateMachine_MinorState>; + + static constexpr FieldMetadata_VideoNeedsBeginFrames kVideoNeedsBeginFrames{}; + void set_video_needs_begin_frames(bool value) { + static constexpr uint32_t field_id = FieldMetadata_VideoNeedsBeginFrames::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DeferBeginMainFrame = + ::protozero::proto_utils::FieldMetadata< + 37, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + ChromeCompositorStateMachine_MinorState>; + + static constexpr FieldMetadata_DeferBeginMainFrame kDeferBeginMainFrame{}; + void set_defer_begin_main_frame(bool value) { + static constexpr uint32_t field_id = FieldMetadata_DeferBeginMainFrame::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_LastCommitHadNoUpdates = + ::protozero::proto_utils::FieldMetadata< + 38, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + ChromeCompositorStateMachine_MinorState>; + + static constexpr FieldMetadata_LastCommitHadNoUpdates kLastCommitHadNoUpdates{}; + void set_last_commit_had_no_updates(bool value) { + static constexpr uint32_t field_id = FieldMetadata_LastCommitHadNoUpdates::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DidDrawInLastFrame = + ::protozero::proto_utils::FieldMetadata< + 39, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + ChromeCompositorStateMachine_MinorState>; + + static constexpr FieldMetadata_DidDrawInLastFrame kDidDrawInLastFrame{}; + void set_did_draw_in_last_frame(bool value) { + static constexpr uint32_t field_id = FieldMetadata_DidDrawInLastFrame::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DidSubmitInLastFrame = + ::protozero::proto_utils::FieldMetadata< + 40, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + ChromeCompositorStateMachine_MinorState>; + + static constexpr FieldMetadata_DidSubmitInLastFrame kDidSubmitInLastFrame{}; + void set_did_submit_in_last_frame(bool value) { + static constexpr uint32_t field_id = FieldMetadata_DidSubmitInLastFrame::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NeedsImplSideInvalidation = + ::protozero::proto_utils::FieldMetadata< + 41, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + ChromeCompositorStateMachine_MinorState>; + + static constexpr FieldMetadata_NeedsImplSideInvalidation kNeedsImplSideInvalidation{}; + void set_needs_impl_side_invalidation(bool value) { + static constexpr uint32_t field_id = FieldMetadata_NeedsImplSideInvalidation::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CurrentPendingTreeIsImplSide = + ::protozero::proto_utils::FieldMetadata< + 42, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + ChromeCompositorStateMachine_MinorState>; + + static constexpr FieldMetadata_CurrentPendingTreeIsImplSide kCurrentPendingTreeIsImplSide{}; + void set_current_pending_tree_is_impl_side(bool value) { + static constexpr uint32_t field_id = FieldMetadata_CurrentPendingTreeIsImplSide::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PreviousPendingTreeWasImplSide = + ::protozero::proto_utils::FieldMetadata< + 43, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + ChromeCompositorStateMachine_MinorState>; + + static constexpr FieldMetadata_PreviousPendingTreeWasImplSide kPreviousPendingTreeWasImplSide{}; + void set_previous_pending_tree_was_impl_side(bool value) { + static constexpr uint32_t field_id = FieldMetadata_PreviousPendingTreeWasImplSide::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ProcessingAnimationWorkletsForActiveTree = + ::protozero::proto_utils::FieldMetadata< + 44, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + ChromeCompositorStateMachine_MinorState>; + + static constexpr FieldMetadata_ProcessingAnimationWorkletsForActiveTree kProcessingAnimationWorkletsForActiveTree{}; + void set_processing_animation_worklets_for_active_tree(bool value) { + static constexpr uint32_t field_id = FieldMetadata_ProcessingAnimationWorkletsForActiveTree::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ProcessingAnimationWorkletsForPendingTree = + ::protozero::proto_utils::FieldMetadata< + 45, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + ChromeCompositorStateMachine_MinorState>; + + static constexpr FieldMetadata_ProcessingAnimationWorkletsForPendingTree kProcessingAnimationWorkletsForPendingTree{}; + void set_processing_animation_worklets_for_pending_tree(bool value) { + static constexpr uint32_t field_id = FieldMetadata_ProcessingAnimationWorkletsForPendingTree::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ProcessingPaintWorkletsForPendingTree = + ::protozero::proto_utils::FieldMetadata< + 46, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + ChromeCompositorStateMachine_MinorState>; + + static constexpr FieldMetadata_ProcessingPaintWorkletsForPendingTree kProcessingPaintWorkletsForPendingTree{}; + void set_processing_paint_worklets_for_pending_tree(bool value) { + static constexpr uint32_t field_id = FieldMetadata_ProcessingPaintWorkletsForPendingTree::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } +}; + +class ChromeCompositorStateMachine_MajorState_Decoder : public ::protozero::TypedProtoDecoder { + public: + ChromeCompositorStateMachine_MajorState_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ChromeCompositorStateMachine_MajorState_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ChromeCompositorStateMachine_MajorState_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_next_action() const { return at<1>().valid(); } + int32_t next_action() const { return at<1>().as_int32(); } + bool has_begin_impl_frame_state() const { return at<2>().valid(); } + int32_t begin_impl_frame_state() const { return at<2>().as_int32(); } + bool has_begin_main_frame_state() const { return at<3>().valid(); } + int32_t begin_main_frame_state() const { return at<3>().as_int32(); } + bool has_layer_tree_frame_sink_state() const { return at<4>().valid(); } + int32_t layer_tree_frame_sink_state() const { return at<4>().as_int32(); } + bool has_forced_redraw_state() const { return at<5>().valid(); } + int32_t forced_redraw_state() const { return at<5>().as_int32(); } +}; + +class ChromeCompositorStateMachine_MajorState : public ::protozero::Message { + public: + using Decoder = ChromeCompositorStateMachine_MajorState_Decoder; + enum : int32_t { + kNextActionFieldNumber = 1, + kBeginImplFrameStateFieldNumber = 2, + kBeginMainFrameStateFieldNumber = 3, + kLayerTreeFrameSinkStateFieldNumber = 4, + kForcedRedrawStateFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ChromeCompositorStateMachine.MajorState"; } + + + using BeginImplFrameState = ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_BeginImplFrameState; + static inline const char* BeginImplFrameState_Name(BeginImplFrameState value) { + return ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_BeginImplFrameState_Name(value); + } + + using BeginMainFrameState = ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_BeginMainFrameState; + static inline const char* BeginMainFrameState_Name(BeginMainFrameState value) { + return ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_BeginMainFrameState_Name(value); + } + + using LayerTreeFrameSinkState = ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState; + static inline const char* LayerTreeFrameSinkState_Name(LayerTreeFrameSinkState value) { + return ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState_Name(value); + } + + using ForcedRedrawOnTimeoutState = ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState; + static inline const char* ForcedRedrawOnTimeoutState_Name(ForcedRedrawOnTimeoutState value) { + return ::perfetto::protos::pbzero::ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState_Name(value); + } + static inline const BeginImplFrameState BEGIN_IMPL_FRAME_UNSPECIFIED = BeginImplFrameState::BEGIN_IMPL_FRAME_UNSPECIFIED; + static inline const BeginImplFrameState BEGIN_IMPL_FRAME_IDLE = BeginImplFrameState::BEGIN_IMPL_FRAME_IDLE; + static inline const BeginImplFrameState BEGIN_IMPL_FRAME_INSIDE_BEGIN_FRAME = BeginImplFrameState::BEGIN_IMPL_FRAME_INSIDE_BEGIN_FRAME; + static inline const BeginImplFrameState BEGIN_IMPL_FRAME_INSIDE_DEADLINE = BeginImplFrameState::BEGIN_IMPL_FRAME_INSIDE_DEADLINE; + static inline const BeginMainFrameState BEGIN_MAIN_FRAME_UNSPECIFIED = BeginMainFrameState::BEGIN_MAIN_FRAME_UNSPECIFIED; + static inline const BeginMainFrameState BEGIN_MAIN_FRAME_IDLE = BeginMainFrameState::BEGIN_MAIN_FRAME_IDLE; + static inline const BeginMainFrameState BEGIN_MAIN_FRAME_SENT = BeginMainFrameState::BEGIN_MAIN_FRAME_SENT; + static inline const BeginMainFrameState BEGIN_MAIN_FRAME_READY_TO_COMMIT = BeginMainFrameState::BEGIN_MAIN_FRAME_READY_TO_COMMIT; + static inline const LayerTreeFrameSinkState LAYER_TREE_FRAME_UNSPECIFIED = LayerTreeFrameSinkState::LAYER_TREE_FRAME_UNSPECIFIED; + static inline const LayerTreeFrameSinkState LAYER_TREE_FRAME_NONE = LayerTreeFrameSinkState::LAYER_TREE_FRAME_NONE; + static inline const LayerTreeFrameSinkState LAYER_TREE_FRAME_ACTIVE = LayerTreeFrameSinkState::LAYER_TREE_FRAME_ACTIVE; + static inline const LayerTreeFrameSinkState LAYER_TREE_FRAME_CREATING = LayerTreeFrameSinkState::LAYER_TREE_FRAME_CREATING; + static inline const LayerTreeFrameSinkState LAYER_TREE_FRAME_WAITING_FOR_FIRST_COMMIT = LayerTreeFrameSinkState::LAYER_TREE_FRAME_WAITING_FOR_FIRST_COMMIT; + static inline const LayerTreeFrameSinkState LAYER_TREE_FRAME_WAITING_FOR_FIRST_ACTIVATION = LayerTreeFrameSinkState::LAYER_TREE_FRAME_WAITING_FOR_FIRST_ACTIVATION; + static inline const ForcedRedrawOnTimeoutState FORCED_REDRAW_UNSPECIFIED = ForcedRedrawOnTimeoutState::FORCED_REDRAW_UNSPECIFIED; + static inline const ForcedRedrawOnTimeoutState FORCED_REDRAW_IDLE = ForcedRedrawOnTimeoutState::FORCED_REDRAW_IDLE; + static inline const ForcedRedrawOnTimeoutState FORCED_REDRAW_WAITING_FOR_COMMIT = ForcedRedrawOnTimeoutState::FORCED_REDRAW_WAITING_FOR_COMMIT; + static inline const ForcedRedrawOnTimeoutState FORCED_REDRAW_WAITING_FOR_ACTIVATION = ForcedRedrawOnTimeoutState::FORCED_REDRAW_WAITING_FOR_ACTIVATION; + static inline const ForcedRedrawOnTimeoutState FORCED_REDRAW_WAITING_FOR_DRAW = ForcedRedrawOnTimeoutState::FORCED_REDRAW_WAITING_FOR_DRAW; + + using FieldMetadata_NextAction = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + ChromeCompositorSchedulerAction, + ChromeCompositorStateMachine_MajorState>; + + static constexpr FieldMetadata_NextAction kNextAction{}; + void set_next_action(ChromeCompositorSchedulerAction value) { + static constexpr uint32_t field_id = FieldMetadata_NextAction::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_BeginImplFrameState = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + ChromeCompositorStateMachine_MajorState_BeginImplFrameState, + ChromeCompositorStateMachine_MajorState>; + + static constexpr FieldMetadata_BeginImplFrameState kBeginImplFrameState{}; + void set_begin_impl_frame_state(ChromeCompositorStateMachine_MajorState_BeginImplFrameState value) { + static constexpr uint32_t field_id = FieldMetadata_BeginImplFrameState::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_BeginMainFrameState = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + ChromeCompositorStateMachine_MajorState_BeginMainFrameState, + ChromeCompositorStateMachine_MajorState>; + + static constexpr FieldMetadata_BeginMainFrameState kBeginMainFrameState{}; + void set_begin_main_frame_state(ChromeCompositorStateMachine_MajorState_BeginMainFrameState value) { + static constexpr uint32_t field_id = FieldMetadata_BeginMainFrameState::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_LayerTreeFrameSinkState = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState, + ChromeCompositorStateMachine_MajorState>; + + static constexpr FieldMetadata_LayerTreeFrameSinkState kLayerTreeFrameSinkState{}; + void set_layer_tree_frame_sink_state(ChromeCompositorStateMachine_MajorState_LayerTreeFrameSinkState value) { + static constexpr uint32_t field_id = FieldMetadata_LayerTreeFrameSinkState::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ForcedRedrawState = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState, + ChromeCompositorStateMachine_MajorState>; + + static constexpr FieldMetadata_ForcedRedrawState kForcedRedrawState{}; + void set_forced_redraw_state(ChromeCompositorStateMachine_MajorState_ForcedRedrawOnTimeoutState value) { + static constexpr uint32_t field_id = FieldMetadata_ForcedRedrawState::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } +}; + +class ChromeCompositorSchedulerState_Decoder : public ::protozero::TypedProtoDecoder { + public: + ChromeCompositorSchedulerState_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ChromeCompositorSchedulerState_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ChromeCompositorSchedulerState_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_state_machine() const { return at<1>().valid(); } + ::protozero::ConstBytes state_machine() const { return at<1>().as_bytes(); } + bool has_observing_begin_frame_source() const { return at<2>().valid(); } + bool observing_begin_frame_source() const { return at<2>().as_bool(); } + bool has_begin_impl_frame_deadline_task() const { return at<3>().valid(); } + bool begin_impl_frame_deadline_task() const { return at<3>().as_bool(); } + bool has_pending_begin_frame_task() const { return at<4>().valid(); } + bool pending_begin_frame_task() const { return at<4>().as_bool(); } + bool has_skipped_last_frame_missed_exceeded_deadline() const { return at<5>().valid(); } + bool skipped_last_frame_missed_exceeded_deadline() const { return at<5>().as_bool(); } + bool has_inside_action() const { return at<7>().valid(); } + int32_t inside_action() const { return at<7>().as_int32(); } + bool has_deadline_mode() const { return at<8>().valid(); } + int32_t deadline_mode() const { return at<8>().as_int32(); } + bool has_deadline_us() const { return at<9>().valid(); } + int64_t deadline_us() const { return at<9>().as_int64(); } + bool has_deadline_scheduled_at_us() const { return at<10>().valid(); } + int64_t deadline_scheduled_at_us() const { return at<10>().as_int64(); } + bool has_now_us() const { return at<11>().valid(); } + int64_t now_us() const { return at<11>().as_int64(); } + bool has_now_to_deadline_delta_us() const { return at<12>().valid(); } + int64_t now_to_deadline_delta_us() const { return at<12>().as_int64(); } + bool has_now_to_deadline_scheduled_at_delta_us() const { return at<13>().valid(); } + int64_t now_to_deadline_scheduled_at_delta_us() const { return at<13>().as_int64(); } + bool has_begin_impl_frame_args() const { return at<14>().valid(); } + ::protozero::ConstBytes begin_impl_frame_args() const { return at<14>().as_bytes(); } + bool has_begin_frame_observer_state() const { return at<15>().valid(); } + ::protozero::ConstBytes begin_frame_observer_state() const { return at<15>().as_bytes(); } + bool has_begin_frame_source_state() const { return at<16>().valid(); } + ::protozero::ConstBytes begin_frame_source_state() const { return at<16>().as_bytes(); } + bool has_compositor_timing_history() const { return at<17>().valid(); } + ::protozero::ConstBytes compositor_timing_history() const { return at<17>().as_bytes(); } +}; + +class ChromeCompositorSchedulerState : public ::protozero::Message { + public: + using Decoder = ChromeCompositorSchedulerState_Decoder; + enum : int32_t { + kStateMachineFieldNumber = 1, + kObservingBeginFrameSourceFieldNumber = 2, + kBeginImplFrameDeadlineTaskFieldNumber = 3, + kPendingBeginFrameTaskFieldNumber = 4, + kSkippedLastFrameMissedExceededDeadlineFieldNumber = 5, + kInsideActionFieldNumber = 7, + kDeadlineModeFieldNumber = 8, + kDeadlineUsFieldNumber = 9, + kDeadlineScheduledAtUsFieldNumber = 10, + kNowUsFieldNumber = 11, + kNowToDeadlineDeltaUsFieldNumber = 12, + kNowToDeadlineScheduledAtDeltaUsFieldNumber = 13, + kBeginImplFrameArgsFieldNumber = 14, + kBeginFrameObserverStateFieldNumber = 15, + kBeginFrameSourceStateFieldNumber = 16, + kCompositorTimingHistoryFieldNumber = 17, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ChromeCompositorSchedulerState"; } + + + using BeginImplFrameDeadlineMode = ::perfetto::protos::pbzero::ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode; + static inline const char* BeginImplFrameDeadlineMode_Name(BeginImplFrameDeadlineMode value) { + return ::perfetto::protos::pbzero::ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode_Name(value); + } + static inline const BeginImplFrameDeadlineMode DEADLINE_MODE_UNSPECIFIED = BeginImplFrameDeadlineMode::DEADLINE_MODE_UNSPECIFIED; + static inline const BeginImplFrameDeadlineMode DEADLINE_MODE_NONE = BeginImplFrameDeadlineMode::DEADLINE_MODE_NONE; + static inline const BeginImplFrameDeadlineMode DEADLINE_MODE_IMMEDIATE = BeginImplFrameDeadlineMode::DEADLINE_MODE_IMMEDIATE; + static inline const BeginImplFrameDeadlineMode DEADLINE_MODE_REGULAR = BeginImplFrameDeadlineMode::DEADLINE_MODE_REGULAR; + static inline const BeginImplFrameDeadlineMode DEADLINE_MODE_LATE = BeginImplFrameDeadlineMode::DEADLINE_MODE_LATE; + static inline const BeginImplFrameDeadlineMode DEADLINE_MODE_BLOCKED = BeginImplFrameDeadlineMode::DEADLINE_MODE_BLOCKED; + + using FieldMetadata_StateMachine = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ChromeCompositorStateMachine, + ChromeCompositorSchedulerState>; + + static constexpr FieldMetadata_StateMachine kStateMachine{}; + template T* set_state_machine() { + return BeginNestedMessage(1); + } + + + using FieldMetadata_ObservingBeginFrameSource = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + ChromeCompositorSchedulerState>; + + static constexpr FieldMetadata_ObservingBeginFrameSource kObservingBeginFrameSource{}; + void set_observing_begin_frame_source(bool value) { + static constexpr uint32_t field_id = FieldMetadata_ObservingBeginFrameSource::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_BeginImplFrameDeadlineTask = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + ChromeCompositorSchedulerState>; + + static constexpr FieldMetadata_BeginImplFrameDeadlineTask kBeginImplFrameDeadlineTask{}; + void set_begin_impl_frame_deadline_task(bool value) { + static constexpr uint32_t field_id = FieldMetadata_BeginImplFrameDeadlineTask::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PendingBeginFrameTask = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + ChromeCompositorSchedulerState>; + + static constexpr FieldMetadata_PendingBeginFrameTask kPendingBeginFrameTask{}; + void set_pending_begin_frame_task(bool value) { + static constexpr uint32_t field_id = FieldMetadata_PendingBeginFrameTask::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SkippedLastFrameMissedExceededDeadline = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + ChromeCompositorSchedulerState>; + + static constexpr FieldMetadata_SkippedLastFrameMissedExceededDeadline kSkippedLastFrameMissedExceededDeadline{}; + void set_skipped_last_frame_missed_exceeded_deadline(bool value) { + static constexpr uint32_t field_id = FieldMetadata_SkippedLastFrameMissedExceededDeadline::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_InsideAction = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + ChromeCompositorSchedulerAction, + ChromeCompositorSchedulerState>; + + static constexpr FieldMetadata_InsideAction kInsideAction{}; + void set_inside_action(ChromeCompositorSchedulerAction value) { + static constexpr uint32_t field_id = FieldMetadata_InsideAction::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DeadlineMode = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode, + ChromeCompositorSchedulerState>; + + static constexpr FieldMetadata_DeadlineMode kDeadlineMode{}; + void set_deadline_mode(ChromeCompositorSchedulerState_BeginImplFrameDeadlineMode value) { + static constexpr uint32_t field_id = FieldMetadata_DeadlineMode::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DeadlineUs = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + ChromeCompositorSchedulerState>; + + static constexpr FieldMetadata_DeadlineUs kDeadlineUs{}; + void set_deadline_us(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_DeadlineUs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DeadlineScheduledAtUs = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + ChromeCompositorSchedulerState>; + + static constexpr FieldMetadata_DeadlineScheduledAtUs kDeadlineScheduledAtUs{}; + void set_deadline_scheduled_at_us(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_DeadlineScheduledAtUs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NowUs = + ::protozero::proto_utils::FieldMetadata< + 11, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + ChromeCompositorSchedulerState>; + + static constexpr FieldMetadata_NowUs kNowUs{}; + void set_now_us(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_NowUs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NowToDeadlineDeltaUs = + ::protozero::proto_utils::FieldMetadata< + 12, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + ChromeCompositorSchedulerState>; + + static constexpr FieldMetadata_NowToDeadlineDeltaUs kNowToDeadlineDeltaUs{}; + void set_now_to_deadline_delta_us(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_NowToDeadlineDeltaUs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NowToDeadlineScheduledAtDeltaUs = + ::protozero::proto_utils::FieldMetadata< + 13, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + ChromeCompositorSchedulerState>; + + static constexpr FieldMetadata_NowToDeadlineScheduledAtDeltaUs kNowToDeadlineScheduledAtDeltaUs{}; + void set_now_to_deadline_scheduled_at_delta_us(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_NowToDeadlineScheduledAtDeltaUs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_BeginImplFrameArgs = + ::protozero::proto_utils::FieldMetadata< + 14, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + BeginImplFrameArgs, + ChromeCompositorSchedulerState>; + + static constexpr FieldMetadata_BeginImplFrameArgs kBeginImplFrameArgs{}; + template T* set_begin_impl_frame_args() { + return BeginNestedMessage(14); + } + + + using FieldMetadata_BeginFrameObserverState = + ::protozero::proto_utils::FieldMetadata< + 15, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + BeginFrameObserverState, + ChromeCompositorSchedulerState>; + + static constexpr FieldMetadata_BeginFrameObserverState kBeginFrameObserverState{}; + template T* set_begin_frame_observer_state() { + return BeginNestedMessage(15); + } + + + using FieldMetadata_BeginFrameSourceState = + ::protozero::proto_utils::FieldMetadata< + 16, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + BeginFrameSourceState, + ChromeCompositorSchedulerState>; + + static constexpr FieldMetadata_BeginFrameSourceState kBeginFrameSourceState{}; + template T* set_begin_frame_source_state() { + return BeginNestedMessage(16); + } + + + using FieldMetadata_CompositorTimingHistory = + ::protozero::proto_utils::FieldMetadata< + 17, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + CompositorTimingHistory, + ChromeCompositorSchedulerState>; + + static constexpr FieldMetadata_CompositorTimingHistory kCompositorTimingHistory{}; + template T* set_compositor_timing_history() { + return BeginNestedMessage(17); + } + +}; + +class ChromeApplicationStateInfo_Decoder : public ::protozero::TypedProtoDecoder { + public: + ChromeApplicationStateInfo_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ChromeApplicationStateInfo_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ChromeApplicationStateInfo_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_application_state() const { return at<1>().valid(); } + int32_t application_state() const { return at<1>().as_int32(); } +}; + +class ChromeApplicationStateInfo : public ::protozero::Message { + public: + using Decoder = ChromeApplicationStateInfo_Decoder; + enum : int32_t { + kApplicationStateFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ChromeApplicationStateInfo"; } + + + using ChromeApplicationState = ::perfetto::protos::pbzero::ChromeApplicationStateInfo_ChromeApplicationState; + static inline const char* ChromeApplicationState_Name(ChromeApplicationState value) { + return ::perfetto::protos::pbzero::ChromeApplicationStateInfo_ChromeApplicationState_Name(value); + } + static inline const ChromeApplicationState APPLICATION_STATE_UNKNOWN = ChromeApplicationState::APPLICATION_STATE_UNKNOWN; + static inline const ChromeApplicationState APPLICATION_STATE_HAS_RUNNING_ACTIVITIES = ChromeApplicationState::APPLICATION_STATE_HAS_RUNNING_ACTIVITIES; + static inline const ChromeApplicationState APPLICATION_STATE_HAS_PAUSED_ACTIVITIES = ChromeApplicationState::APPLICATION_STATE_HAS_PAUSED_ACTIVITIES; + static inline const ChromeApplicationState APPLICATION_STATE_HAS_STOPPED_ACTIVITIES = ChromeApplicationState::APPLICATION_STATE_HAS_STOPPED_ACTIVITIES; + static inline const ChromeApplicationState APPLICATION_STATE_HAS_DESTROYED_ACTIVITIES = ChromeApplicationState::APPLICATION_STATE_HAS_DESTROYED_ACTIVITIES; + + using FieldMetadata_ApplicationState = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + ChromeApplicationStateInfo_ChromeApplicationState, + ChromeApplicationStateInfo>; + + static constexpr FieldMetadata_ApplicationState kApplicationState{}; + void set_application_state(ChromeApplicationStateInfo_ChromeApplicationState value) { + static constexpr uint32_t field_id = FieldMetadata_ApplicationState::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } +}; + +class ChromeActiveProcesses_Decoder : public ::protozero::TypedProtoDecoder { + public: + ChromeActiveProcesses_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ChromeActiveProcesses_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ChromeActiveProcesses_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_pid() const { return at<1>().valid(); } + ::protozero::RepeatedFieldIterator pid() const { return GetRepeated(1); } +}; + +class ChromeActiveProcesses : public ::protozero::Message { + public: + using Decoder = ChromeActiveProcesses_Decoder; + enum : int32_t { + kPidFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ChromeActiveProcesses"; } + + + using FieldMetadata_Pid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + ChromeActiveProcesses>; + + static constexpr FieldMetadata_Pid kPid{}; + void add_pid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class SourceLocation_Decoder : public ::protozero::TypedProtoDecoder { + public: + SourceLocation_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit SourceLocation_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit SourceLocation_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_iid() const { return at<1>().valid(); } + uint64_t iid() const { return at<1>().as_uint64(); } + bool has_file_name() const { return at<2>().valid(); } + ::protozero::ConstChars file_name() const { return at<2>().as_string(); } + bool has_function_name() const { return at<3>().valid(); } + ::protozero::ConstChars function_name() const { return at<3>().as_string(); } + bool has_line_number() const { return at<4>().valid(); } + uint32_t line_number() const { return at<4>().as_uint32(); } +}; + +class SourceLocation : public ::protozero::Message { + public: + using Decoder = SourceLocation_Decoder; + enum : int32_t { + kIidFieldNumber = 1, + kFileNameFieldNumber = 2, + kFunctionNameFieldNumber = 3, + kLineNumberFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.SourceLocation"; } + + + using FieldMetadata_Iid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + SourceLocation>; + + static constexpr FieldMetadata_Iid kIid{}; + void set_iid(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Iid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FileName = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + SourceLocation>; + + static constexpr FieldMetadata_FileName kFileName{}; + void set_file_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_FileName::kFieldId, data, size); + } + void set_file_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_FileName::kFieldId, chars.data, chars.size); + } + void set_file_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_FileName::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FunctionName = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + SourceLocation>; + + static constexpr FieldMetadata_FunctionName kFunctionName{}; + void set_function_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_FunctionName::kFieldId, data, size); + } + void set_function_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_FunctionName::kFieldId, chars.data, chars.size); + } + void set_function_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_FunctionName::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_LineNumber = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SourceLocation>; + + static constexpr FieldMetadata_LineNumber kLineNumber{}; + void set_line_number(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_LineNumber::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class UnsymbolizedSourceLocation_Decoder : public ::protozero::TypedProtoDecoder { + public: + UnsymbolizedSourceLocation_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit UnsymbolizedSourceLocation_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit UnsymbolizedSourceLocation_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_iid() const { return at<1>().valid(); } + uint64_t iid() const { return at<1>().as_uint64(); } + bool has_mapping_id() const { return at<2>().valid(); } + uint64_t mapping_id() const { return at<2>().as_uint64(); } + bool has_rel_pc() const { return at<3>().valid(); } + uint64_t rel_pc() const { return at<3>().as_uint64(); } +}; + +class UnsymbolizedSourceLocation : public ::protozero::Message { + public: + using Decoder = UnsymbolizedSourceLocation_Decoder; + enum : int32_t { + kIidFieldNumber = 1, + kMappingIdFieldNumber = 2, + kRelPcFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.UnsymbolizedSourceLocation"; } + + + using FieldMetadata_Iid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + UnsymbolizedSourceLocation>; + + static constexpr FieldMetadata_Iid kIid{}; + void set_iid(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Iid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_MappingId = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + UnsymbolizedSourceLocation>; + + static constexpr FieldMetadata_MappingId kMappingId{}; + void set_mapping_id(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_MappingId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_RelPc = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + UnsymbolizedSourceLocation>; + + static constexpr FieldMetadata_RelPc kRelPc{}; + void set_rel_pc(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_RelPc::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class LogMessageBody_Decoder : public ::protozero::TypedProtoDecoder { + public: + LogMessageBody_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit LogMessageBody_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit LogMessageBody_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_iid() const { return at<1>().valid(); } + uint64_t iid() const { return at<1>().as_uint64(); } + bool has_body() const { return at<2>().valid(); } + ::protozero::ConstChars body() const { return at<2>().as_string(); } +}; + +class LogMessageBody : public ::protozero::Message { + public: + using Decoder = LogMessageBody_Decoder; + enum : int32_t { + kIidFieldNumber = 1, + kBodyFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.LogMessageBody"; } + + + using FieldMetadata_Iid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + LogMessageBody>; + + static constexpr FieldMetadata_Iid kIid{}; + void set_iid(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Iid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Body = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + LogMessageBody>; + + static constexpr FieldMetadata_Body kBody{}; + void set_body(const char* data, size_t size) { + AppendBytes(FieldMetadata_Body::kFieldId, data, size); + } + void set_body(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Body::kFieldId, chars.data, chars.size); + } + void set_body(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Body::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class LogMessage_Decoder : public ::protozero::TypedProtoDecoder { + public: + LogMessage_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit LogMessage_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit LogMessage_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_source_location_iid() const { return at<1>().valid(); } + uint64_t source_location_iid() const { return at<1>().as_uint64(); } + bool has_body_iid() const { return at<2>().valid(); } + uint64_t body_iid() const { return at<2>().as_uint64(); } + bool has_prio() const { return at<3>().valid(); } + int32_t prio() const { return at<3>().as_int32(); } +}; + +class LogMessage : public ::protozero::Message { + public: + using Decoder = LogMessage_Decoder; + enum : int32_t { + kSourceLocationIidFieldNumber = 1, + kBodyIidFieldNumber = 2, + kPrioFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.LogMessage"; } + + + using Priority = ::perfetto::protos::pbzero::LogMessage_Priority; + static inline const char* Priority_Name(Priority value) { + return ::perfetto::protos::pbzero::LogMessage_Priority_Name(value); + } + static inline const Priority PRIO_UNSPECIFIED = Priority::PRIO_UNSPECIFIED; + static inline const Priority PRIO_UNUSED = Priority::PRIO_UNUSED; + static inline const Priority PRIO_VERBOSE = Priority::PRIO_VERBOSE; + static inline const Priority PRIO_DEBUG = Priority::PRIO_DEBUG; + static inline const Priority PRIO_INFO = Priority::PRIO_INFO; + static inline const Priority PRIO_WARN = Priority::PRIO_WARN; + static inline const Priority PRIO_ERROR = Priority::PRIO_ERROR; + static inline const Priority PRIO_FATAL = Priority::PRIO_FATAL; + + using FieldMetadata_SourceLocationIid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + LogMessage>; + + static constexpr FieldMetadata_SourceLocationIid kSourceLocationIid{}; + void set_source_location_iid(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_SourceLocationIid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_BodyIid = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + LogMessage>; + + static constexpr FieldMetadata_BodyIid kBodyIid{}; + void set_body_iid(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_BodyIid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Prio = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + LogMessage_Priority, + LogMessage>; + + static constexpr FieldMetadata_Prio kPrio{}; + void set_prio(LogMessage_Priority value) { + static constexpr uint32_t field_id = FieldMetadata_Prio::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } +}; + +class DebugAnnotationValueTypeName_Decoder : public ::protozero::TypedProtoDecoder { + public: + DebugAnnotationValueTypeName_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit DebugAnnotationValueTypeName_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit DebugAnnotationValueTypeName_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_iid() const { return at<1>().valid(); } + uint64_t iid() const { return at<1>().as_uint64(); } + bool has_name() const { return at<2>().valid(); } + ::protozero::ConstChars name() const { return at<2>().as_string(); } +}; + +class DebugAnnotationValueTypeName : public ::protozero::Message { + public: + using Decoder = DebugAnnotationValueTypeName_Decoder; + enum : int32_t { + kIidFieldNumber = 1, + kNameFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.DebugAnnotationValueTypeName"; } + + + using FieldMetadata_Iid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + DebugAnnotationValueTypeName>; + + static constexpr FieldMetadata_Iid kIid{}; + void set_iid(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Iid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + DebugAnnotationValueTypeName>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class DebugAnnotationName_Decoder : public ::protozero::TypedProtoDecoder { + public: + DebugAnnotationName_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit DebugAnnotationName_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit DebugAnnotationName_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_iid() const { return at<1>().valid(); } + uint64_t iid() const { return at<1>().as_uint64(); } + bool has_name() const { return at<2>().valid(); } + ::protozero::ConstChars name() const { return at<2>().as_string(); } +}; + +class DebugAnnotationName : public ::protozero::Message { + public: + using Decoder = DebugAnnotationName_Decoder; + enum : int32_t { + kIidFieldNumber = 1, + kNameFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.DebugAnnotationName"; } + + + using FieldMetadata_Iid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + DebugAnnotationName>; + + static constexpr FieldMetadata_Iid kIid{}; + void set_iid(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Iid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + DebugAnnotationName>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class DebugAnnotation_Decoder : public ::protozero::TypedProtoDecoder { + public: + DebugAnnotation_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit DebugAnnotation_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit DebugAnnotation_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_name_iid() const { return at<1>().valid(); } + uint64_t name_iid() const { return at<1>().as_uint64(); } + bool has_name() const { return at<10>().valid(); } + ::protozero::ConstChars name() const { return at<10>().as_string(); } + bool has_bool_value() const { return at<2>().valid(); } + bool bool_value() const { return at<2>().as_bool(); } + bool has_uint_value() const { return at<3>().valid(); } + uint64_t uint_value() const { return at<3>().as_uint64(); } + bool has_int_value() const { return at<4>().valid(); } + int64_t int_value() const { return at<4>().as_int64(); } + bool has_double_value() const { return at<5>().valid(); } + double double_value() const { return at<5>().as_double(); } + bool has_pointer_value() const { return at<7>().valid(); } + uint64_t pointer_value() const { return at<7>().as_uint64(); } + bool has_nested_value() const { return at<8>().valid(); } + ::protozero::ConstBytes nested_value() const { return at<8>().as_bytes(); } + bool has_legacy_json_value() const { return at<9>().valid(); } + ::protozero::ConstChars legacy_json_value() const { return at<9>().as_string(); } + bool has_string_value() const { return at<6>().valid(); } + ::protozero::ConstChars string_value() const { return at<6>().as_string(); } + bool has_string_value_iid() const { return at<17>().valid(); } + uint64_t string_value_iid() const { return at<17>().as_uint64(); } + bool has_proto_type_name() const { return at<16>().valid(); } + ::protozero::ConstChars proto_type_name() const { return at<16>().as_string(); } + bool has_proto_type_name_iid() const { return at<13>().valid(); } + uint64_t proto_type_name_iid() const { return at<13>().as_uint64(); } + bool has_proto_value() const { return at<14>().valid(); } + ::protozero::ConstBytes proto_value() const { return at<14>().as_bytes(); } + bool has_dict_entries() const { return at<11>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> dict_entries() const { return GetRepeated<::protozero::ConstBytes>(11); } + bool has_array_values() const { return at<12>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> array_values() const { return GetRepeated<::protozero::ConstBytes>(12); } +}; + +class DebugAnnotation : public ::protozero::Message { + public: + using Decoder = DebugAnnotation_Decoder; + enum : int32_t { + kNameIidFieldNumber = 1, + kNameFieldNumber = 10, + kBoolValueFieldNumber = 2, + kUintValueFieldNumber = 3, + kIntValueFieldNumber = 4, + kDoubleValueFieldNumber = 5, + kPointerValueFieldNumber = 7, + kNestedValueFieldNumber = 8, + kLegacyJsonValueFieldNumber = 9, + kStringValueFieldNumber = 6, + kStringValueIidFieldNumber = 17, + kProtoTypeNameFieldNumber = 16, + kProtoTypeNameIidFieldNumber = 13, + kProtoValueFieldNumber = 14, + kDictEntriesFieldNumber = 11, + kArrayValuesFieldNumber = 12, + }; + static constexpr const char* GetName() { return ".perfetto.protos.DebugAnnotation"; } + + using NestedValue = ::perfetto::protos::pbzero::DebugAnnotation_NestedValue; + + using FieldMetadata_NameIid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + DebugAnnotation>; + + static constexpr FieldMetadata_NameIid kNameIid{}; + void set_name_iid(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_NameIid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + DebugAnnotation>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_BoolValue = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + DebugAnnotation>; + + static constexpr FieldMetadata_BoolValue kBoolValue{}; + void set_bool_value(bool value) { + static constexpr uint32_t field_id = FieldMetadata_BoolValue::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_UintValue = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + DebugAnnotation>; + + static constexpr FieldMetadata_UintValue kUintValue{}; + void set_uint_value(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_UintValue::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_IntValue = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + DebugAnnotation>; + + static constexpr FieldMetadata_IntValue kIntValue{}; + void set_int_value(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_IntValue::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DoubleValue = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kDouble, + double, + DebugAnnotation>; + + static constexpr FieldMetadata_DoubleValue kDoubleValue{}; + void set_double_value(double value) { + static constexpr uint32_t field_id = FieldMetadata_DoubleValue::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kDouble> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PointerValue = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + DebugAnnotation>; + + static constexpr FieldMetadata_PointerValue kPointerValue{}; + void set_pointer_value(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_PointerValue::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NestedValue = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + DebugAnnotation_NestedValue, + DebugAnnotation>; + + static constexpr FieldMetadata_NestedValue kNestedValue{}; + template T* set_nested_value() { + return BeginNestedMessage(8); + } + + + using FieldMetadata_LegacyJsonValue = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + DebugAnnotation>; + + static constexpr FieldMetadata_LegacyJsonValue kLegacyJsonValue{}; + void set_legacy_json_value(const char* data, size_t size) { + AppendBytes(FieldMetadata_LegacyJsonValue::kFieldId, data, size); + } + void set_legacy_json_value(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_LegacyJsonValue::kFieldId, chars.data, chars.size); + } + void set_legacy_json_value(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_LegacyJsonValue::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_StringValue = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + DebugAnnotation>; + + static constexpr FieldMetadata_StringValue kStringValue{}; + void set_string_value(const char* data, size_t size) { + AppendBytes(FieldMetadata_StringValue::kFieldId, data, size); + } + void set_string_value(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_StringValue::kFieldId, chars.data, chars.size); + } + void set_string_value(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_StringValue::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_StringValueIid = + ::protozero::proto_utils::FieldMetadata< + 17, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + DebugAnnotation>; + + static constexpr FieldMetadata_StringValueIid kStringValueIid{}; + void set_string_value_iid(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_StringValueIid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ProtoTypeName = + ::protozero::proto_utils::FieldMetadata< + 16, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + DebugAnnotation>; + + static constexpr FieldMetadata_ProtoTypeName kProtoTypeName{}; + void set_proto_type_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_ProtoTypeName::kFieldId, data, size); + } + void set_proto_type_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_ProtoTypeName::kFieldId, chars.data, chars.size); + } + void set_proto_type_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_ProtoTypeName::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ProtoTypeNameIid = + ::protozero::proto_utils::FieldMetadata< + 13, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + DebugAnnotation>; + + static constexpr FieldMetadata_ProtoTypeNameIid kProtoTypeNameIid{}; + void set_proto_type_name_iid(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_ProtoTypeNameIid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ProtoValue = + ::protozero::proto_utils::FieldMetadata< + 14, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBytes, + std::string, + DebugAnnotation>; + + static constexpr FieldMetadata_ProtoValue kProtoValue{}; + void set_proto_value(const uint8_t* data, size_t size) { + AppendBytes(FieldMetadata_ProtoValue::kFieldId, data, size); + } + void set_proto_value(::protozero::ConstBytes bytes) { + AppendBytes(FieldMetadata_ProtoValue::kFieldId, bytes.data, bytes.size); + } + void set_proto_value(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_ProtoValue::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBytes> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DictEntries = + ::protozero::proto_utils::FieldMetadata< + 11, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + DebugAnnotation, + DebugAnnotation>; + + static constexpr FieldMetadata_DictEntries kDictEntries{}; + template T* add_dict_entries() { + return BeginNestedMessage(11); + } + + + using FieldMetadata_ArrayValues = + ::protozero::proto_utils::FieldMetadata< + 12, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + DebugAnnotation, + DebugAnnotation>; + + static constexpr FieldMetadata_ArrayValues kArrayValues{}; + template T* add_array_values() { + return BeginNestedMessage(12); + } + +}; + +class DebugAnnotation_NestedValue_Decoder : public ::protozero::TypedProtoDecoder { + public: + DebugAnnotation_NestedValue_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit DebugAnnotation_NestedValue_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit DebugAnnotation_NestedValue_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_nested_type() const { return at<1>().valid(); } + int32_t nested_type() const { return at<1>().as_int32(); } + bool has_dict_keys() const { return at<2>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstChars> dict_keys() const { return GetRepeated<::protozero::ConstChars>(2); } + bool has_dict_values() const { return at<3>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> dict_values() const { return GetRepeated<::protozero::ConstBytes>(3); } + bool has_array_values() const { return at<4>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> array_values() const { return GetRepeated<::protozero::ConstBytes>(4); } + bool has_int_value() const { return at<5>().valid(); } + int64_t int_value() const { return at<5>().as_int64(); } + bool has_double_value() const { return at<6>().valid(); } + double double_value() const { return at<6>().as_double(); } + bool has_bool_value() const { return at<7>().valid(); } + bool bool_value() const { return at<7>().as_bool(); } + bool has_string_value() const { return at<8>().valid(); } + ::protozero::ConstChars string_value() const { return at<8>().as_string(); } +}; + +class DebugAnnotation_NestedValue : public ::protozero::Message { + public: + using Decoder = DebugAnnotation_NestedValue_Decoder; + enum : int32_t { + kNestedTypeFieldNumber = 1, + kDictKeysFieldNumber = 2, + kDictValuesFieldNumber = 3, + kArrayValuesFieldNumber = 4, + kIntValueFieldNumber = 5, + kDoubleValueFieldNumber = 6, + kBoolValueFieldNumber = 7, + kStringValueFieldNumber = 8, + }; + static constexpr const char* GetName() { return ".perfetto.protos.DebugAnnotation.NestedValue"; } + + + using NestedType = ::perfetto::protos::pbzero::DebugAnnotation_NestedValue_NestedType; + static inline const char* NestedType_Name(NestedType value) { + return ::perfetto::protos::pbzero::DebugAnnotation_NestedValue_NestedType_Name(value); + } + static inline const NestedType UNSPECIFIED = NestedType::UNSPECIFIED; + static inline const NestedType DICT = NestedType::DICT; + static inline const NestedType ARRAY = NestedType::ARRAY; + + using FieldMetadata_NestedType = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + DebugAnnotation_NestedValue_NestedType, + DebugAnnotation_NestedValue>; + + static constexpr FieldMetadata_NestedType kNestedType{}; + void set_nested_type(DebugAnnotation_NestedValue_NestedType value) { + static constexpr uint32_t field_id = FieldMetadata_NestedType::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DictKeys = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + DebugAnnotation_NestedValue>; + + static constexpr FieldMetadata_DictKeys kDictKeys{}; + void add_dict_keys(const char* data, size_t size) { + AppendBytes(FieldMetadata_DictKeys::kFieldId, data, size); + } + void add_dict_keys(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_DictKeys::kFieldId, chars.data, chars.size); + } + void add_dict_keys(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_DictKeys::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DictValues = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + DebugAnnotation_NestedValue, + DebugAnnotation_NestedValue>; + + static constexpr FieldMetadata_DictValues kDictValues{}; + template T* add_dict_values() { + return BeginNestedMessage(3); + } + + + using FieldMetadata_ArrayValues = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + DebugAnnotation_NestedValue, + DebugAnnotation_NestedValue>; + + static constexpr FieldMetadata_ArrayValues kArrayValues{}; + template T* add_array_values() { + return BeginNestedMessage(4); + } + + + using FieldMetadata_IntValue = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + DebugAnnotation_NestedValue>; + + static constexpr FieldMetadata_IntValue kIntValue{}; + void set_int_value(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_IntValue::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DoubleValue = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kDouble, + double, + DebugAnnotation_NestedValue>; + + static constexpr FieldMetadata_DoubleValue kDoubleValue{}; + void set_double_value(double value) { + static constexpr uint32_t field_id = FieldMetadata_DoubleValue::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kDouble> + ::Append(*this, field_id, value); + } + + using FieldMetadata_BoolValue = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + DebugAnnotation_NestedValue>; + + static constexpr FieldMetadata_BoolValue kBoolValue{}; + void set_bool_value(bool value) { + static constexpr uint32_t field_id = FieldMetadata_BoolValue::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_StringValue = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + DebugAnnotation_NestedValue>; + + static constexpr FieldMetadata_StringValue kStringValue{}; + void set_string_value(const char* data, size_t size) { + AppendBytes(FieldMetadata_StringValue::kFieldId, data, size); + } + void set_string_value(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_StringValue::kFieldId, chars.data, chars.size); + } + void set_string_value(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_StringValue::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class ChromeHistogramSample_Decoder : public ::protozero::TypedProtoDecoder { + public: + ChromeHistogramSample_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ChromeHistogramSample_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ChromeHistogramSample_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_name_hash() const { return at<1>().valid(); } + uint64_t name_hash() const { return at<1>().as_uint64(); } + bool has_name() const { return at<2>().valid(); } + ::protozero::ConstChars name() const { return at<2>().as_string(); } + bool has_sample() const { return at<3>().valid(); } + int64_t sample() const { return at<3>().as_int64(); } + bool has_name_iid() const { return at<4>().valid(); } + uint64_t name_iid() const { return at<4>().as_uint64(); } +}; + +class ChromeHistogramSample : public ::protozero::Message { + public: + using Decoder = ChromeHistogramSample_Decoder; + enum : int32_t { + kNameHashFieldNumber = 1, + kNameFieldNumber = 2, + kSampleFieldNumber = 3, + kNameIidFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ChromeHistogramSample"; } + + + using FieldMetadata_NameHash = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + ChromeHistogramSample>; + + static constexpr FieldMetadata_NameHash kNameHash{}; + void set_name_hash(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_NameHash::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + ChromeHistogramSample>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Sample = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + ChromeHistogramSample>; + + static constexpr FieldMetadata_Sample kSample{}; + void set_sample(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Sample::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NameIid = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + ChromeHistogramSample>; + + static constexpr FieldMetadata_NameIid kNameIid{}; + void set_name_iid(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_NameIid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class HistogramName_Decoder : public ::protozero::TypedProtoDecoder { + public: + HistogramName_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit HistogramName_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit HistogramName_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_iid() const { return at<1>().valid(); } + uint64_t iid() const { return at<1>().as_uint64(); } + bool has_name() const { return at<2>().valid(); } + ::protozero::ConstChars name() const { return at<2>().as_string(); } +}; + +class HistogramName : public ::protozero::Message { + public: + using Decoder = HistogramName_Decoder; + enum : int32_t { + kIidFieldNumber = 1, + kNameFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.HistogramName"; } + + + using FieldMetadata_Iid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + HistogramName>; + + static constexpr FieldMetadata_Iid kIid{}; + void set_iid(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Iid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + HistogramName>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class Callstack_Decoder : public ::protozero::TypedProtoDecoder { + public: + Callstack_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Callstack_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Callstack_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_iid() const { return at<1>().valid(); } + uint64_t iid() const { return at<1>().as_uint64(); } + bool has_frame_ids() const { return at<2>().valid(); } + ::protozero::RepeatedFieldIterator frame_ids() const { return GetRepeated(2); } +}; + +class Callstack : public ::protozero::Message { + public: + using Decoder = Callstack_Decoder; + enum : int32_t { + kIidFieldNumber = 1, + kFrameIdsFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Callstack"; } + + + using FieldMetadata_Iid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Callstack>; + + static constexpr FieldMetadata_Iid kIid{}; + void set_iid(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Iid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FrameIds = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Callstack>; + + static constexpr FieldMetadata_FrameIds kFrameIds{}; + void add_frame_ids(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_FrameIds::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class Frame_Decoder : public ::protozero::TypedProtoDecoder { + public: + Frame_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Frame_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Frame_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_iid() const { return at<1>().valid(); } + uint64_t iid() const { return at<1>().as_uint64(); } + bool has_function_name_id() const { return at<2>().valid(); } + uint64_t function_name_id() const { return at<2>().as_uint64(); } + bool has_mapping_id() const { return at<3>().valid(); } + uint64_t mapping_id() const { return at<3>().as_uint64(); } + bool has_rel_pc() const { return at<4>().valid(); } + uint64_t rel_pc() const { return at<4>().as_uint64(); } +}; + +class Frame : public ::protozero::Message { + public: + using Decoder = Frame_Decoder; + enum : int32_t { + kIidFieldNumber = 1, + kFunctionNameIdFieldNumber = 2, + kMappingIdFieldNumber = 3, + kRelPcFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Frame"; } + + + using FieldMetadata_Iid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Frame>; + + static constexpr FieldMetadata_Iid kIid{}; + void set_iid(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Iid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FunctionNameId = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Frame>; + + static constexpr FieldMetadata_FunctionNameId kFunctionNameId{}; + void set_function_name_id(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_FunctionNameId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_MappingId = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Frame>; + + static constexpr FieldMetadata_MappingId kMappingId{}; + void set_mapping_id(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_MappingId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_RelPc = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Frame>; + + static constexpr FieldMetadata_RelPc kRelPc{}; + void set_rel_pc(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_RelPc::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class Mapping_Decoder : public ::protozero::TypedProtoDecoder { + public: + Mapping_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Mapping_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Mapping_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_iid() const { return at<1>().valid(); } + uint64_t iid() const { return at<1>().as_uint64(); } + bool has_build_id() const { return at<2>().valid(); } + uint64_t build_id() const { return at<2>().as_uint64(); } + bool has_exact_offset() const { return at<8>().valid(); } + uint64_t exact_offset() const { return at<8>().as_uint64(); } + bool has_start_offset() const { return at<3>().valid(); } + uint64_t start_offset() const { return at<3>().as_uint64(); } + bool has_start() const { return at<4>().valid(); } + uint64_t start() const { return at<4>().as_uint64(); } + bool has_end() const { return at<5>().valid(); } + uint64_t end() const { return at<5>().as_uint64(); } + bool has_load_bias() const { return at<6>().valid(); } + uint64_t load_bias() const { return at<6>().as_uint64(); } + bool has_path_string_ids() const { return at<7>().valid(); } + ::protozero::RepeatedFieldIterator path_string_ids() const { return GetRepeated(7); } +}; + +class Mapping : public ::protozero::Message { + public: + using Decoder = Mapping_Decoder; + enum : int32_t { + kIidFieldNumber = 1, + kBuildIdFieldNumber = 2, + kExactOffsetFieldNumber = 8, + kStartOffsetFieldNumber = 3, + kStartFieldNumber = 4, + kEndFieldNumber = 5, + kLoadBiasFieldNumber = 6, + kPathStringIdsFieldNumber = 7, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Mapping"; } + + + using FieldMetadata_Iid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Mapping>; + + static constexpr FieldMetadata_Iid kIid{}; + void set_iid(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Iid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_BuildId = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Mapping>; + + static constexpr FieldMetadata_BuildId kBuildId{}; + void set_build_id(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_BuildId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ExactOffset = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Mapping>; + + static constexpr FieldMetadata_ExactOffset kExactOffset{}; + void set_exact_offset(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_ExactOffset::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_StartOffset = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Mapping>; + + static constexpr FieldMetadata_StartOffset kStartOffset{}; + void set_start_offset(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_StartOffset::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Start = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Mapping>; + + static constexpr FieldMetadata_Start kStart{}; + void set_start(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Start::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_End = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Mapping>; + + static constexpr FieldMetadata_End kEnd{}; + void set_end(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_End::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_LoadBias = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Mapping>; + + static constexpr FieldMetadata_LoadBias kLoadBias{}; + void set_load_bias(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_LoadBias::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PathStringIds = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Mapping>; + + static constexpr FieldMetadata_PathStringIds kPathStringIds{}; + void add_path_string_ids(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_PathStringIds::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class ModuleSymbols_Decoder : public ::protozero::TypedProtoDecoder { + public: + ModuleSymbols_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ModuleSymbols_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ModuleSymbols_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_path() const { return at<1>().valid(); } + ::protozero::ConstChars path() const { return at<1>().as_string(); } + bool has_build_id() const { return at<2>().valid(); } + ::protozero::ConstChars build_id() const { return at<2>().as_string(); } + bool has_address_symbols() const { return at<3>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> address_symbols() const { return GetRepeated<::protozero::ConstBytes>(3); } +}; + +class ModuleSymbols : public ::protozero::Message { + public: + using Decoder = ModuleSymbols_Decoder; + enum : int32_t { + kPathFieldNumber = 1, + kBuildIdFieldNumber = 2, + kAddressSymbolsFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ModuleSymbols"; } + + + using FieldMetadata_Path = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + ModuleSymbols>; + + static constexpr FieldMetadata_Path kPath{}; + void set_path(const char* data, size_t size) { + AppendBytes(FieldMetadata_Path::kFieldId, data, size); + } + void set_path(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Path::kFieldId, chars.data, chars.size); + } + void set_path(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Path::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_BuildId = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + ModuleSymbols>; + + static constexpr FieldMetadata_BuildId kBuildId{}; + void set_build_id(const char* data, size_t size) { + AppendBytes(FieldMetadata_BuildId::kFieldId, data, size); + } + void set_build_id(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_BuildId::kFieldId, chars.data, chars.size); + } + void set_build_id(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_BuildId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_AddressSymbols = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + AddressSymbols, + ModuleSymbols>; + + static constexpr FieldMetadata_AddressSymbols kAddressSymbols{}; + template T* add_address_symbols() { + return BeginNestedMessage(3); + } + +}; + +class AddressSymbols_Decoder : public ::protozero::TypedProtoDecoder { + public: + AddressSymbols_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit AddressSymbols_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit AddressSymbols_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_address() const { return at<1>().valid(); } + uint64_t address() const { return at<1>().as_uint64(); } + bool has_lines() const { return at<2>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> lines() const { return GetRepeated<::protozero::ConstBytes>(2); } +}; + +class AddressSymbols : public ::protozero::Message { + public: + using Decoder = AddressSymbols_Decoder; + enum : int32_t { + kAddressFieldNumber = 1, + kLinesFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.AddressSymbols"; } + + + using FieldMetadata_Address = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + AddressSymbols>; + + static constexpr FieldMetadata_Address kAddress{}; + void set_address(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Address::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Lines = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Line, + AddressSymbols>; + + static constexpr FieldMetadata_Lines kLines{}; + template T* add_lines() { + return BeginNestedMessage(2); + } + +}; + +class Line_Decoder : public ::protozero::TypedProtoDecoder { + public: + Line_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Line_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Line_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_function_name() const { return at<1>().valid(); } + ::protozero::ConstChars function_name() const { return at<1>().as_string(); } + bool has_source_file_name() const { return at<2>().valid(); } + ::protozero::ConstChars source_file_name() const { return at<2>().as_string(); } + bool has_line_number() const { return at<3>().valid(); } + uint32_t line_number() const { return at<3>().as_uint32(); } +}; + +class Line : public ::protozero::Message { + public: + using Decoder = Line_Decoder; + enum : int32_t { + kFunctionNameFieldNumber = 1, + kSourceFileNameFieldNumber = 2, + kLineNumberFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Line"; } + + + using FieldMetadata_FunctionName = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + Line>; + + static constexpr FieldMetadata_FunctionName kFunctionName{}; + void set_function_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_FunctionName::kFieldId, data, size); + } + void set_function_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_FunctionName::kFieldId, chars.data, chars.size); + } + void set_function_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_FunctionName::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SourceFileName = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + Line>; + + static constexpr FieldMetadata_SourceFileName kSourceFileName{}; + void set_source_file_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_SourceFileName::kFieldId, data, size); + } + void set_source_file_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_SourceFileName::kFieldId, chars.data, chars.size); + } + void set_source_file_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_SourceFileName::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_LineNumber = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Line>; + + static constexpr FieldMetadata_LineNumber kLineNumber{}; + void set_line_number(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_LineNumber::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class ProfiledFrameSymbols_Decoder : public ::protozero::TypedProtoDecoder { + public: + ProfiledFrameSymbols_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ProfiledFrameSymbols_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ProfiledFrameSymbols_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_frame_iid() const { return at<1>().valid(); } + uint64_t frame_iid() const { return at<1>().as_uint64(); } + bool has_function_name_id() const { return at<2>().valid(); } + ::protozero::RepeatedFieldIterator function_name_id() const { return GetRepeated(2); } + bool has_file_name_id() const { return at<3>().valid(); } + ::protozero::RepeatedFieldIterator file_name_id() const { return GetRepeated(3); } + bool has_line_number() const { return at<4>().valid(); } + ::protozero::RepeatedFieldIterator line_number() const { return GetRepeated(4); } +}; + +class ProfiledFrameSymbols : public ::protozero::Message { + public: + using Decoder = ProfiledFrameSymbols_Decoder; + enum : int32_t { + kFrameIidFieldNumber = 1, + kFunctionNameIdFieldNumber = 2, + kFileNameIdFieldNumber = 3, + kLineNumberFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ProfiledFrameSymbols"; } + + + using FieldMetadata_FrameIid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + ProfiledFrameSymbols>; + + static constexpr FieldMetadata_FrameIid kFrameIid{}; + void set_frame_iid(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_FrameIid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FunctionNameId = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + ProfiledFrameSymbols>; + + static constexpr FieldMetadata_FunctionNameId kFunctionNameId{}; + void add_function_name_id(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_FunctionNameId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FileNameId = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + ProfiledFrameSymbols>; + + static constexpr FieldMetadata_FileNameId kFileNameId{}; + void add_file_name_id(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_FileNameId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_LineNumber = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + ProfiledFrameSymbols>; + + static constexpr FieldMetadata_LineNumber kLineNumber{}; + void add_line_number(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_LineNumber::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class InternedString_Decoder : public ::protozero::TypedProtoDecoder { + public: + InternedString_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit InternedString_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit InternedString_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_iid() const { return at<1>().valid(); } + uint64_t iid() const { return at<1>().as_uint64(); } + bool has_str() const { return at<2>().valid(); } + ::protozero::ConstBytes str() const { return at<2>().as_bytes(); } +}; + +class InternedString : public ::protozero::Message { + public: + using Decoder = InternedString_Decoder; + enum : int32_t { + kIidFieldNumber = 1, + kStrFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.InternedString"; } + + + using FieldMetadata_Iid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + InternedString>; + + static constexpr FieldMetadata_Iid kIid{}; + void set_iid(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Iid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Str = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBytes, + std::string, + InternedString>; + + static constexpr FieldMetadata_Str kStr{}; + void set_str(const uint8_t* data, size_t size) { + AppendBytes(FieldMetadata_Str::kFieldId, data, size); + } + void set_str(::protozero::ConstBytes bytes) { + AppendBytes(FieldMetadata_Str::kFieldId, bytes.data, bytes.size); + } + void set_str(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Str::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBytes> + ::Append(*this, field_id, value); + } +}; + +class VulkanMemoryEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + VulkanMemoryEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit VulkanMemoryEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit VulkanMemoryEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_source() const { return at<1>().valid(); } + int32_t source() const { return at<1>().as_int32(); } + bool has_operation() const { return at<2>().valid(); } + int32_t operation() const { return at<2>().as_int32(); } + bool has_timestamp() const { return at<3>().valid(); } + int64_t timestamp() const { return at<3>().as_int64(); } + bool has_pid() const { return at<4>().valid(); } + uint32_t pid() const { return at<4>().as_uint32(); } + bool has_memory_address() const { return at<5>().valid(); } + uint64_t memory_address() const { return at<5>().as_uint64(); } + bool has_memory_size() const { return at<6>().valid(); } + uint64_t memory_size() const { return at<6>().as_uint64(); } + bool has_caller_iid() const { return at<7>().valid(); } + uint64_t caller_iid() const { return at<7>().as_uint64(); } + bool has_allocation_scope() const { return at<8>().valid(); } + int32_t allocation_scope() const { return at<8>().as_int32(); } + bool has_annotations() const { return at<9>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> annotations() const { return GetRepeated<::protozero::ConstBytes>(9); } + bool has_device() const { return at<16>().valid(); } + uint64_t device() const { return at<16>().as_uint64(); } + bool has_device_memory() const { return at<17>().valid(); } + uint64_t device_memory() const { return at<17>().as_uint64(); } + bool has_memory_type() const { return at<18>().valid(); } + uint32_t memory_type() const { return at<18>().as_uint32(); } + bool has_heap() const { return at<19>().valid(); } + uint32_t heap() const { return at<19>().as_uint32(); } + bool has_object_handle() const { return at<20>().valid(); } + uint64_t object_handle() const { return at<20>().as_uint64(); } +}; + +class VulkanMemoryEvent : public ::protozero::Message { + public: + using Decoder = VulkanMemoryEvent_Decoder; + enum : int32_t { + kSourceFieldNumber = 1, + kOperationFieldNumber = 2, + kTimestampFieldNumber = 3, + kPidFieldNumber = 4, + kMemoryAddressFieldNumber = 5, + kMemorySizeFieldNumber = 6, + kCallerIidFieldNumber = 7, + kAllocationScopeFieldNumber = 8, + kAnnotationsFieldNumber = 9, + kDeviceFieldNumber = 16, + kDeviceMemoryFieldNumber = 17, + kMemoryTypeFieldNumber = 18, + kHeapFieldNumber = 19, + kObjectHandleFieldNumber = 20, + }; + static constexpr const char* GetName() { return ".perfetto.protos.VulkanMemoryEvent"; } + + + using Source = ::perfetto::protos::pbzero::VulkanMemoryEvent_Source; + static inline const char* Source_Name(Source value) { + return ::perfetto::protos::pbzero::VulkanMemoryEvent_Source_Name(value); + } + + using Operation = ::perfetto::protos::pbzero::VulkanMemoryEvent_Operation; + static inline const char* Operation_Name(Operation value) { + return ::perfetto::protos::pbzero::VulkanMemoryEvent_Operation_Name(value); + } + + using AllocationScope = ::perfetto::protos::pbzero::VulkanMemoryEvent_AllocationScope; + static inline const char* AllocationScope_Name(AllocationScope value) { + return ::perfetto::protos::pbzero::VulkanMemoryEvent_AllocationScope_Name(value); + } + static inline const Source SOURCE_UNSPECIFIED = Source::SOURCE_UNSPECIFIED; + static inline const Source SOURCE_DRIVER = Source::SOURCE_DRIVER; + static inline const Source SOURCE_DEVICE = Source::SOURCE_DEVICE; + static inline const Source SOURCE_DEVICE_MEMORY = Source::SOURCE_DEVICE_MEMORY; + static inline const Source SOURCE_BUFFER = Source::SOURCE_BUFFER; + static inline const Source SOURCE_IMAGE = Source::SOURCE_IMAGE; + static inline const Operation OP_UNSPECIFIED = Operation::OP_UNSPECIFIED; + static inline const Operation OP_CREATE = Operation::OP_CREATE; + static inline const Operation OP_DESTROY = Operation::OP_DESTROY; + static inline const Operation OP_BIND = Operation::OP_BIND; + static inline const Operation OP_DESTROY_BOUND = Operation::OP_DESTROY_BOUND; + static inline const Operation OP_ANNOTATIONS = Operation::OP_ANNOTATIONS; + static inline const AllocationScope SCOPE_UNSPECIFIED = AllocationScope::SCOPE_UNSPECIFIED; + static inline const AllocationScope SCOPE_COMMAND = AllocationScope::SCOPE_COMMAND; + static inline const AllocationScope SCOPE_OBJECT = AllocationScope::SCOPE_OBJECT; + static inline const AllocationScope SCOPE_CACHE = AllocationScope::SCOPE_CACHE; + static inline const AllocationScope SCOPE_DEVICE = AllocationScope::SCOPE_DEVICE; + static inline const AllocationScope SCOPE_INSTANCE = AllocationScope::SCOPE_INSTANCE; + + using FieldMetadata_Source = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + VulkanMemoryEvent_Source, + VulkanMemoryEvent>; + + static constexpr FieldMetadata_Source kSource{}; + void set_source(VulkanMemoryEvent_Source value) { + static constexpr uint32_t field_id = FieldMetadata_Source::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Operation = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + VulkanMemoryEvent_Operation, + VulkanMemoryEvent>; + + static constexpr FieldMetadata_Operation kOperation{}; + void set_operation(VulkanMemoryEvent_Operation value) { + static constexpr uint32_t field_id = FieldMetadata_Operation::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Timestamp = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + VulkanMemoryEvent>; + + static constexpr FieldMetadata_Timestamp kTimestamp{}; + void set_timestamp(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Timestamp::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pid = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + VulkanMemoryEvent>; + + static constexpr FieldMetadata_Pid kPid{}; + void set_pid(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_MemoryAddress = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFixed64, + uint64_t, + VulkanMemoryEvent>; + + static constexpr FieldMetadata_MemoryAddress kMemoryAddress{}; + void set_memory_address(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_MemoryAddress::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFixed64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_MemorySize = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + VulkanMemoryEvent>; + + static constexpr FieldMetadata_MemorySize kMemorySize{}; + void set_memory_size(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_MemorySize::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CallerIid = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + VulkanMemoryEvent>; + + static constexpr FieldMetadata_CallerIid kCallerIid{}; + void set_caller_iid(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_CallerIid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_AllocationScope = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + VulkanMemoryEvent_AllocationScope, + VulkanMemoryEvent>; + + static constexpr FieldMetadata_AllocationScope kAllocationScope{}; + void set_allocation_scope(VulkanMemoryEvent_AllocationScope value) { + static constexpr uint32_t field_id = FieldMetadata_AllocationScope::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Annotations = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + VulkanMemoryEventAnnotation, + VulkanMemoryEvent>; + + static constexpr FieldMetadata_Annotations kAnnotations{}; + template T* add_annotations() { + return BeginNestedMessage(9); + } + + + using FieldMetadata_Device = + ::protozero::proto_utils::FieldMetadata< + 16, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFixed64, + uint64_t, + VulkanMemoryEvent>; + + static constexpr FieldMetadata_Device kDevice{}; + void set_device(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Device::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFixed64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DeviceMemory = + ::protozero::proto_utils::FieldMetadata< + 17, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFixed64, + uint64_t, + VulkanMemoryEvent>; + + static constexpr FieldMetadata_DeviceMemory kDeviceMemory{}; + void set_device_memory(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_DeviceMemory::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFixed64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_MemoryType = + ::protozero::proto_utils::FieldMetadata< + 18, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + VulkanMemoryEvent>; + + static constexpr FieldMetadata_MemoryType kMemoryType{}; + void set_memory_type(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_MemoryType::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Heap = + ::protozero::proto_utils::FieldMetadata< + 19, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + VulkanMemoryEvent>; + + static constexpr FieldMetadata_Heap kHeap{}; + void set_heap(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Heap::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ObjectHandle = + ::protozero::proto_utils::FieldMetadata< + 20, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFixed64, + uint64_t, + VulkanMemoryEvent>; + + static constexpr FieldMetadata_ObjectHandle kObjectHandle{}; + void set_object_handle(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_ObjectHandle::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFixed64> + ::Append(*this, field_id, value); + } +}; + +class VulkanMemoryEventAnnotation_Decoder : public ::protozero::TypedProtoDecoder { + public: + VulkanMemoryEventAnnotation_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit VulkanMemoryEventAnnotation_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit VulkanMemoryEventAnnotation_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_key_iid() const { return at<1>().valid(); } + uint64_t key_iid() const { return at<1>().as_uint64(); } + bool has_int_value() const { return at<2>().valid(); } + int64_t int_value() const { return at<2>().as_int64(); } + bool has_double_value() const { return at<3>().valid(); } + double double_value() const { return at<3>().as_double(); } + bool has_string_iid() const { return at<4>().valid(); } + uint64_t string_iid() const { return at<4>().as_uint64(); } +}; + +class VulkanMemoryEventAnnotation : public ::protozero::Message { + public: + using Decoder = VulkanMemoryEventAnnotation_Decoder; + enum : int32_t { + kKeyIidFieldNumber = 1, + kIntValueFieldNumber = 2, + kDoubleValueFieldNumber = 3, + kStringIidFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.VulkanMemoryEventAnnotation"; } + + + using FieldMetadata_KeyIid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + VulkanMemoryEventAnnotation>; + + static constexpr FieldMetadata_KeyIid kKeyIid{}; + void set_key_iid(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_KeyIid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_IntValue = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + VulkanMemoryEventAnnotation>; + + static constexpr FieldMetadata_IntValue kIntValue{}; + void set_int_value(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_IntValue::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DoubleValue = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kDouble, + double, + VulkanMemoryEventAnnotation>; + + static constexpr FieldMetadata_DoubleValue kDoubleValue{}; + void set_double_value(double value) { + static constexpr uint32_t field_id = FieldMetadata_DoubleValue::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kDouble> + ::Append(*this, field_id, value); + } + + using FieldMetadata_StringIid = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + VulkanMemoryEventAnnotation>; + + static constexpr FieldMetadata_StringIid kStringIid{}; + void set_string_iid(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_StringIid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class VulkanApiEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + VulkanApiEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit VulkanApiEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit VulkanApiEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_vk_debug_utils_object_name() const { return at<1>().valid(); } + ::protozero::ConstBytes vk_debug_utils_object_name() const { return at<1>().as_bytes(); } + bool has_vk_queue_submit() const { return at<2>().valid(); } + ::protozero::ConstBytes vk_queue_submit() const { return at<2>().as_bytes(); } +}; + +class VulkanApiEvent : public ::protozero::Message { + public: + using Decoder = VulkanApiEvent_Decoder; + enum : int32_t { + kVkDebugUtilsObjectNameFieldNumber = 1, + kVkQueueSubmitFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.VulkanApiEvent"; } + + using VkDebugUtilsObjectName = ::perfetto::protos::pbzero::VulkanApiEvent_VkDebugUtilsObjectName; + using VkQueueSubmit = ::perfetto::protos::pbzero::VulkanApiEvent_VkQueueSubmit; + + using FieldMetadata_VkDebugUtilsObjectName = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + VulkanApiEvent_VkDebugUtilsObjectName, + VulkanApiEvent>; + + static constexpr FieldMetadata_VkDebugUtilsObjectName kVkDebugUtilsObjectName{}; + template T* set_vk_debug_utils_object_name() { + return BeginNestedMessage(1); + } + + + using FieldMetadata_VkQueueSubmit = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + VulkanApiEvent_VkQueueSubmit, + VulkanApiEvent>; + + static constexpr FieldMetadata_VkQueueSubmit kVkQueueSubmit{}; + template T* set_vk_queue_submit() { + return BeginNestedMessage(2); + } + +}; + +class VulkanApiEvent_VkQueueSubmit_Decoder : public ::protozero::TypedProtoDecoder { + public: + VulkanApiEvent_VkQueueSubmit_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit VulkanApiEvent_VkQueueSubmit_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit VulkanApiEvent_VkQueueSubmit_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_duration_ns() const { return at<1>().valid(); } + uint64_t duration_ns() const { return at<1>().as_uint64(); } + bool has_pid() const { return at<2>().valid(); } + uint32_t pid() const { return at<2>().as_uint32(); } + bool has_tid() const { return at<3>().valid(); } + uint32_t tid() const { return at<3>().as_uint32(); } + bool has_vk_queue() const { return at<4>().valid(); } + uint64_t vk_queue() const { return at<4>().as_uint64(); } + bool has_vk_command_buffers() const { return at<5>().valid(); } + ::protozero::RepeatedFieldIterator vk_command_buffers() const { return GetRepeated(5); } + bool has_submission_id() const { return at<6>().valid(); } + uint32_t submission_id() const { return at<6>().as_uint32(); } +}; + +class VulkanApiEvent_VkQueueSubmit : public ::protozero::Message { + public: + using Decoder = VulkanApiEvent_VkQueueSubmit_Decoder; + enum : int32_t { + kDurationNsFieldNumber = 1, + kPidFieldNumber = 2, + kTidFieldNumber = 3, + kVkQueueFieldNumber = 4, + kVkCommandBuffersFieldNumber = 5, + kSubmissionIdFieldNumber = 6, + }; + static constexpr const char* GetName() { return ".perfetto.protos.VulkanApiEvent.VkQueueSubmit"; } + + + using FieldMetadata_DurationNs = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + VulkanApiEvent_VkQueueSubmit>; + + static constexpr FieldMetadata_DurationNs kDurationNs{}; + void set_duration_ns(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_DurationNs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pid = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + VulkanApiEvent_VkQueueSubmit>; + + static constexpr FieldMetadata_Pid kPid{}; + void set_pid(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Tid = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + VulkanApiEvent_VkQueueSubmit>; + + static constexpr FieldMetadata_Tid kTid{}; + void set_tid(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Tid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_VkQueue = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + VulkanApiEvent_VkQueueSubmit>; + + static constexpr FieldMetadata_VkQueue kVkQueue{}; + void set_vk_queue(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_VkQueue::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_VkCommandBuffers = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + VulkanApiEvent_VkQueueSubmit>; + + static constexpr FieldMetadata_VkCommandBuffers kVkCommandBuffers{}; + void add_vk_command_buffers(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_VkCommandBuffers::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SubmissionId = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + VulkanApiEvent_VkQueueSubmit>; + + static constexpr FieldMetadata_SubmissionId kSubmissionId{}; + void set_submission_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_SubmissionId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class VulkanApiEvent_VkDebugUtilsObjectName_Decoder : public ::protozero::TypedProtoDecoder { + public: + VulkanApiEvent_VkDebugUtilsObjectName_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit VulkanApiEvent_VkDebugUtilsObjectName_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit VulkanApiEvent_VkDebugUtilsObjectName_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_pid() const { return at<1>().valid(); } + uint32_t pid() const { return at<1>().as_uint32(); } + bool has_vk_device() const { return at<2>().valid(); } + uint64_t vk_device() const { return at<2>().as_uint64(); } + bool has_object_type() const { return at<3>().valid(); } + int32_t object_type() const { return at<3>().as_int32(); } + bool has_object() const { return at<4>().valid(); } + uint64_t object() const { return at<4>().as_uint64(); } + bool has_object_name() const { return at<5>().valid(); } + ::protozero::ConstChars object_name() const { return at<5>().as_string(); } +}; + +class VulkanApiEvent_VkDebugUtilsObjectName : public ::protozero::Message { + public: + using Decoder = VulkanApiEvent_VkDebugUtilsObjectName_Decoder; + enum : int32_t { + kPidFieldNumber = 1, + kVkDeviceFieldNumber = 2, + kObjectTypeFieldNumber = 3, + kObjectFieldNumber = 4, + kObjectNameFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.VulkanApiEvent.VkDebugUtilsObjectName"; } + + + using FieldMetadata_Pid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + VulkanApiEvent_VkDebugUtilsObjectName>; + + static constexpr FieldMetadata_Pid kPid{}; + void set_pid(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_VkDevice = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + VulkanApiEvent_VkDebugUtilsObjectName>; + + static constexpr FieldMetadata_VkDevice kVkDevice{}; + void set_vk_device(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_VkDevice::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ObjectType = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + VulkanApiEvent_VkDebugUtilsObjectName>; + + static constexpr FieldMetadata_ObjectType kObjectType{}; + void set_object_type(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ObjectType::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Object = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + VulkanApiEvent_VkDebugUtilsObjectName>; + + static constexpr FieldMetadata_Object kObject{}; + void set_object(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Object::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ObjectName = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + VulkanApiEvent_VkDebugUtilsObjectName>; + + static constexpr FieldMetadata_ObjectName kObjectName{}; + void set_object_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_ObjectName::kFieldId, data, size); + } + void set_object_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_ObjectName::kFieldId, chars.data, chars.size); + } + void set_object_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_ObjectName::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class InternedGpuRenderStageSpecification_Decoder : public ::protozero::TypedProtoDecoder { + public: + InternedGpuRenderStageSpecification_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit InternedGpuRenderStageSpecification_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit InternedGpuRenderStageSpecification_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_iid() const { return at<1>().valid(); } + uint64_t iid() const { return at<1>().as_uint64(); } + bool has_name() const { return at<2>().valid(); } + ::protozero::ConstChars name() const { return at<2>().as_string(); } + bool has_description() const { return at<3>().valid(); } + ::protozero::ConstChars description() const { return at<3>().as_string(); } + bool has_category() const { return at<4>().valid(); } + int32_t category() const { return at<4>().as_int32(); } +}; + +class InternedGpuRenderStageSpecification : public ::protozero::Message { + public: + using Decoder = InternedGpuRenderStageSpecification_Decoder; + enum : int32_t { + kIidFieldNumber = 1, + kNameFieldNumber = 2, + kDescriptionFieldNumber = 3, + kCategoryFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.InternedGpuRenderStageSpecification"; } + + + using RenderStageCategory = ::perfetto::protos::pbzero::InternedGpuRenderStageSpecification_RenderStageCategory; + static inline const char* RenderStageCategory_Name(RenderStageCategory value) { + return ::perfetto::protos::pbzero::InternedGpuRenderStageSpecification_RenderStageCategory_Name(value); + } + static inline const RenderStageCategory OTHER = RenderStageCategory::OTHER; + static inline const RenderStageCategory GRAPHICS = RenderStageCategory::GRAPHICS; + static inline const RenderStageCategory COMPUTE = RenderStageCategory::COMPUTE; + + using FieldMetadata_Iid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + InternedGpuRenderStageSpecification>; + + static constexpr FieldMetadata_Iid kIid{}; + void set_iid(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Iid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + InternedGpuRenderStageSpecification>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Description = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + InternedGpuRenderStageSpecification>; + + static constexpr FieldMetadata_Description kDescription{}; + void set_description(const char* data, size_t size) { + AppendBytes(FieldMetadata_Description::kFieldId, data, size); + } + void set_description(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Description::kFieldId, chars.data, chars.size); + } + void set_description(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Description::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Category = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + InternedGpuRenderStageSpecification_RenderStageCategory, + InternedGpuRenderStageSpecification>; + + static constexpr FieldMetadata_Category kCategory{}; + void set_category(InternedGpuRenderStageSpecification_RenderStageCategory value) { + static constexpr uint32_t field_id = FieldMetadata_Category::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } +}; + +class InternedGraphicsContext_Decoder : public ::protozero::TypedProtoDecoder { + public: + InternedGraphicsContext_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit InternedGraphicsContext_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit InternedGraphicsContext_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_iid() const { return at<1>().valid(); } + uint64_t iid() const { return at<1>().as_uint64(); } + bool has_pid() const { return at<2>().valid(); } + int32_t pid() const { return at<2>().as_int32(); } + bool has_api() const { return at<3>().valid(); } + int32_t api() const { return at<3>().as_int32(); } +}; + +class InternedGraphicsContext : public ::protozero::Message { + public: + using Decoder = InternedGraphicsContext_Decoder; + enum : int32_t { + kIidFieldNumber = 1, + kPidFieldNumber = 2, + kApiFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.InternedGraphicsContext"; } + + + using Api = ::perfetto::protos::pbzero::InternedGraphicsContext_Api; + static inline const char* Api_Name(Api value) { + return ::perfetto::protos::pbzero::InternedGraphicsContext_Api_Name(value); + } + static inline const Api UNDEFINED = Api::UNDEFINED; + static inline const Api OPEN_GL = Api::OPEN_GL; + static inline const Api VULKAN = Api::VULKAN; + static inline const Api OPEN_CL = Api::OPEN_CL; + + using FieldMetadata_Iid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + InternedGraphicsContext>; + + static constexpr FieldMetadata_Iid kIid{}; + void set_iid(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Iid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pid = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + InternedGraphicsContext>; + + static constexpr FieldMetadata_Pid kPid{}; + void set_pid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Api = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + InternedGraphicsContext_Api, + InternedGraphicsContext>; + + static constexpr FieldMetadata_Api kApi{}; + void set_api(InternedGraphicsContext_Api value) { + static constexpr uint32_t field_id = FieldMetadata_Api::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } +}; + +class GpuRenderStageEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + GpuRenderStageEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit GpuRenderStageEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit GpuRenderStageEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_event_id() const { return at<1>().valid(); } + uint64_t event_id() const { return at<1>().as_uint64(); } + bool has_duration() const { return at<2>().valid(); } + uint64_t duration() const { return at<2>().as_uint64(); } + bool has_hw_queue_iid() const { return at<13>().valid(); } + uint64_t hw_queue_iid() const { return at<13>().as_uint64(); } + bool has_stage_iid() const { return at<14>().valid(); } + uint64_t stage_iid() const { return at<14>().as_uint64(); } + bool has_gpu_id() const { return at<11>().valid(); } + int32_t gpu_id() const { return at<11>().as_int32(); } + bool has_context() const { return at<5>().valid(); } + uint64_t context() const { return at<5>().as_uint64(); } + bool has_render_target_handle() const { return at<8>().valid(); } + uint64_t render_target_handle() const { return at<8>().as_uint64(); } + bool has_submission_id() const { return at<10>().valid(); } + uint32_t submission_id() const { return at<10>().as_uint32(); } + bool has_extra_data() const { return at<6>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> extra_data() const { return GetRepeated<::protozero::ConstBytes>(6); } + bool has_render_pass_handle() const { return at<9>().valid(); } + uint64_t render_pass_handle() const { return at<9>().as_uint64(); } + bool has_render_subpass_index_mask() const { return at<15>().valid(); } + ::protozero::RepeatedFieldIterator render_subpass_index_mask() const { return GetRepeated(15); } + bool has_command_buffer_handle() const { return at<12>().valid(); } + uint64_t command_buffer_handle() const { return at<12>().as_uint64(); } + bool has_specifications() const { return at<7>().valid(); } + ::protozero::ConstBytes specifications() const { return at<7>().as_bytes(); } + bool has_hw_queue_id() const { return at<3>().valid(); } + int32_t hw_queue_id() const { return at<3>().as_int32(); } + bool has_stage_id() const { return at<4>().valid(); } + int32_t stage_id() const { return at<4>().as_int32(); } +}; + +class GpuRenderStageEvent : public ::protozero::Message { + public: + using Decoder = GpuRenderStageEvent_Decoder; + enum : int32_t { + kEventIdFieldNumber = 1, + kDurationFieldNumber = 2, + kHwQueueIidFieldNumber = 13, + kStageIidFieldNumber = 14, + kGpuIdFieldNumber = 11, + kContextFieldNumber = 5, + kRenderTargetHandleFieldNumber = 8, + kSubmissionIdFieldNumber = 10, + kExtraDataFieldNumber = 6, + kRenderPassHandleFieldNumber = 9, + kRenderSubpassIndexMaskFieldNumber = 15, + kCommandBufferHandleFieldNumber = 12, + kSpecificationsFieldNumber = 7, + kHwQueueIdFieldNumber = 3, + kStageIdFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.GpuRenderStageEvent"; } + + using ExtraData = ::perfetto::protos::pbzero::GpuRenderStageEvent_ExtraData; + using Specifications = ::perfetto::protos::pbzero::GpuRenderStageEvent_Specifications; + + using FieldMetadata_EventId = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + GpuRenderStageEvent>; + + static constexpr FieldMetadata_EventId kEventId{}; + void set_event_id(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_EventId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Duration = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + GpuRenderStageEvent>; + + static constexpr FieldMetadata_Duration kDuration{}; + void set_duration(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Duration::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_HwQueueIid = + ::protozero::proto_utils::FieldMetadata< + 13, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + GpuRenderStageEvent>; + + static constexpr FieldMetadata_HwQueueIid kHwQueueIid{}; + void set_hw_queue_iid(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_HwQueueIid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_StageIid = + ::protozero::proto_utils::FieldMetadata< + 14, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + GpuRenderStageEvent>; + + static constexpr FieldMetadata_StageIid kStageIid{}; + void set_stage_iid(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_StageIid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_GpuId = + ::protozero::proto_utils::FieldMetadata< + 11, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + GpuRenderStageEvent>; + + static constexpr FieldMetadata_GpuId kGpuId{}; + void set_gpu_id(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_GpuId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Context = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + GpuRenderStageEvent>; + + static constexpr FieldMetadata_Context kContext{}; + void set_context(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Context::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_RenderTargetHandle = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + GpuRenderStageEvent>; + + static constexpr FieldMetadata_RenderTargetHandle kRenderTargetHandle{}; + void set_render_target_handle(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_RenderTargetHandle::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SubmissionId = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + GpuRenderStageEvent>; + + static constexpr FieldMetadata_SubmissionId kSubmissionId{}; + void set_submission_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_SubmissionId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ExtraData = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + GpuRenderStageEvent_ExtraData, + GpuRenderStageEvent>; + + static constexpr FieldMetadata_ExtraData kExtraData{}; + template T* add_extra_data() { + return BeginNestedMessage(6); + } + + + using FieldMetadata_RenderPassHandle = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + GpuRenderStageEvent>; + + static constexpr FieldMetadata_RenderPassHandle kRenderPassHandle{}; + void set_render_pass_handle(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_RenderPassHandle::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_RenderSubpassIndexMask = + ::protozero::proto_utils::FieldMetadata< + 15, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + GpuRenderStageEvent>; + + static constexpr FieldMetadata_RenderSubpassIndexMask kRenderSubpassIndexMask{}; + void add_render_subpass_index_mask(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_RenderSubpassIndexMask::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CommandBufferHandle = + ::protozero::proto_utils::FieldMetadata< + 12, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + GpuRenderStageEvent>; + + static constexpr FieldMetadata_CommandBufferHandle kCommandBufferHandle{}; + void set_command_buffer_handle(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_CommandBufferHandle::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Specifications = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + GpuRenderStageEvent_Specifications, + GpuRenderStageEvent>; + + static constexpr FieldMetadata_Specifications kSpecifications{}; + template T* set_specifications() { + return BeginNestedMessage(7); + } + + + using FieldMetadata_HwQueueId = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + GpuRenderStageEvent>; + + static constexpr FieldMetadata_HwQueueId kHwQueueId{}; + void set_hw_queue_id(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_HwQueueId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_StageId = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + GpuRenderStageEvent>; + + static constexpr FieldMetadata_StageId kStageId{}; + void set_stage_id(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_StageId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class GpuRenderStageEvent_Specifications_Decoder : public ::protozero::TypedProtoDecoder { + public: + GpuRenderStageEvent_Specifications_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit GpuRenderStageEvent_Specifications_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit GpuRenderStageEvent_Specifications_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_context_spec() const { return at<1>().valid(); } + ::protozero::ConstBytes context_spec() const { return at<1>().as_bytes(); } + bool has_hw_queue() const { return at<2>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> hw_queue() const { return GetRepeated<::protozero::ConstBytes>(2); } + bool has_stage() const { return at<3>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> stage() const { return GetRepeated<::protozero::ConstBytes>(3); } +}; + +class GpuRenderStageEvent_Specifications : public ::protozero::Message { + public: + using Decoder = GpuRenderStageEvent_Specifications_Decoder; + enum : int32_t { + kContextSpecFieldNumber = 1, + kHwQueueFieldNumber = 2, + kStageFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.GpuRenderStageEvent.Specifications"; } + + using ContextSpec = ::perfetto::protos::pbzero::GpuRenderStageEvent_Specifications_ContextSpec; + using Description = ::perfetto::protos::pbzero::GpuRenderStageEvent_Specifications_Description; + + using FieldMetadata_ContextSpec = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + GpuRenderStageEvent_Specifications_ContextSpec, + GpuRenderStageEvent_Specifications>; + + static constexpr FieldMetadata_ContextSpec kContextSpec{}; + template T* set_context_spec() { + return BeginNestedMessage(1); + } + + + using FieldMetadata_HwQueue = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + GpuRenderStageEvent_Specifications_Description, + GpuRenderStageEvent_Specifications>; + + static constexpr FieldMetadata_HwQueue kHwQueue{}; + template T* add_hw_queue() { + return BeginNestedMessage(2); + } + + + using FieldMetadata_Stage = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + GpuRenderStageEvent_Specifications_Description, + GpuRenderStageEvent_Specifications>; + + static constexpr FieldMetadata_Stage kStage{}; + template T* add_stage() { + return BeginNestedMessage(3); + } + +}; + +class GpuRenderStageEvent_Specifications_Description_Decoder : public ::protozero::TypedProtoDecoder { + public: + GpuRenderStageEvent_Specifications_Description_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit GpuRenderStageEvent_Specifications_Description_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit GpuRenderStageEvent_Specifications_Description_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_name() const { return at<1>().valid(); } + ::protozero::ConstChars name() const { return at<1>().as_string(); } + bool has_description() const { return at<2>().valid(); } + ::protozero::ConstChars description() const { return at<2>().as_string(); } +}; + +class GpuRenderStageEvent_Specifications_Description : public ::protozero::Message { + public: + using Decoder = GpuRenderStageEvent_Specifications_Description_Decoder; + enum : int32_t { + kNameFieldNumber = 1, + kDescriptionFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.GpuRenderStageEvent.Specifications.Description"; } + + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + GpuRenderStageEvent_Specifications_Description>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Description = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + GpuRenderStageEvent_Specifications_Description>; + + static constexpr FieldMetadata_Description kDescription{}; + void set_description(const char* data, size_t size) { + AppendBytes(FieldMetadata_Description::kFieldId, data, size); + } + void set_description(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Description::kFieldId, chars.data, chars.size); + } + void set_description(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Description::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class GpuRenderStageEvent_Specifications_ContextSpec_Decoder : public ::protozero::TypedProtoDecoder { + public: + GpuRenderStageEvent_Specifications_ContextSpec_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit GpuRenderStageEvent_Specifications_ContextSpec_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit GpuRenderStageEvent_Specifications_ContextSpec_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_context() const { return at<1>().valid(); } + uint64_t context() const { return at<1>().as_uint64(); } + bool has_pid() const { return at<2>().valid(); } + int32_t pid() const { return at<2>().as_int32(); } +}; + +class GpuRenderStageEvent_Specifications_ContextSpec : public ::protozero::Message { + public: + using Decoder = GpuRenderStageEvent_Specifications_ContextSpec_Decoder; + enum : int32_t { + kContextFieldNumber = 1, + kPidFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.GpuRenderStageEvent.Specifications.ContextSpec"; } + + + using FieldMetadata_Context = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + GpuRenderStageEvent_Specifications_ContextSpec>; + + static constexpr FieldMetadata_Context kContext{}; + void set_context(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Context::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pid = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + GpuRenderStageEvent_Specifications_ContextSpec>; + + static constexpr FieldMetadata_Pid kPid{}; + void set_pid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class GpuRenderStageEvent_ExtraData_Decoder : public ::protozero::TypedProtoDecoder { + public: + GpuRenderStageEvent_ExtraData_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit GpuRenderStageEvent_ExtraData_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit GpuRenderStageEvent_ExtraData_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_name() const { return at<1>().valid(); } + ::protozero::ConstChars name() const { return at<1>().as_string(); } + bool has_value() const { return at<2>().valid(); } + ::protozero::ConstChars value() const { return at<2>().as_string(); } +}; + +class GpuRenderStageEvent_ExtraData : public ::protozero::Message { + public: + using Decoder = GpuRenderStageEvent_ExtraData_Decoder; + enum : int32_t { + kNameFieldNumber = 1, + kValueFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.GpuRenderStageEvent.ExtraData"; } + + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + GpuRenderStageEvent_ExtraData>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Value = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + GpuRenderStageEvent_ExtraData>; + + static constexpr FieldMetadata_Value kValue{}; + void set_value(const char* data, size_t size) { + AppendBytes(FieldMetadata_Value::kFieldId, data, size); + } + void set_value(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Value::kFieldId, chars.data, chars.size); + } + void set_value(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class GpuLog_Decoder : public ::protozero::TypedProtoDecoder { + public: + GpuLog_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit GpuLog_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit GpuLog_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_severity() const { return at<1>().valid(); } + int32_t severity() const { return at<1>().as_int32(); } + bool has_tag() const { return at<2>().valid(); } + ::protozero::ConstChars tag() const { return at<2>().as_string(); } + bool has_log_message() const { return at<3>().valid(); } + ::protozero::ConstChars log_message() const { return at<3>().as_string(); } +}; + +class GpuLog : public ::protozero::Message { + public: + using Decoder = GpuLog_Decoder; + enum : int32_t { + kSeverityFieldNumber = 1, + kTagFieldNumber = 2, + kLogMessageFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.GpuLog"; } + + + using Severity = ::perfetto::protos::pbzero::GpuLog_Severity; + static inline const char* Severity_Name(Severity value) { + return ::perfetto::protos::pbzero::GpuLog_Severity_Name(value); + } + static inline const Severity LOG_SEVERITY_UNSPECIFIED = Severity::LOG_SEVERITY_UNSPECIFIED; + static inline const Severity LOG_SEVERITY_VERBOSE = Severity::LOG_SEVERITY_VERBOSE; + static inline const Severity LOG_SEVERITY_DEBUG = Severity::LOG_SEVERITY_DEBUG; + static inline const Severity LOG_SEVERITY_INFO = Severity::LOG_SEVERITY_INFO; + static inline const Severity LOG_SEVERITY_WARNING = Severity::LOG_SEVERITY_WARNING; + static inline const Severity LOG_SEVERITY_ERROR = Severity::LOG_SEVERITY_ERROR; + + using FieldMetadata_Severity = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + GpuLog_Severity, + GpuLog>; + + static constexpr FieldMetadata_Severity kSeverity{}; + void set_severity(GpuLog_Severity value) { + static constexpr uint32_t field_id = FieldMetadata_Severity::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Tag = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + GpuLog>; + + static constexpr FieldMetadata_Tag kTag{}; + void set_tag(const char* data, size_t size) { + AppendBytes(FieldMetadata_Tag::kFieldId, data, size); + } + void set_tag(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Tag::kFieldId, chars.data, chars.size); + } + void set_tag(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Tag::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_LogMessage = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + GpuLog>; + + static constexpr FieldMetadata_LogMessage kLogMessage{}; + void set_log_message(const char* data, size_t size) { + AppendBytes(FieldMetadata_LogMessage::kFieldId, data, size); + } + void set_log_message(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_LogMessage::kFieldId, chars.data, chars.size); + } + void set_log_message(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_LogMessage::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class GpuCounterEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + GpuCounterEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit GpuCounterEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit GpuCounterEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_counters() const { return at<2>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> counters() const { return GetRepeated<::protozero::ConstBytes>(2); } + bool has_gpu_id() const { return at<3>().valid(); } + int32_t gpu_id() const { return at<3>().as_int32(); } +}; + +class GpuCounterEvent : public ::protozero::Message { + public: + using Decoder = GpuCounterEvent_Decoder; + enum : int32_t { + kCountersFieldNumber = 2, + kGpuIdFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.GpuCounterEvent"; } + + using GpuCounter = ::perfetto::protos::pbzero::GpuCounterEvent_GpuCounter; + + using FieldMetadata_Counters = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + GpuCounterEvent_GpuCounter, + GpuCounterEvent>; + + static constexpr FieldMetadata_Counters kCounters{}; + template T* add_counters() { + return BeginNestedMessage(2); + } + + + using FieldMetadata_GpuId = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + GpuCounterEvent>; + + static constexpr FieldMetadata_GpuId kGpuId{}; + void set_gpu_id(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_GpuId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class GpuCounterEvent_GpuCounter_Decoder : public ::protozero::TypedProtoDecoder { + public: + GpuCounterEvent_GpuCounter_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit GpuCounterEvent_GpuCounter_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit GpuCounterEvent_GpuCounter_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_counter_id() const { return at<1>().valid(); } + uint32_t counter_id() const { return at<1>().as_uint32(); } + bool has_int_value() const { return at<2>().valid(); } + int64_t int_value() const { return at<2>().as_int64(); } + bool has_double_value() const { return at<3>().valid(); } + double double_value() const { return at<3>().as_double(); } +}; + +class GpuCounterEvent_GpuCounter : public ::protozero::Message { + public: + using Decoder = GpuCounterEvent_GpuCounter_Decoder; + enum : int32_t { + kCounterIdFieldNumber = 1, + kIntValueFieldNumber = 2, + kDoubleValueFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.GpuCounterEvent.GpuCounter"; } + + + using FieldMetadata_CounterId = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + GpuCounterEvent_GpuCounter>; + + static constexpr FieldMetadata_CounterId kCounterId{}; + void set_counter_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_CounterId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_IntValue = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + GpuCounterEvent_GpuCounter>; + + static constexpr FieldMetadata_IntValue kIntValue{}; + void set_int_value(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_IntValue::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DoubleValue = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kDouble, + double, + GpuCounterEvent_GpuCounter>; + + static constexpr FieldMetadata_DoubleValue kDoubleValue{}; + void set_double_value(double value) { + static constexpr uint32_t field_id = FieldMetadata_DoubleValue::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kDouble> + ::Append(*this, field_id, value); + } +}; + +class FtraceEventBundle_Decoder : public ::protozero::TypedProtoDecoder { + public: + FtraceEventBundle_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit FtraceEventBundle_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit FtraceEventBundle_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_cpu() const { return at<1>().valid(); } + uint32_t cpu() const { return at<1>().as_uint32(); } + bool has_event() const { return at<2>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> event() const { return GetRepeated<::protozero::ConstBytes>(2); } + bool has_lost_events() const { return at<3>().valid(); } + bool lost_events() const { return at<3>().as_bool(); } + bool has_compact_sched() const { return at<4>().valid(); } + ::protozero::ConstBytes compact_sched() const { return at<4>().as_bytes(); } + bool has_ftrace_clock() const { return at<5>().valid(); } + int32_t ftrace_clock() const { return at<5>().as_int32(); } + bool has_ftrace_timestamp() const { return at<6>().valid(); } + int64_t ftrace_timestamp() const { return at<6>().as_int64(); } + bool has_boot_timestamp() const { return at<7>().valid(); } + int64_t boot_timestamp() const { return at<7>().as_int64(); } + bool has_error() const { return at<8>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> error() const { return GetRepeated<::protozero::ConstBytes>(8); } + bool has_last_read_event_timestamp() const { return at<9>().valid(); } + uint64_t last_read_event_timestamp() const { return at<9>().as_uint64(); } +}; + +class FtraceEventBundle : public ::protozero::Message { + public: + using Decoder = FtraceEventBundle_Decoder; + enum : int32_t { + kCpuFieldNumber = 1, + kEventFieldNumber = 2, + kLostEventsFieldNumber = 3, + kCompactSchedFieldNumber = 4, + kFtraceClockFieldNumber = 5, + kFtraceTimestampFieldNumber = 6, + kBootTimestampFieldNumber = 7, + kErrorFieldNumber = 8, + kLastReadEventTimestampFieldNumber = 9, + }; + static constexpr const char* GetName() { return ".perfetto.protos.FtraceEventBundle"; } + + using CompactSched = ::perfetto::protos::pbzero::FtraceEventBundle_CompactSched; + using FtraceError = ::perfetto::protos::pbzero::FtraceEventBundle_FtraceError; + + using FieldMetadata_Cpu = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + FtraceEventBundle>; + + static constexpr FieldMetadata_Cpu kCpu{}; + void set_cpu(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Cpu::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Event = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + FtraceEvent, + FtraceEventBundle>; + + static constexpr FieldMetadata_Event kEvent{}; + template T* add_event() { + return BeginNestedMessage(2); + } + + + using FieldMetadata_LostEvents = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + FtraceEventBundle>; + + static constexpr FieldMetadata_LostEvents kLostEvents{}; + void set_lost_events(bool value) { + static constexpr uint32_t field_id = FieldMetadata_LostEvents::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CompactSched = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + FtraceEventBundle_CompactSched, + FtraceEventBundle>; + + static constexpr FieldMetadata_CompactSched kCompactSched{}; + template T* set_compact_sched() { + return BeginNestedMessage(4); + } + + + using FieldMetadata_FtraceClock = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + FtraceClock, + FtraceEventBundle>; + + static constexpr FieldMetadata_FtraceClock kFtraceClock{}; + void set_ftrace_clock(FtraceClock value) { + static constexpr uint32_t field_id = FieldMetadata_FtraceClock::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FtraceTimestamp = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + FtraceEventBundle>; + + static constexpr FieldMetadata_FtraceTimestamp kFtraceTimestamp{}; + void set_ftrace_timestamp(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_FtraceTimestamp::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_BootTimestamp = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + FtraceEventBundle>; + + static constexpr FieldMetadata_BootTimestamp kBootTimestamp{}; + void set_boot_timestamp(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_BootTimestamp::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Error = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + FtraceEventBundle_FtraceError, + FtraceEventBundle>; + + static constexpr FieldMetadata_Error kError{}; + template T* add_error() { + return BeginNestedMessage(8); + } + + + using FieldMetadata_LastReadEventTimestamp = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + FtraceEventBundle>; + + static constexpr FieldMetadata_LastReadEventTimestamp kLastReadEventTimestamp{}; + void set_last_read_event_timestamp(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_LastReadEventTimestamp::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class FtraceEventBundle_FtraceError_Decoder : public ::protozero::TypedProtoDecoder { + public: + FtraceEventBundle_FtraceError_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit FtraceEventBundle_FtraceError_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit FtraceEventBundle_FtraceError_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_timestamp() const { return at<1>().valid(); } + uint64_t timestamp() const { return at<1>().as_uint64(); } + bool has_status() const { return at<2>().valid(); } + int32_t status() const { return at<2>().as_int32(); } +}; + +class FtraceEventBundle_FtraceError : public ::protozero::Message { + public: + using Decoder = FtraceEventBundle_FtraceError_Decoder; + enum : int32_t { + kTimestampFieldNumber = 1, + kStatusFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.FtraceEventBundle.FtraceError"; } + + + using FieldMetadata_Timestamp = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + FtraceEventBundle_FtraceError>; + + static constexpr FieldMetadata_Timestamp kTimestamp{}; + void set_timestamp(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Timestamp::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Status = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + FtraceParseStatus, + FtraceEventBundle_FtraceError>; + + static constexpr FieldMetadata_Status kStatus{}; + void set_status(FtraceParseStatus value) { + static constexpr uint32_t field_id = FieldMetadata_Status::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } +}; + +class FtraceEventBundle_CompactSched_Decoder : public ::protozero::TypedProtoDecoder { + public: + FtraceEventBundle_CompactSched_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit FtraceEventBundle_CompactSched_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit FtraceEventBundle_CompactSched_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_intern_table() const { return at<5>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstChars> intern_table() const { return GetRepeated<::protozero::ConstChars>(5); } + bool has_switch_timestamp() const { return at<1>().valid(); } + ::protozero::PackedRepeatedFieldIterator<::protozero::proto_utils::ProtoWireType::kVarInt, uint64_t> switch_timestamp(bool* parse_error_ptr) const { return GetPackedRepeated<::protozero::proto_utils::ProtoWireType::kVarInt, uint64_t>(1, parse_error_ptr); } + bool has_switch_prev_state() const { return at<2>().valid(); } + ::protozero::PackedRepeatedFieldIterator<::protozero::proto_utils::ProtoWireType::kVarInt, int64_t> switch_prev_state(bool* parse_error_ptr) const { return GetPackedRepeated<::protozero::proto_utils::ProtoWireType::kVarInt, int64_t>(2, parse_error_ptr); } + bool has_switch_next_pid() const { return at<3>().valid(); } + ::protozero::PackedRepeatedFieldIterator<::protozero::proto_utils::ProtoWireType::kVarInt, int32_t> switch_next_pid(bool* parse_error_ptr) const { return GetPackedRepeated<::protozero::proto_utils::ProtoWireType::kVarInt, int32_t>(3, parse_error_ptr); } + bool has_switch_next_prio() const { return at<4>().valid(); } + ::protozero::PackedRepeatedFieldIterator<::protozero::proto_utils::ProtoWireType::kVarInt, int32_t> switch_next_prio(bool* parse_error_ptr) const { return GetPackedRepeated<::protozero::proto_utils::ProtoWireType::kVarInt, int32_t>(4, parse_error_ptr); } + bool has_switch_next_comm_index() const { return at<6>().valid(); } + ::protozero::PackedRepeatedFieldIterator<::protozero::proto_utils::ProtoWireType::kVarInt, uint32_t> switch_next_comm_index(bool* parse_error_ptr) const { return GetPackedRepeated<::protozero::proto_utils::ProtoWireType::kVarInt, uint32_t>(6, parse_error_ptr); } + bool has_waking_timestamp() const { return at<7>().valid(); } + ::protozero::PackedRepeatedFieldIterator<::protozero::proto_utils::ProtoWireType::kVarInt, uint64_t> waking_timestamp(bool* parse_error_ptr) const { return GetPackedRepeated<::protozero::proto_utils::ProtoWireType::kVarInt, uint64_t>(7, parse_error_ptr); } + bool has_waking_pid() const { return at<8>().valid(); } + ::protozero::PackedRepeatedFieldIterator<::protozero::proto_utils::ProtoWireType::kVarInt, int32_t> waking_pid(bool* parse_error_ptr) const { return GetPackedRepeated<::protozero::proto_utils::ProtoWireType::kVarInt, int32_t>(8, parse_error_ptr); } + bool has_waking_target_cpu() const { return at<9>().valid(); } + ::protozero::PackedRepeatedFieldIterator<::protozero::proto_utils::ProtoWireType::kVarInt, int32_t> waking_target_cpu(bool* parse_error_ptr) const { return GetPackedRepeated<::protozero::proto_utils::ProtoWireType::kVarInt, int32_t>(9, parse_error_ptr); } + bool has_waking_prio() const { return at<10>().valid(); } + ::protozero::PackedRepeatedFieldIterator<::protozero::proto_utils::ProtoWireType::kVarInt, int32_t> waking_prio(bool* parse_error_ptr) const { return GetPackedRepeated<::protozero::proto_utils::ProtoWireType::kVarInt, int32_t>(10, parse_error_ptr); } + bool has_waking_comm_index() const { return at<11>().valid(); } + ::protozero::PackedRepeatedFieldIterator<::protozero::proto_utils::ProtoWireType::kVarInt, uint32_t> waking_comm_index(bool* parse_error_ptr) const { return GetPackedRepeated<::protozero::proto_utils::ProtoWireType::kVarInt, uint32_t>(11, parse_error_ptr); } + bool has_waking_common_flags() const { return at<12>().valid(); } + ::protozero::PackedRepeatedFieldIterator<::protozero::proto_utils::ProtoWireType::kVarInt, uint32_t> waking_common_flags(bool* parse_error_ptr) const { return GetPackedRepeated<::protozero::proto_utils::ProtoWireType::kVarInt, uint32_t>(12, parse_error_ptr); } +}; + +class FtraceEventBundle_CompactSched : public ::protozero::Message { + public: + using Decoder = FtraceEventBundle_CompactSched_Decoder; + enum : int32_t { + kInternTableFieldNumber = 5, + kSwitchTimestampFieldNumber = 1, + kSwitchPrevStateFieldNumber = 2, + kSwitchNextPidFieldNumber = 3, + kSwitchNextPrioFieldNumber = 4, + kSwitchNextCommIndexFieldNumber = 6, + kWakingTimestampFieldNumber = 7, + kWakingPidFieldNumber = 8, + kWakingTargetCpuFieldNumber = 9, + kWakingPrioFieldNumber = 10, + kWakingCommIndexFieldNumber = 11, + kWakingCommonFlagsFieldNumber = 12, + }; + static constexpr const char* GetName() { return ".perfetto.protos.FtraceEventBundle.CompactSched"; } + + + using FieldMetadata_InternTable = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + FtraceEventBundle_CompactSched>; + + static constexpr FieldMetadata_InternTable kInternTable{}; + void add_intern_table(const char* data, size_t size) { + AppendBytes(FieldMetadata_InternTable::kFieldId, data, size); + } + void add_intern_table(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_InternTable::kFieldId, chars.data, chars.size); + } + void add_intern_table(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_InternTable::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SwitchTimestamp = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kRepeatedPacked, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + FtraceEventBundle_CompactSched>; + + static constexpr FieldMetadata_SwitchTimestamp kSwitchTimestamp{}; + void set_switch_timestamp(const ::protozero::PackedVarInt& packed_buffer) { + AppendBytes(FieldMetadata_SwitchTimestamp::kFieldId, packed_buffer.data(), + packed_buffer.size()); + } + + using FieldMetadata_SwitchPrevState = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kRepeatedPacked, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + FtraceEventBundle_CompactSched>; + + static constexpr FieldMetadata_SwitchPrevState kSwitchPrevState{}; + void set_switch_prev_state(const ::protozero::PackedVarInt& packed_buffer) { + AppendBytes(FieldMetadata_SwitchPrevState::kFieldId, packed_buffer.data(), + packed_buffer.size()); + } + + using FieldMetadata_SwitchNextPid = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kRepeatedPacked, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + FtraceEventBundle_CompactSched>; + + static constexpr FieldMetadata_SwitchNextPid kSwitchNextPid{}; + void set_switch_next_pid(const ::protozero::PackedVarInt& packed_buffer) { + AppendBytes(FieldMetadata_SwitchNextPid::kFieldId, packed_buffer.data(), + packed_buffer.size()); + } + + using FieldMetadata_SwitchNextPrio = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kRepeatedPacked, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + FtraceEventBundle_CompactSched>; + + static constexpr FieldMetadata_SwitchNextPrio kSwitchNextPrio{}; + void set_switch_next_prio(const ::protozero::PackedVarInt& packed_buffer) { + AppendBytes(FieldMetadata_SwitchNextPrio::kFieldId, packed_buffer.data(), + packed_buffer.size()); + } + + using FieldMetadata_SwitchNextCommIndex = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kRepeatedPacked, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + FtraceEventBundle_CompactSched>; + + static constexpr FieldMetadata_SwitchNextCommIndex kSwitchNextCommIndex{}; + void set_switch_next_comm_index(const ::protozero::PackedVarInt& packed_buffer) { + AppendBytes(FieldMetadata_SwitchNextCommIndex::kFieldId, packed_buffer.data(), + packed_buffer.size()); + } + + using FieldMetadata_WakingTimestamp = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kRepeatedPacked, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + FtraceEventBundle_CompactSched>; + + static constexpr FieldMetadata_WakingTimestamp kWakingTimestamp{}; + void set_waking_timestamp(const ::protozero::PackedVarInt& packed_buffer) { + AppendBytes(FieldMetadata_WakingTimestamp::kFieldId, packed_buffer.data(), + packed_buffer.size()); + } + + using FieldMetadata_WakingPid = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kRepeatedPacked, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + FtraceEventBundle_CompactSched>; + + static constexpr FieldMetadata_WakingPid kWakingPid{}; + void set_waking_pid(const ::protozero::PackedVarInt& packed_buffer) { + AppendBytes(FieldMetadata_WakingPid::kFieldId, packed_buffer.data(), + packed_buffer.size()); + } + + using FieldMetadata_WakingTargetCpu = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kRepeatedPacked, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + FtraceEventBundle_CompactSched>; + + static constexpr FieldMetadata_WakingTargetCpu kWakingTargetCpu{}; + void set_waking_target_cpu(const ::protozero::PackedVarInt& packed_buffer) { + AppendBytes(FieldMetadata_WakingTargetCpu::kFieldId, packed_buffer.data(), + packed_buffer.size()); + } + + using FieldMetadata_WakingPrio = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kRepeatedPacked, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + FtraceEventBundle_CompactSched>; + + static constexpr FieldMetadata_WakingPrio kWakingPrio{}; + void set_waking_prio(const ::protozero::PackedVarInt& packed_buffer) { + AppendBytes(FieldMetadata_WakingPrio::kFieldId, packed_buffer.data(), + packed_buffer.size()); + } + + using FieldMetadata_WakingCommIndex = + ::protozero::proto_utils::FieldMetadata< + 11, + ::protozero::proto_utils::RepetitionType::kRepeatedPacked, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + FtraceEventBundle_CompactSched>; + + static constexpr FieldMetadata_WakingCommIndex kWakingCommIndex{}; + void set_waking_comm_index(const ::protozero::PackedVarInt& packed_buffer) { + AppendBytes(FieldMetadata_WakingCommIndex::kFieldId, packed_buffer.data(), + packed_buffer.size()); + } + + using FieldMetadata_WakingCommonFlags = + ::protozero::proto_utils::FieldMetadata< + 12, + ::protozero::proto_utils::RepetitionType::kRepeatedPacked, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + FtraceEventBundle_CompactSched>; + + static constexpr FieldMetadata_WakingCommonFlags kWakingCommonFlags{}; + void set_waking_common_flags(const ::protozero::PackedVarInt& packed_buffer) { + AppendBytes(FieldMetadata_WakingCommonFlags::kFieldId, packed_buffer.data(), + packed_buffer.size()); + } +}; + +class FtraceStats_Decoder : public ::protozero::TypedProtoDecoder { + public: + FtraceStats_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit FtraceStats_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit FtraceStats_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_phase() const { return at<1>().valid(); } + int32_t phase() const { return at<1>().as_int32(); } + bool has_cpu_stats() const { return at<2>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> cpu_stats() const { return GetRepeated<::protozero::ConstBytes>(2); } + bool has_kernel_symbols_parsed() const { return at<3>().valid(); } + uint32_t kernel_symbols_parsed() const { return at<3>().as_uint32(); } + bool has_kernel_symbols_mem_kb() const { return at<4>().valid(); } + uint32_t kernel_symbols_mem_kb() const { return at<4>().as_uint32(); } + bool has_atrace_errors() const { return at<5>().valid(); } + ::protozero::ConstChars atrace_errors() const { return at<5>().as_string(); } + bool has_unknown_ftrace_events() const { return at<6>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstChars> unknown_ftrace_events() const { return GetRepeated<::protozero::ConstChars>(6); } + bool has_failed_ftrace_events() const { return at<7>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstChars> failed_ftrace_events() const { return GetRepeated<::protozero::ConstChars>(7); } + bool has_preserve_ftrace_buffer() const { return at<8>().valid(); } + bool preserve_ftrace_buffer() const { return at<8>().as_bool(); } + bool has_ftrace_parse_errors() const { return at<9>().valid(); } + ::protozero::RepeatedFieldIterator ftrace_parse_errors() const { return GetRepeated(9); } +}; + +class FtraceStats : public ::protozero::Message { + public: + using Decoder = FtraceStats_Decoder; + enum : int32_t { + kPhaseFieldNumber = 1, + kCpuStatsFieldNumber = 2, + kKernelSymbolsParsedFieldNumber = 3, + kKernelSymbolsMemKbFieldNumber = 4, + kAtraceErrorsFieldNumber = 5, + kUnknownFtraceEventsFieldNumber = 6, + kFailedFtraceEventsFieldNumber = 7, + kPreserveFtraceBufferFieldNumber = 8, + kFtraceParseErrorsFieldNumber = 9, + }; + static constexpr const char* GetName() { return ".perfetto.protos.FtraceStats"; } + + + using Phase = ::perfetto::protos::pbzero::FtraceStats_Phase; + static inline const char* Phase_Name(Phase value) { + return ::perfetto::protos::pbzero::FtraceStats_Phase_Name(value); + } + static inline const Phase UNSPECIFIED = Phase::UNSPECIFIED; + static inline const Phase START_OF_TRACE = Phase::START_OF_TRACE; + static inline const Phase END_OF_TRACE = Phase::END_OF_TRACE; + + using FieldMetadata_Phase = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + FtraceStats_Phase, + FtraceStats>; + + static constexpr FieldMetadata_Phase kPhase{}; + void set_phase(FtraceStats_Phase value) { + static constexpr uint32_t field_id = FieldMetadata_Phase::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CpuStats = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + FtraceCpuStats, + FtraceStats>; + + static constexpr FieldMetadata_CpuStats kCpuStats{}; + template T* add_cpu_stats() { + return BeginNestedMessage(2); + } + + + using FieldMetadata_KernelSymbolsParsed = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + FtraceStats>; + + static constexpr FieldMetadata_KernelSymbolsParsed kKernelSymbolsParsed{}; + void set_kernel_symbols_parsed(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_KernelSymbolsParsed::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_KernelSymbolsMemKb = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + FtraceStats>; + + static constexpr FieldMetadata_KernelSymbolsMemKb kKernelSymbolsMemKb{}; + void set_kernel_symbols_mem_kb(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_KernelSymbolsMemKb::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_AtraceErrors = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + FtraceStats>; + + static constexpr FieldMetadata_AtraceErrors kAtraceErrors{}; + void set_atrace_errors(const char* data, size_t size) { + AppendBytes(FieldMetadata_AtraceErrors::kFieldId, data, size); + } + void set_atrace_errors(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_AtraceErrors::kFieldId, chars.data, chars.size); + } + void set_atrace_errors(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_AtraceErrors::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_UnknownFtraceEvents = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + FtraceStats>; + + static constexpr FieldMetadata_UnknownFtraceEvents kUnknownFtraceEvents{}; + void add_unknown_ftrace_events(const char* data, size_t size) { + AppendBytes(FieldMetadata_UnknownFtraceEvents::kFieldId, data, size); + } + void add_unknown_ftrace_events(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_UnknownFtraceEvents::kFieldId, chars.data, chars.size); + } + void add_unknown_ftrace_events(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_UnknownFtraceEvents::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FailedFtraceEvents = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + FtraceStats>; + + static constexpr FieldMetadata_FailedFtraceEvents kFailedFtraceEvents{}; + void add_failed_ftrace_events(const char* data, size_t size) { + AppendBytes(FieldMetadata_FailedFtraceEvents::kFieldId, data, size); + } + void add_failed_ftrace_events(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_FailedFtraceEvents::kFieldId, chars.data, chars.size); + } + void add_failed_ftrace_events(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_FailedFtraceEvents::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PreserveFtraceBuffer = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + FtraceStats>; + + static constexpr FieldMetadata_PreserveFtraceBuffer kPreserveFtraceBuffer{}; + void set_preserve_ftrace_buffer(bool value) { + static constexpr uint32_t field_id = FieldMetadata_PreserveFtraceBuffer::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FtraceParseErrors = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + FtraceParseStatus, + FtraceStats>; + + static constexpr FieldMetadata_FtraceParseErrors kFtraceParseErrors{}; + void add_ftrace_parse_errors(FtraceParseStatus value) { + static constexpr uint32_t field_id = FieldMetadata_FtraceParseErrors::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } +}; + +class FtraceCpuStats_Decoder : public ::protozero::TypedProtoDecoder { + public: + FtraceCpuStats_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit FtraceCpuStats_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit FtraceCpuStats_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_cpu() const { return at<1>().valid(); } + uint64_t cpu() const { return at<1>().as_uint64(); } + bool has_entries() const { return at<2>().valid(); } + uint64_t entries() const { return at<2>().as_uint64(); } + bool has_overrun() const { return at<3>().valid(); } + uint64_t overrun() const { return at<3>().as_uint64(); } + bool has_commit_overrun() const { return at<4>().valid(); } + uint64_t commit_overrun() const { return at<4>().as_uint64(); } + bool has_bytes_read() const { return at<5>().valid(); } + uint64_t bytes_read() const { return at<5>().as_uint64(); } + bool has_oldest_event_ts() const { return at<6>().valid(); } + double oldest_event_ts() const { return at<6>().as_double(); } + bool has_now_ts() const { return at<7>().valid(); } + double now_ts() const { return at<7>().as_double(); } + bool has_dropped_events() const { return at<8>().valid(); } + uint64_t dropped_events() const { return at<8>().as_uint64(); } + bool has_read_events() const { return at<9>().valid(); } + uint64_t read_events() const { return at<9>().as_uint64(); } +}; + +class FtraceCpuStats : public ::protozero::Message { + public: + using Decoder = FtraceCpuStats_Decoder; + enum : int32_t { + kCpuFieldNumber = 1, + kEntriesFieldNumber = 2, + kOverrunFieldNumber = 3, + kCommitOverrunFieldNumber = 4, + kBytesReadFieldNumber = 5, + kOldestEventTsFieldNumber = 6, + kNowTsFieldNumber = 7, + kDroppedEventsFieldNumber = 8, + kReadEventsFieldNumber = 9, + }; + static constexpr const char* GetName() { return ".perfetto.protos.FtraceCpuStats"; } + + + using FieldMetadata_Cpu = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + FtraceCpuStats>; + + static constexpr FieldMetadata_Cpu kCpu{}; + void set_cpu(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Cpu::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Entries = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + FtraceCpuStats>; + + static constexpr FieldMetadata_Entries kEntries{}; + void set_entries(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Entries::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Overrun = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + FtraceCpuStats>; + + static constexpr FieldMetadata_Overrun kOverrun{}; + void set_overrun(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Overrun::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CommitOverrun = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + FtraceCpuStats>; + + static constexpr FieldMetadata_CommitOverrun kCommitOverrun{}; + void set_commit_overrun(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_CommitOverrun::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_BytesRead = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + FtraceCpuStats>; + + static constexpr FieldMetadata_BytesRead kBytesRead{}; + void set_bytes_read(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_BytesRead::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_OldestEventTs = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kDouble, + double, + FtraceCpuStats>; + + static constexpr FieldMetadata_OldestEventTs kOldestEventTs{}; + void set_oldest_event_ts(double value) { + static constexpr uint32_t field_id = FieldMetadata_OldestEventTs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kDouble> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NowTs = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kDouble, + double, + FtraceCpuStats>; + + static constexpr FieldMetadata_NowTs kNowTs{}; + void set_now_ts(double value) { + static constexpr uint32_t field_id = FieldMetadata_NowTs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kDouble> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DroppedEvents = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + FtraceCpuStats>; + + static constexpr FieldMetadata_DroppedEvents kDroppedEvents{}; + void set_dropped_events(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_DroppedEvents::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ReadEvents = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + FtraceCpuStats>; + + static constexpr FieldMetadata_ReadEvents kReadEvents{}; + void set_read_events(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_ReadEvents::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class FtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + FtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit FtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit FtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_timestamp() const { return at<1>().valid(); } + uint64_t timestamp() const { return at<1>().as_uint64(); } + bool has_pid() const { return at<2>().valid(); } + uint32_t pid() const { return at<2>().as_uint32(); } + bool has_common_flags() const { return at<5>().valid(); } + uint32_t common_flags() const { return at<5>().as_uint32(); } + bool has_print() const { return at<3>().valid(); } + ::protozero::ConstBytes print() const { return at<3>().as_bytes(); } + bool has_sched_switch() const { return at<4>().valid(); } + ::protozero::ConstBytes sched_switch() const { return at<4>().as_bytes(); } + bool has_cpu_frequency() const { return at<11>().valid(); } + ::protozero::ConstBytes cpu_frequency() const { return at<11>().as_bytes(); } + bool has_cpu_frequency_limits() const { return at<12>().valid(); } + ::protozero::ConstBytes cpu_frequency_limits() const { return at<12>().as_bytes(); } + bool has_cpu_idle() const { return at<13>().valid(); } + ::protozero::ConstBytes cpu_idle() const { return at<13>().as_bytes(); } + bool has_clock_enable() const { return at<14>().valid(); } + ::protozero::ConstBytes clock_enable() const { return at<14>().as_bytes(); } + bool has_clock_disable() const { return at<15>().valid(); } + ::protozero::ConstBytes clock_disable() const { return at<15>().as_bytes(); } + bool has_clock_set_rate() const { return at<16>().valid(); } + ::protozero::ConstBytes clock_set_rate() const { return at<16>().as_bytes(); } + bool has_sched_wakeup() const { return at<17>().valid(); } + ::protozero::ConstBytes sched_wakeup() const { return at<17>().as_bytes(); } + bool has_sched_blocked_reason() const { return at<18>().valid(); } + ::protozero::ConstBytes sched_blocked_reason() const { return at<18>().as_bytes(); } + bool has_sched_cpu_hotplug() const { return at<19>().valid(); } + ::protozero::ConstBytes sched_cpu_hotplug() const { return at<19>().as_bytes(); } + bool has_sched_waking() const { return at<20>().valid(); } + ::protozero::ConstBytes sched_waking() const { return at<20>().as_bytes(); } + bool has_ipi_entry() const { return at<21>().valid(); } + ::protozero::ConstBytes ipi_entry() const { return at<21>().as_bytes(); } + bool has_ipi_exit() const { return at<22>().valid(); } + ::protozero::ConstBytes ipi_exit() const { return at<22>().as_bytes(); } + bool has_ipi_raise() const { return at<23>().valid(); } + ::protozero::ConstBytes ipi_raise() const { return at<23>().as_bytes(); } + bool has_softirq_entry() const { return at<24>().valid(); } + ::protozero::ConstBytes softirq_entry() const { return at<24>().as_bytes(); } + bool has_softirq_exit() const { return at<25>().valid(); } + ::protozero::ConstBytes softirq_exit() const { return at<25>().as_bytes(); } + bool has_softirq_raise() const { return at<26>().valid(); } + ::protozero::ConstBytes softirq_raise() const { return at<26>().as_bytes(); } + bool has_i2c_read() const { return at<27>().valid(); } + ::protozero::ConstBytes i2c_read() const { return at<27>().as_bytes(); } + bool has_i2c_write() const { return at<28>().valid(); } + ::protozero::ConstBytes i2c_write() const { return at<28>().as_bytes(); } + bool has_i2c_result() const { return at<29>().valid(); } + ::protozero::ConstBytes i2c_result() const { return at<29>().as_bytes(); } + bool has_i2c_reply() const { return at<30>().valid(); } + ::protozero::ConstBytes i2c_reply() const { return at<30>().as_bytes(); } + bool has_smbus_read() const { return at<31>().valid(); } + ::protozero::ConstBytes smbus_read() const { return at<31>().as_bytes(); } + bool has_smbus_write() const { return at<32>().valid(); } + ::protozero::ConstBytes smbus_write() const { return at<32>().as_bytes(); } + bool has_smbus_result() const { return at<33>().valid(); } + ::protozero::ConstBytes smbus_result() const { return at<33>().as_bytes(); } + bool has_smbus_reply() const { return at<34>().valid(); } + ::protozero::ConstBytes smbus_reply() const { return at<34>().as_bytes(); } + bool has_lowmemory_kill() const { return at<35>().valid(); } + ::protozero::ConstBytes lowmemory_kill() const { return at<35>().as_bytes(); } + bool has_irq_handler_entry() const { return at<36>().valid(); } + ::protozero::ConstBytes irq_handler_entry() const { return at<36>().as_bytes(); } + bool has_irq_handler_exit() const { return at<37>().valid(); } + ::protozero::ConstBytes irq_handler_exit() const { return at<37>().as_bytes(); } + bool has_sync_pt() const { return at<38>().valid(); } + ::protozero::ConstBytes sync_pt() const { return at<38>().as_bytes(); } + bool has_sync_timeline() const { return at<39>().valid(); } + ::protozero::ConstBytes sync_timeline() const { return at<39>().as_bytes(); } + bool has_sync_wait() const { return at<40>().valid(); } + ::protozero::ConstBytes sync_wait() const { return at<40>().as_bytes(); } + bool has_ext4_da_write_begin() const { return at<41>().valid(); } + ::protozero::ConstBytes ext4_da_write_begin() const { return at<41>().as_bytes(); } + bool has_ext4_da_write_end() const { return at<42>().valid(); } + ::protozero::ConstBytes ext4_da_write_end() const { return at<42>().as_bytes(); } + bool has_ext4_sync_file_enter() const { return at<43>().valid(); } + ::protozero::ConstBytes ext4_sync_file_enter() const { return at<43>().as_bytes(); } + bool has_ext4_sync_file_exit() const { return at<44>().valid(); } + ::protozero::ConstBytes ext4_sync_file_exit() const { return at<44>().as_bytes(); } + bool has_block_rq_issue() const { return at<45>().valid(); } + ::protozero::ConstBytes block_rq_issue() const { return at<45>().as_bytes(); } + bool has_mm_vmscan_direct_reclaim_begin() const { return at<46>().valid(); } + ::protozero::ConstBytes mm_vmscan_direct_reclaim_begin() const { return at<46>().as_bytes(); } + bool has_mm_vmscan_direct_reclaim_end() const { return at<47>().valid(); } + ::protozero::ConstBytes mm_vmscan_direct_reclaim_end() const { return at<47>().as_bytes(); } + bool has_mm_vmscan_kswapd_wake() const { return at<48>().valid(); } + ::protozero::ConstBytes mm_vmscan_kswapd_wake() const { return at<48>().as_bytes(); } + bool has_mm_vmscan_kswapd_sleep() const { return at<49>().valid(); } + ::protozero::ConstBytes mm_vmscan_kswapd_sleep() const { return at<49>().as_bytes(); } + bool has_binder_transaction() const { return at<50>().valid(); } + ::protozero::ConstBytes binder_transaction() const { return at<50>().as_bytes(); } + bool has_binder_transaction_received() const { return at<51>().valid(); } + ::protozero::ConstBytes binder_transaction_received() const { return at<51>().as_bytes(); } + bool has_binder_set_priority() const { return at<52>().valid(); } + ::protozero::ConstBytes binder_set_priority() const { return at<52>().as_bytes(); } + bool has_binder_lock() const { return at<53>().valid(); } + ::protozero::ConstBytes binder_lock() const { return at<53>().as_bytes(); } + bool has_binder_locked() const { return at<54>().valid(); } + ::protozero::ConstBytes binder_locked() const { return at<54>().as_bytes(); } + bool has_binder_unlock() const { return at<55>().valid(); } + ::protozero::ConstBytes binder_unlock() const { return at<55>().as_bytes(); } + bool has_workqueue_activate_work() const { return at<56>().valid(); } + ::protozero::ConstBytes workqueue_activate_work() const { return at<56>().as_bytes(); } + bool has_workqueue_execute_end() const { return at<57>().valid(); } + ::protozero::ConstBytes workqueue_execute_end() const { return at<57>().as_bytes(); } + bool has_workqueue_execute_start() const { return at<58>().valid(); } + ::protozero::ConstBytes workqueue_execute_start() const { return at<58>().as_bytes(); } + bool has_workqueue_queue_work() const { return at<59>().valid(); } + ::protozero::ConstBytes workqueue_queue_work() const { return at<59>().as_bytes(); } + bool has_regulator_disable() const { return at<60>().valid(); } + ::protozero::ConstBytes regulator_disable() const { return at<60>().as_bytes(); } + bool has_regulator_disable_complete() const { return at<61>().valid(); } + ::protozero::ConstBytes regulator_disable_complete() const { return at<61>().as_bytes(); } + bool has_regulator_enable() const { return at<62>().valid(); } + ::protozero::ConstBytes regulator_enable() const { return at<62>().as_bytes(); } + bool has_regulator_enable_complete() const { return at<63>().valid(); } + ::protozero::ConstBytes regulator_enable_complete() const { return at<63>().as_bytes(); } + bool has_regulator_enable_delay() const { return at<64>().valid(); } + ::protozero::ConstBytes regulator_enable_delay() const { return at<64>().as_bytes(); } + bool has_regulator_set_voltage() const { return at<65>().valid(); } + ::protozero::ConstBytes regulator_set_voltage() const { return at<65>().as_bytes(); } + bool has_regulator_set_voltage_complete() const { return at<66>().valid(); } + ::protozero::ConstBytes regulator_set_voltage_complete() const { return at<66>().as_bytes(); } + bool has_cgroup_attach_task() const { return at<67>().valid(); } + ::protozero::ConstBytes cgroup_attach_task() const { return at<67>().as_bytes(); } + bool has_cgroup_mkdir() const { return at<68>().valid(); } + ::protozero::ConstBytes cgroup_mkdir() const { return at<68>().as_bytes(); } + bool has_cgroup_remount() const { return at<69>().valid(); } + ::protozero::ConstBytes cgroup_remount() const { return at<69>().as_bytes(); } + bool has_cgroup_rmdir() const { return at<70>().valid(); } + ::protozero::ConstBytes cgroup_rmdir() const { return at<70>().as_bytes(); } + bool has_cgroup_transfer_tasks() const { return at<71>().valid(); } + ::protozero::ConstBytes cgroup_transfer_tasks() const { return at<71>().as_bytes(); } + bool has_cgroup_destroy_root() const { return at<72>().valid(); } + ::protozero::ConstBytes cgroup_destroy_root() const { return at<72>().as_bytes(); } + bool has_cgroup_release() const { return at<73>().valid(); } + ::protozero::ConstBytes cgroup_release() const { return at<73>().as_bytes(); } + bool has_cgroup_rename() const { return at<74>().valid(); } + ::protozero::ConstBytes cgroup_rename() const { return at<74>().as_bytes(); } + bool has_cgroup_setup_root() const { return at<75>().valid(); } + ::protozero::ConstBytes cgroup_setup_root() const { return at<75>().as_bytes(); } + bool has_mdp_cmd_kickoff() const { return at<76>().valid(); } + ::protozero::ConstBytes mdp_cmd_kickoff() const { return at<76>().as_bytes(); } + bool has_mdp_commit() const { return at<77>().valid(); } + ::protozero::ConstBytes mdp_commit() const { return at<77>().as_bytes(); } + bool has_mdp_perf_set_ot() const { return at<78>().valid(); } + ::protozero::ConstBytes mdp_perf_set_ot() const { return at<78>().as_bytes(); } + bool has_mdp_sspp_change() const { return at<79>().valid(); } + ::protozero::ConstBytes mdp_sspp_change() const { return at<79>().as_bytes(); } + bool has_tracing_mark_write() const { return at<80>().valid(); } + ::protozero::ConstBytes tracing_mark_write() const { return at<80>().as_bytes(); } + bool has_mdp_cmd_pingpong_done() const { return at<81>().valid(); } + ::protozero::ConstBytes mdp_cmd_pingpong_done() const { return at<81>().as_bytes(); } + bool has_mdp_compare_bw() const { return at<82>().valid(); } + ::protozero::ConstBytes mdp_compare_bw() const { return at<82>().as_bytes(); } + bool has_mdp_perf_set_panic_luts() const { return at<83>().valid(); } + ::protozero::ConstBytes mdp_perf_set_panic_luts() const { return at<83>().as_bytes(); } + bool has_mdp_sspp_set() const { return at<84>().valid(); } + ::protozero::ConstBytes mdp_sspp_set() const { return at<84>().as_bytes(); } + bool has_mdp_cmd_readptr_done() const { return at<85>().valid(); } + ::protozero::ConstBytes mdp_cmd_readptr_done() const { return at<85>().as_bytes(); } + bool has_mdp_misr_crc() const { return at<86>().valid(); } + ::protozero::ConstBytes mdp_misr_crc() const { return at<86>().as_bytes(); } + bool has_mdp_perf_set_qos_luts() const { return at<87>().valid(); } + ::protozero::ConstBytes mdp_perf_set_qos_luts() const { return at<87>().as_bytes(); } + bool has_mdp_trace_counter() const { return at<88>().valid(); } + ::protozero::ConstBytes mdp_trace_counter() const { return at<88>().as_bytes(); } + bool has_mdp_cmd_release_bw() const { return at<89>().valid(); } + ::protozero::ConstBytes mdp_cmd_release_bw() const { return at<89>().as_bytes(); } + bool has_mdp_mixer_update() const { return at<90>().valid(); } + ::protozero::ConstBytes mdp_mixer_update() const { return at<90>().as_bytes(); } + bool has_mdp_perf_set_wm_levels() const { return at<91>().valid(); } + ::protozero::ConstBytes mdp_perf_set_wm_levels() const { return at<91>().as_bytes(); } + bool has_mdp_video_underrun_done() const { return at<92>().valid(); } + ::protozero::ConstBytes mdp_video_underrun_done() const { return at<92>().as_bytes(); } + bool has_mdp_cmd_wait_pingpong() const { return at<93>().valid(); } + ::protozero::ConstBytes mdp_cmd_wait_pingpong() const { return at<93>().as_bytes(); } + bool has_mdp_perf_prefill_calc() const { return at<94>().valid(); } + ::protozero::ConstBytes mdp_perf_prefill_calc() const { return at<94>().as_bytes(); } + bool has_mdp_perf_update_bus() const { return at<95>().valid(); } + ::protozero::ConstBytes mdp_perf_update_bus() const { return at<95>().as_bytes(); } + bool has_rotator_bw_ao_as_context() const { return at<96>().valid(); } + ::protozero::ConstBytes rotator_bw_ao_as_context() const { return at<96>().as_bytes(); } + bool has_mm_filemap_add_to_page_cache() const { return at<97>().valid(); } + ::protozero::ConstBytes mm_filemap_add_to_page_cache() const { return at<97>().as_bytes(); } + bool has_mm_filemap_delete_from_page_cache() const { return at<98>().valid(); } + ::protozero::ConstBytes mm_filemap_delete_from_page_cache() const { return at<98>().as_bytes(); } + bool has_mm_compaction_begin() const { return at<99>().valid(); } + ::protozero::ConstBytes mm_compaction_begin() const { return at<99>().as_bytes(); } + bool has_mm_compaction_defer_compaction() const { return at<100>().valid(); } + ::protozero::ConstBytes mm_compaction_defer_compaction() const { return at<100>().as_bytes(); } + bool has_mm_compaction_deferred() const { return at<101>().valid(); } + ::protozero::ConstBytes mm_compaction_deferred() const { return at<101>().as_bytes(); } + bool has_mm_compaction_defer_reset() const { return at<102>().valid(); } + ::protozero::ConstBytes mm_compaction_defer_reset() const { return at<102>().as_bytes(); } + bool has_mm_compaction_end() const { return at<103>().valid(); } + ::protozero::ConstBytes mm_compaction_end() const { return at<103>().as_bytes(); } + bool has_mm_compaction_finished() const { return at<104>().valid(); } + ::protozero::ConstBytes mm_compaction_finished() const { return at<104>().as_bytes(); } + bool has_mm_compaction_isolate_freepages() const { return at<105>().valid(); } + ::protozero::ConstBytes mm_compaction_isolate_freepages() const { return at<105>().as_bytes(); } + bool has_mm_compaction_isolate_migratepages() const { return at<106>().valid(); } + ::protozero::ConstBytes mm_compaction_isolate_migratepages() const { return at<106>().as_bytes(); } + bool has_mm_compaction_kcompactd_sleep() const { return at<107>().valid(); } + ::protozero::ConstBytes mm_compaction_kcompactd_sleep() const { return at<107>().as_bytes(); } + bool has_mm_compaction_kcompactd_wake() const { return at<108>().valid(); } + ::protozero::ConstBytes mm_compaction_kcompactd_wake() const { return at<108>().as_bytes(); } + bool has_mm_compaction_migratepages() const { return at<109>().valid(); } + ::protozero::ConstBytes mm_compaction_migratepages() const { return at<109>().as_bytes(); } + bool has_mm_compaction_suitable() const { return at<110>().valid(); } + ::protozero::ConstBytes mm_compaction_suitable() const { return at<110>().as_bytes(); } + bool has_mm_compaction_try_to_compact_pages() const { return at<111>().valid(); } + ::protozero::ConstBytes mm_compaction_try_to_compact_pages() const { return at<111>().as_bytes(); } + bool has_mm_compaction_wakeup_kcompactd() const { return at<112>().valid(); } + ::protozero::ConstBytes mm_compaction_wakeup_kcompactd() const { return at<112>().as_bytes(); } + bool has_suspend_resume() const { return at<113>().valid(); } + ::protozero::ConstBytes suspend_resume() const { return at<113>().as_bytes(); } + bool has_sched_wakeup_new() const { return at<114>().valid(); } + ::protozero::ConstBytes sched_wakeup_new() const { return at<114>().as_bytes(); } + bool has_block_bio_backmerge() const { return at<115>().valid(); } + ::protozero::ConstBytes block_bio_backmerge() const { return at<115>().as_bytes(); } + bool has_block_bio_bounce() const { return at<116>().valid(); } + ::protozero::ConstBytes block_bio_bounce() const { return at<116>().as_bytes(); } + bool has_block_bio_complete() const { return at<117>().valid(); } + ::protozero::ConstBytes block_bio_complete() const { return at<117>().as_bytes(); } + bool has_block_bio_frontmerge() const { return at<118>().valid(); } + ::protozero::ConstBytes block_bio_frontmerge() const { return at<118>().as_bytes(); } + bool has_block_bio_queue() const { return at<119>().valid(); } + ::protozero::ConstBytes block_bio_queue() const { return at<119>().as_bytes(); } + bool has_block_bio_remap() const { return at<120>().valid(); } + ::protozero::ConstBytes block_bio_remap() const { return at<120>().as_bytes(); } + bool has_block_dirty_buffer() const { return at<121>().valid(); } + ::protozero::ConstBytes block_dirty_buffer() const { return at<121>().as_bytes(); } + bool has_block_getrq() const { return at<122>().valid(); } + ::protozero::ConstBytes block_getrq() const { return at<122>().as_bytes(); } + bool has_block_plug() const { return at<123>().valid(); } + ::protozero::ConstBytes block_plug() const { return at<123>().as_bytes(); } + bool has_block_rq_abort() const { return at<124>().valid(); } + ::protozero::ConstBytes block_rq_abort() const { return at<124>().as_bytes(); } + bool has_block_rq_complete() const { return at<125>().valid(); } + ::protozero::ConstBytes block_rq_complete() const { return at<125>().as_bytes(); } + bool has_block_rq_insert() const { return at<126>().valid(); } + ::protozero::ConstBytes block_rq_insert() const { return at<126>().as_bytes(); } + bool has_block_rq_remap() const { return at<128>().valid(); } + ::protozero::ConstBytes block_rq_remap() const { return at<128>().as_bytes(); } + bool has_block_rq_requeue() const { return at<129>().valid(); } + ::protozero::ConstBytes block_rq_requeue() const { return at<129>().as_bytes(); } + bool has_block_sleeprq() const { return at<130>().valid(); } + ::protozero::ConstBytes block_sleeprq() const { return at<130>().as_bytes(); } + bool has_block_split() const { return at<131>().valid(); } + ::protozero::ConstBytes block_split() const { return at<131>().as_bytes(); } + bool has_block_touch_buffer() const { return at<132>().valid(); } + ::protozero::ConstBytes block_touch_buffer() const { return at<132>().as_bytes(); } + bool has_block_unplug() const { return at<133>().valid(); } + ::protozero::ConstBytes block_unplug() const { return at<133>().as_bytes(); } + bool has_ext4_alloc_da_blocks() const { return at<134>().valid(); } + ::protozero::ConstBytes ext4_alloc_da_blocks() const { return at<134>().as_bytes(); } + bool has_ext4_allocate_blocks() const { return at<135>().valid(); } + ::protozero::ConstBytes ext4_allocate_blocks() const { return at<135>().as_bytes(); } + bool has_ext4_allocate_inode() const { return at<136>().valid(); } + ::protozero::ConstBytes ext4_allocate_inode() const { return at<136>().as_bytes(); } + bool has_ext4_begin_ordered_truncate() const { return at<137>().valid(); } + ::protozero::ConstBytes ext4_begin_ordered_truncate() const { return at<137>().as_bytes(); } + bool has_ext4_collapse_range() const { return at<138>().valid(); } + ::protozero::ConstBytes ext4_collapse_range() const { return at<138>().as_bytes(); } + bool has_ext4_da_release_space() const { return at<139>().valid(); } + ::protozero::ConstBytes ext4_da_release_space() const { return at<139>().as_bytes(); } + bool has_ext4_da_reserve_space() const { return at<140>().valid(); } + ::protozero::ConstBytes ext4_da_reserve_space() const { return at<140>().as_bytes(); } + bool has_ext4_da_update_reserve_space() const { return at<141>().valid(); } + ::protozero::ConstBytes ext4_da_update_reserve_space() const { return at<141>().as_bytes(); } + bool has_ext4_da_write_pages() const { return at<142>().valid(); } + ::protozero::ConstBytes ext4_da_write_pages() const { return at<142>().as_bytes(); } + bool has_ext4_da_write_pages_extent() const { return at<143>().valid(); } + ::protozero::ConstBytes ext4_da_write_pages_extent() const { return at<143>().as_bytes(); } + bool has_ext4_direct_io_enter() const { return at<144>().valid(); } + ::protozero::ConstBytes ext4_direct_io_enter() const { return at<144>().as_bytes(); } + bool has_ext4_direct_io_exit() const { return at<145>().valid(); } + ::protozero::ConstBytes ext4_direct_io_exit() const { return at<145>().as_bytes(); } + bool has_ext4_discard_blocks() const { return at<146>().valid(); } + ::protozero::ConstBytes ext4_discard_blocks() const { return at<146>().as_bytes(); } + bool has_ext4_discard_preallocations() const { return at<147>().valid(); } + ::protozero::ConstBytes ext4_discard_preallocations() const { return at<147>().as_bytes(); } + bool has_ext4_drop_inode() const { return at<148>().valid(); } + ::protozero::ConstBytes ext4_drop_inode() const { return at<148>().as_bytes(); } + bool has_ext4_es_cache_extent() const { return at<149>().valid(); } + ::protozero::ConstBytes ext4_es_cache_extent() const { return at<149>().as_bytes(); } + bool has_ext4_es_find_delayed_extent_range_enter() const { return at<150>().valid(); } + ::protozero::ConstBytes ext4_es_find_delayed_extent_range_enter() const { return at<150>().as_bytes(); } + bool has_ext4_es_find_delayed_extent_range_exit() const { return at<151>().valid(); } + ::protozero::ConstBytes ext4_es_find_delayed_extent_range_exit() const { return at<151>().as_bytes(); } + bool has_ext4_es_insert_extent() const { return at<152>().valid(); } + ::protozero::ConstBytes ext4_es_insert_extent() const { return at<152>().as_bytes(); } + bool has_ext4_es_lookup_extent_enter() const { return at<153>().valid(); } + ::protozero::ConstBytes ext4_es_lookup_extent_enter() const { return at<153>().as_bytes(); } + bool has_ext4_es_lookup_extent_exit() const { return at<154>().valid(); } + ::protozero::ConstBytes ext4_es_lookup_extent_exit() const { return at<154>().as_bytes(); } + bool has_ext4_es_remove_extent() const { return at<155>().valid(); } + ::protozero::ConstBytes ext4_es_remove_extent() const { return at<155>().as_bytes(); } + bool has_ext4_es_shrink() const { return at<156>().valid(); } + ::protozero::ConstBytes ext4_es_shrink() const { return at<156>().as_bytes(); } + bool has_ext4_es_shrink_count() const { return at<157>().valid(); } + ::protozero::ConstBytes ext4_es_shrink_count() const { return at<157>().as_bytes(); } + bool has_ext4_es_shrink_scan_enter() const { return at<158>().valid(); } + ::protozero::ConstBytes ext4_es_shrink_scan_enter() const { return at<158>().as_bytes(); } + bool has_ext4_es_shrink_scan_exit() const { return at<159>().valid(); } + ::protozero::ConstBytes ext4_es_shrink_scan_exit() const { return at<159>().as_bytes(); } + bool has_ext4_evict_inode() const { return at<160>().valid(); } + ::protozero::ConstBytes ext4_evict_inode() const { return at<160>().as_bytes(); } + bool has_ext4_ext_convert_to_initialized_enter() const { return at<161>().valid(); } + ::protozero::ConstBytes ext4_ext_convert_to_initialized_enter() const { return at<161>().as_bytes(); } + bool has_ext4_ext_convert_to_initialized_fastpath() const { return at<162>().valid(); } + ::protozero::ConstBytes ext4_ext_convert_to_initialized_fastpath() const { return at<162>().as_bytes(); } + bool has_ext4_ext_handle_unwritten_extents() const { return at<163>().valid(); } + ::protozero::ConstBytes ext4_ext_handle_unwritten_extents() const { return at<163>().as_bytes(); } + bool has_ext4_ext_in_cache() const { return at<164>().valid(); } + ::protozero::ConstBytes ext4_ext_in_cache() const { return at<164>().as_bytes(); } + bool has_ext4_ext_load_extent() const { return at<165>().valid(); } + ::protozero::ConstBytes ext4_ext_load_extent() const { return at<165>().as_bytes(); } + bool has_ext4_ext_map_blocks_enter() const { return at<166>().valid(); } + ::protozero::ConstBytes ext4_ext_map_blocks_enter() const { return at<166>().as_bytes(); } + bool has_ext4_ext_map_blocks_exit() const { return at<167>().valid(); } + ::protozero::ConstBytes ext4_ext_map_blocks_exit() const { return at<167>().as_bytes(); } + bool has_ext4_ext_put_in_cache() const { return at<168>().valid(); } + ::protozero::ConstBytes ext4_ext_put_in_cache() const { return at<168>().as_bytes(); } + bool has_ext4_ext_remove_space() const { return at<169>().valid(); } + ::protozero::ConstBytes ext4_ext_remove_space() const { return at<169>().as_bytes(); } + bool has_ext4_ext_remove_space_done() const { return at<170>().valid(); } + ::protozero::ConstBytes ext4_ext_remove_space_done() const { return at<170>().as_bytes(); } + bool has_ext4_ext_rm_idx() const { return at<171>().valid(); } + ::protozero::ConstBytes ext4_ext_rm_idx() const { return at<171>().as_bytes(); } + bool has_ext4_ext_rm_leaf() const { return at<172>().valid(); } + ::protozero::ConstBytes ext4_ext_rm_leaf() const { return at<172>().as_bytes(); } + bool has_ext4_ext_show_extent() const { return at<173>().valid(); } + ::protozero::ConstBytes ext4_ext_show_extent() const { return at<173>().as_bytes(); } + bool has_ext4_fallocate_enter() const { return at<174>().valid(); } + ::protozero::ConstBytes ext4_fallocate_enter() const { return at<174>().as_bytes(); } + bool has_ext4_fallocate_exit() const { return at<175>().valid(); } + ::protozero::ConstBytes ext4_fallocate_exit() const { return at<175>().as_bytes(); } + bool has_ext4_find_delalloc_range() const { return at<176>().valid(); } + ::protozero::ConstBytes ext4_find_delalloc_range() const { return at<176>().as_bytes(); } + bool has_ext4_forget() const { return at<177>().valid(); } + ::protozero::ConstBytes ext4_forget() const { return at<177>().as_bytes(); } + bool has_ext4_free_blocks() const { return at<178>().valid(); } + ::protozero::ConstBytes ext4_free_blocks() const { return at<178>().as_bytes(); } + bool has_ext4_free_inode() const { return at<179>().valid(); } + ::protozero::ConstBytes ext4_free_inode() const { return at<179>().as_bytes(); } + bool has_ext4_get_implied_cluster_alloc_exit() const { return at<180>().valid(); } + ::protozero::ConstBytes ext4_get_implied_cluster_alloc_exit() const { return at<180>().as_bytes(); } + bool has_ext4_get_reserved_cluster_alloc() const { return at<181>().valid(); } + ::protozero::ConstBytes ext4_get_reserved_cluster_alloc() const { return at<181>().as_bytes(); } + bool has_ext4_ind_map_blocks_enter() const { return at<182>().valid(); } + ::protozero::ConstBytes ext4_ind_map_blocks_enter() const { return at<182>().as_bytes(); } + bool has_ext4_ind_map_blocks_exit() const { return at<183>().valid(); } + ::protozero::ConstBytes ext4_ind_map_blocks_exit() const { return at<183>().as_bytes(); } + bool has_ext4_insert_range() const { return at<184>().valid(); } + ::protozero::ConstBytes ext4_insert_range() const { return at<184>().as_bytes(); } + bool has_ext4_invalidatepage() const { return at<185>().valid(); } + ::protozero::ConstBytes ext4_invalidatepage() const { return at<185>().as_bytes(); } + bool has_ext4_journal_start() const { return at<186>().valid(); } + ::protozero::ConstBytes ext4_journal_start() const { return at<186>().as_bytes(); } + bool has_ext4_journal_start_reserved() const { return at<187>().valid(); } + ::protozero::ConstBytes ext4_journal_start_reserved() const { return at<187>().as_bytes(); } + bool has_ext4_journalled_invalidatepage() const { return at<188>().valid(); } + ::protozero::ConstBytes ext4_journalled_invalidatepage() const { return at<188>().as_bytes(); } + bool has_ext4_journalled_write_end() const { return at<189>().valid(); } + ::protozero::ConstBytes ext4_journalled_write_end() const { return at<189>().as_bytes(); } + bool has_ext4_load_inode() const { return at<190>().valid(); } + ::protozero::ConstBytes ext4_load_inode() const { return at<190>().as_bytes(); } + bool has_ext4_load_inode_bitmap() const { return at<191>().valid(); } + ::protozero::ConstBytes ext4_load_inode_bitmap() const { return at<191>().as_bytes(); } + bool has_ext4_mark_inode_dirty() const { return at<192>().valid(); } + ::protozero::ConstBytes ext4_mark_inode_dirty() const { return at<192>().as_bytes(); } + bool has_ext4_mb_bitmap_load() const { return at<193>().valid(); } + ::protozero::ConstBytes ext4_mb_bitmap_load() const { return at<193>().as_bytes(); } + bool has_ext4_mb_buddy_bitmap_load() const { return at<194>().valid(); } + ::protozero::ConstBytes ext4_mb_buddy_bitmap_load() const { return at<194>().as_bytes(); } + bool has_ext4_mb_discard_preallocations() const { return at<195>().valid(); } + ::protozero::ConstBytes ext4_mb_discard_preallocations() const { return at<195>().as_bytes(); } + bool has_ext4_mb_new_group_pa() const { return at<196>().valid(); } + ::protozero::ConstBytes ext4_mb_new_group_pa() const { return at<196>().as_bytes(); } + bool has_ext4_mb_new_inode_pa() const { return at<197>().valid(); } + ::protozero::ConstBytes ext4_mb_new_inode_pa() const { return at<197>().as_bytes(); } + bool has_ext4_mb_release_group_pa() const { return at<198>().valid(); } + ::protozero::ConstBytes ext4_mb_release_group_pa() const { return at<198>().as_bytes(); } + bool has_ext4_mb_release_inode_pa() const { return at<199>().valid(); } + ::protozero::ConstBytes ext4_mb_release_inode_pa() const { return at<199>().as_bytes(); } + bool has_ext4_mballoc_alloc() const { return at<200>().valid(); } + ::protozero::ConstBytes ext4_mballoc_alloc() const { return at<200>().as_bytes(); } + bool has_ext4_mballoc_discard() const { return at<201>().valid(); } + ::protozero::ConstBytes ext4_mballoc_discard() const { return at<201>().as_bytes(); } + bool has_ext4_mballoc_free() const { return at<202>().valid(); } + ::protozero::ConstBytes ext4_mballoc_free() const { return at<202>().as_bytes(); } + bool has_ext4_mballoc_prealloc() const { return at<203>().valid(); } + ::protozero::ConstBytes ext4_mballoc_prealloc() const { return at<203>().as_bytes(); } + bool has_ext4_other_inode_update_time() const { return at<204>().valid(); } + ::protozero::ConstBytes ext4_other_inode_update_time() const { return at<204>().as_bytes(); } + bool has_ext4_punch_hole() const { return at<205>().valid(); } + ::protozero::ConstBytes ext4_punch_hole() const { return at<205>().as_bytes(); } + bool has_ext4_read_block_bitmap_load() const { return at<206>().valid(); } + ::protozero::ConstBytes ext4_read_block_bitmap_load() const { return at<206>().as_bytes(); } + bool has_ext4_readpage() const { return at<207>().valid(); } + ::protozero::ConstBytes ext4_readpage() const { return at<207>().as_bytes(); } + bool has_ext4_releasepage() const { return at<208>().valid(); } + ::protozero::ConstBytes ext4_releasepage() const { return at<208>().as_bytes(); } + bool has_ext4_remove_blocks() const { return at<209>().valid(); } + ::protozero::ConstBytes ext4_remove_blocks() const { return at<209>().as_bytes(); } + bool has_ext4_request_blocks() const { return at<210>().valid(); } + ::protozero::ConstBytes ext4_request_blocks() const { return at<210>().as_bytes(); } + bool has_ext4_request_inode() const { return at<211>().valid(); } + ::protozero::ConstBytes ext4_request_inode() const { return at<211>().as_bytes(); } + bool has_ext4_sync_fs() const { return at<212>().valid(); } + ::protozero::ConstBytes ext4_sync_fs() const { return at<212>().as_bytes(); } + bool has_ext4_trim_all_free() const { return at<213>().valid(); } + ::protozero::ConstBytes ext4_trim_all_free() const { return at<213>().as_bytes(); } + bool has_ext4_trim_extent() const { return at<214>().valid(); } + ::protozero::ConstBytes ext4_trim_extent() const { return at<214>().as_bytes(); } + bool has_ext4_truncate_enter() const { return at<215>().valid(); } + ::protozero::ConstBytes ext4_truncate_enter() const { return at<215>().as_bytes(); } + bool has_ext4_truncate_exit() const { return at<216>().valid(); } + ::protozero::ConstBytes ext4_truncate_exit() const { return at<216>().as_bytes(); } + bool has_ext4_unlink_enter() const { return at<217>().valid(); } + ::protozero::ConstBytes ext4_unlink_enter() const { return at<217>().as_bytes(); } + bool has_ext4_unlink_exit() const { return at<218>().valid(); } + ::protozero::ConstBytes ext4_unlink_exit() const { return at<218>().as_bytes(); } + bool has_ext4_write_begin() const { return at<219>().valid(); } + ::protozero::ConstBytes ext4_write_begin() const { return at<219>().as_bytes(); } + bool has_ext4_write_end() const { return at<230>().valid(); } + ::protozero::ConstBytes ext4_write_end() const { return at<230>().as_bytes(); } + bool has_ext4_writepage() const { return at<231>().valid(); } + ::protozero::ConstBytes ext4_writepage() const { return at<231>().as_bytes(); } + bool has_ext4_writepages() const { return at<232>().valid(); } + ::protozero::ConstBytes ext4_writepages() const { return at<232>().as_bytes(); } + bool has_ext4_writepages_result() const { return at<233>().valid(); } + ::protozero::ConstBytes ext4_writepages_result() const { return at<233>().as_bytes(); } + bool has_ext4_zero_range() const { return at<234>().valid(); } + ::protozero::ConstBytes ext4_zero_range() const { return at<234>().as_bytes(); } + bool has_task_newtask() const { return at<235>().valid(); } + ::protozero::ConstBytes task_newtask() const { return at<235>().as_bytes(); } + bool has_task_rename() const { return at<236>().valid(); } + ::protozero::ConstBytes task_rename() const { return at<236>().as_bytes(); } + bool has_sched_process_exec() const { return at<237>().valid(); } + ::protozero::ConstBytes sched_process_exec() const { return at<237>().as_bytes(); } + bool has_sched_process_exit() const { return at<238>().valid(); } + ::protozero::ConstBytes sched_process_exit() const { return at<238>().as_bytes(); } + bool has_sched_process_fork() const { return at<239>().valid(); } + ::protozero::ConstBytes sched_process_fork() const { return at<239>().as_bytes(); } + bool has_sched_process_free() const { return at<240>().valid(); } + ::protozero::ConstBytes sched_process_free() const { return at<240>().as_bytes(); } + bool has_sched_process_hang() const { return at<241>().valid(); } + ::protozero::ConstBytes sched_process_hang() const { return at<241>().as_bytes(); } + bool has_sched_process_wait() const { return at<242>().valid(); } + ::protozero::ConstBytes sched_process_wait() const { return at<242>().as_bytes(); } + bool has_f2fs_do_submit_bio() const { return at<243>().valid(); } + ::protozero::ConstBytes f2fs_do_submit_bio() const { return at<243>().as_bytes(); } + bool has_f2fs_evict_inode() const { return at<244>().valid(); } + ::protozero::ConstBytes f2fs_evict_inode() const { return at<244>().as_bytes(); } + bool has_f2fs_fallocate() const { return at<245>().valid(); } + ::protozero::ConstBytes f2fs_fallocate() const { return at<245>().as_bytes(); } + bool has_f2fs_get_data_block() const { return at<246>().valid(); } + ::protozero::ConstBytes f2fs_get_data_block() const { return at<246>().as_bytes(); } + bool has_f2fs_get_victim() const { return at<247>().valid(); } + ::protozero::ConstBytes f2fs_get_victim() const { return at<247>().as_bytes(); } + bool has_f2fs_iget() const { return at<248>().valid(); } + ::protozero::ConstBytes f2fs_iget() const { return at<248>().as_bytes(); } + bool has_f2fs_iget_exit() const { return at<249>().valid(); } + ::protozero::ConstBytes f2fs_iget_exit() const { return at<249>().as_bytes(); } + bool has_f2fs_new_inode() const { return at<250>().valid(); } + ::protozero::ConstBytes f2fs_new_inode() const { return at<250>().as_bytes(); } + bool has_f2fs_readpage() const { return at<251>().valid(); } + ::protozero::ConstBytes f2fs_readpage() const { return at<251>().as_bytes(); } + bool has_f2fs_reserve_new_block() const { return at<252>().valid(); } + ::protozero::ConstBytes f2fs_reserve_new_block() const { return at<252>().as_bytes(); } + bool has_f2fs_set_page_dirty() const { return at<253>().valid(); } + ::protozero::ConstBytes f2fs_set_page_dirty() const { return at<253>().as_bytes(); } + bool has_f2fs_submit_write_page() const { return at<254>().valid(); } + ::protozero::ConstBytes f2fs_submit_write_page() const { return at<254>().as_bytes(); } + bool has_f2fs_sync_file_enter() const { return at<255>().valid(); } + ::protozero::ConstBytes f2fs_sync_file_enter() const { return at<255>().as_bytes(); } + bool has_f2fs_sync_file_exit() const { return at<256>().valid(); } + ::protozero::ConstBytes f2fs_sync_file_exit() const { return at<256>().as_bytes(); } + bool has_f2fs_sync_fs() const { return at<257>().valid(); } + ::protozero::ConstBytes f2fs_sync_fs() const { return at<257>().as_bytes(); } + bool has_f2fs_truncate() const { return at<258>().valid(); } + ::protozero::ConstBytes f2fs_truncate() const { return at<258>().as_bytes(); } + bool has_f2fs_truncate_blocks_enter() const { return at<259>().valid(); } + ::protozero::ConstBytes f2fs_truncate_blocks_enter() const { return at<259>().as_bytes(); } + bool has_f2fs_truncate_blocks_exit() const { return at<260>().valid(); } + ::protozero::ConstBytes f2fs_truncate_blocks_exit() const { return at<260>().as_bytes(); } + bool has_f2fs_truncate_data_blocks_range() const { return at<261>().valid(); } + ::protozero::ConstBytes f2fs_truncate_data_blocks_range() const { return at<261>().as_bytes(); } + bool has_f2fs_truncate_inode_blocks_enter() const { return at<262>().valid(); } + ::protozero::ConstBytes f2fs_truncate_inode_blocks_enter() const { return at<262>().as_bytes(); } + bool has_f2fs_truncate_inode_blocks_exit() const { return at<263>().valid(); } + ::protozero::ConstBytes f2fs_truncate_inode_blocks_exit() const { return at<263>().as_bytes(); } + bool has_f2fs_truncate_node() const { return at<264>().valid(); } + ::protozero::ConstBytes f2fs_truncate_node() const { return at<264>().as_bytes(); } + bool has_f2fs_truncate_nodes_enter() const { return at<265>().valid(); } + ::protozero::ConstBytes f2fs_truncate_nodes_enter() const { return at<265>().as_bytes(); } + bool has_f2fs_truncate_nodes_exit() const { return at<266>().valid(); } + ::protozero::ConstBytes f2fs_truncate_nodes_exit() const { return at<266>().as_bytes(); } + bool has_f2fs_truncate_partial_nodes() const { return at<267>().valid(); } + ::protozero::ConstBytes f2fs_truncate_partial_nodes() const { return at<267>().as_bytes(); } + bool has_f2fs_unlink_enter() const { return at<268>().valid(); } + ::protozero::ConstBytes f2fs_unlink_enter() const { return at<268>().as_bytes(); } + bool has_f2fs_unlink_exit() const { return at<269>().valid(); } + ::protozero::ConstBytes f2fs_unlink_exit() const { return at<269>().as_bytes(); } + bool has_f2fs_vm_page_mkwrite() const { return at<270>().valid(); } + ::protozero::ConstBytes f2fs_vm_page_mkwrite() const { return at<270>().as_bytes(); } + bool has_f2fs_write_begin() const { return at<271>().valid(); } + ::protozero::ConstBytes f2fs_write_begin() const { return at<271>().as_bytes(); } + bool has_f2fs_write_checkpoint() const { return at<272>().valid(); } + ::protozero::ConstBytes f2fs_write_checkpoint() const { return at<272>().as_bytes(); } + bool has_f2fs_write_end() const { return at<273>().valid(); } + ::protozero::ConstBytes f2fs_write_end() const { return at<273>().as_bytes(); } + bool has_alloc_pages_iommu_end() const { return at<274>().valid(); } + ::protozero::ConstBytes alloc_pages_iommu_end() const { return at<274>().as_bytes(); } + bool has_alloc_pages_iommu_fail() const { return at<275>().valid(); } + ::protozero::ConstBytes alloc_pages_iommu_fail() const { return at<275>().as_bytes(); } + bool has_alloc_pages_iommu_start() const { return at<276>().valid(); } + ::protozero::ConstBytes alloc_pages_iommu_start() const { return at<276>().as_bytes(); } + bool has_alloc_pages_sys_end() const { return at<277>().valid(); } + ::protozero::ConstBytes alloc_pages_sys_end() const { return at<277>().as_bytes(); } + bool has_alloc_pages_sys_fail() const { return at<278>().valid(); } + ::protozero::ConstBytes alloc_pages_sys_fail() const { return at<278>().as_bytes(); } + bool has_alloc_pages_sys_start() const { return at<279>().valid(); } + ::protozero::ConstBytes alloc_pages_sys_start() const { return at<279>().as_bytes(); } + bool has_dma_alloc_contiguous_retry() const { return at<280>().valid(); } + ::protozero::ConstBytes dma_alloc_contiguous_retry() const { return at<280>().as_bytes(); } + bool has_iommu_map_range() const { return at<281>().valid(); } + ::protozero::ConstBytes iommu_map_range() const { return at<281>().as_bytes(); } + bool has_iommu_sec_ptbl_map_range_end() const { return at<282>().valid(); } + ::protozero::ConstBytes iommu_sec_ptbl_map_range_end() const { return at<282>().as_bytes(); } + bool has_iommu_sec_ptbl_map_range_start() const { return at<283>().valid(); } + ::protozero::ConstBytes iommu_sec_ptbl_map_range_start() const { return at<283>().as_bytes(); } + bool has_ion_alloc_buffer_end() const { return at<284>().valid(); } + ::protozero::ConstBytes ion_alloc_buffer_end() const { return at<284>().as_bytes(); } + bool has_ion_alloc_buffer_fail() const { return at<285>().valid(); } + ::protozero::ConstBytes ion_alloc_buffer_fail() const { return at<285>().as_bytes(); } + bool has_ion_alloc_buffer_fallback() const { return at<286>().valid(); } + ::protozero::ConstBytes ion_alloc_buffer_fallback() const { return at<286>().as_bytes(); } + bool has_ion_alloc_buffer_start() const { return at<287>().valid(); } + ::protozero::ConstBytes ion_alloc_buffer_start() const { return at<287>().as_bytes(); } + bool has_ion_cp_alloc_retry() const { return at<288>().valid(); } + ::protozero::ConstBytes ion_cp_alloc_retry() const { return at<288>().as_bytes(); } + bool has_ion_cp_secure_buffer_end() const { return at<289>().valid(); } + ::protozero::ConstBytes ion_cp_secure_buffer_end() const { return at<289>().as_bytes(); } + bool has_ion_cp_secure_buffer_start() const { return at<290>().valid(); } + ::protozero::ConstBytes ion_cp_secure_buffer_start() const { return at<290>().as_bytes(); } + bool has_ion_prefetching() const { return at<291>().valid(); } + ::protozero::ConstBytes ion_prefetching() const { return at<291>().as_bytes(); } + bool has_ion_secure_cma_add_to_pool_end() const { return at<292>().valid(); } + ::protozero::ConstBytes ion_secure_cma_add_to_pool_end() const { return at<292>().as_bytes(); } + bool has_ion_secure_cma_add_to_pool_start() const { return at<293>().valid(); } + ::protozero::ConstBytes ion_secure_cma_add_to_pool_start() const { return at<293>().as_bytes(); } + bool has_ion_secure_cma_allocate_end() const { return at<294>().valid(); } + ::protozero::ConstBytes ion_secure_cma_allocate_end() const { return at<294>().as_bytes(); } + bool has_ion_secure_cma_allocate_start() const { return at<295>().valid(); } + ::protozero::ConstBytes ion_secure_cma_allocate_start() const { return at<295>().as_bytes(); } + bool has_ion_secure_cma_shrink_pool_end() const { return at<296>().valid(); } + ::protozero::ConstBytes ion_secure_cma_shrink_pool_end() const { return at<296>().as_bytes(); } + bool has_ion_secure_cma_shrink_pool_start() const { return at<297>().valid(); } + ::protozero::ConstBytes ion_secure_cma_shrink_pool_start() const { return at<297>().as_bytes(); } + bool has_kfree() const { return at<298>().valid(); } + ::protozero::ConstBytes kfree() const { return at<298>().as_bytes(); } + bool has_kmalloc() const { return at<299>().valid(); } + ::protozero::ConstBytes kmalloc() const { return at<299>().as_bytes(); } + bool has_kmalloc_node() const { return at<300>().valid(); } + ::protozero::ConstBytes kmalloc_node() const { return at<300>().as_bytes(); } + bool has_kmem_cache_alloc() const { return at<301>().valid(); } + ::protozero::ConstBytes kmem_cache_alloc() const { return at<301>().as_bytes(); } + bool has_kmem_cache_alloc_node() const { return at<302>().valid(); } + ::protozero::ConstBytes kmem_cache_alloc_node() const { return at<302>().as_bytes(); } + bool has_kmem_cache_free() const { return at<303>().valid(); } + ::protozero::ConstBytes kmem_cache_free() const { return at<303>().as_bytes(); } + bool has_migrate_pages_end() const { return at<304>().valid(); } + ::protozero::ConstBytes migrate_pages_end() const { return at<304>().as_bytes(); } + bool has_migrate_pages_start() const { return at<305>().valid(); } + ::protozero::ConstBytes migrate_pages_start() const { return at<305>().as_bytes(); } + bool has_migrate_retry() const { return at<306>().valid(); } + ::protozero::ConstBytes migrate_retry() const { return at<306>().as_bytes(); } + bool has_mm_page_alloc() const { return at<307>().valid(); } + ::protozero::ConstBytes mm_page_alloc() const { return at<307>().as_bytes(); } + bool has_mm_page_alloc_extfrag() const { return at<308>().valid(); } + ::protozero::ConstBytes mm_page_alloc_extfrag() const { return at<308>().as_bytes(); } + bool has_mm_page_alloc_zone_locked() const { return at<309>().valid(); } + ::protozero::ConstBytes mm_page_alloc_zone_locked() const { return at<309>().as_bytes(); } + bool has_mm_page_free() const { return at<310>().valid(); } + ::protozero::ConstBytes mm_page_free() const { return at<310>().as_bytes(); } + bool has_mm_page_free_batched() const { return at<311>().valid(); } + ::protozero::ConstBytes mm_page_free_batched() const { return at<311>().as_bytes(); } + bool has_mm_page_pcpu_drain() const { return at<312>().valid(); } + ::protozero::ConstBytes mm_page_pcpu_drain() const { return at<312>().as_bytes(); } + bool has_rss_stat() const { return at<313>().valid(); } + ::protozero::ConstBytes rss_stat() const { return at<313>().as_bytes(); } + bool has_ion_heap_shrink() const { return at<314>().valid(); } + ::protozero::ConstBytes ion_heap_shrink() const { return at<314>().as_bytes(); } + bool has_ion_heap_grow() const { return at<315>().valid(); } + ::protozero::ConstBytes ion_heap_grow() const { return at<315>().as_bytes(); } + bool has_fence_init() const { return at<316>().valid(); } + ::protozero::ConstBytes fence_init() const { return at<316>().as_bytes(); } + bool has_fence_destroy() const { return at<317>().valid(); } + ::protozero::ConstBytes fence_destroy() const { return at<317>().as_bytes(); } + bool has_fence_enable_signal() const { return at<318>().valid(); } + ::protozero::ConstBytes fence_enable_signal() const { return at<318>().as_bytes(); } + bool has_fence_signaled() const { return at<319>().valid(); } + ::protozero::ConstBytes fence_signaled() const { return at<319>().as_bytes(); } + bool has_clk_enable() const { return at<320>().valid(); } + ::protozero::ConstBytes clk_enable() const { return at<320>().as_bytes(); } + bool has_clk_disable() const { return at<321>().valid(); } + ::protozero::ConstBytes clk_disable() const { return at<321>().as_bytes(); } + bool has_clk_set_rate() const { return at<322>().valid(); } + ::protozero::ConstBytes clk_set_rate() const { return at<322>().as_bytes(); } + bool has_binder_transaction_alloc_buf() const { return at<323>().valid(); } + ::protozero::ConstBytes binder_transaction_alloc_buf() const { return at<323>().as_bytes(); } + bool has_signal_deliver() const { return at<324>().valid(); } + ::protozero::ConstBytes signal_deliver() const { return at<324>().as_bytes(); } + bool has_signal_generate() const { return at<325>().valid(); } + ::protozero::ConstBytes signal_generate() const { return at<325>().as_bytes(); } + bool has_oom_score_adj_update() const { return at<326>().valid(); } + ::protozero::ConstBytes oom_score_adj_update() const { return at<326>().as_bytes(); } + bool has_generic() const { return at<327>().valid(); } + ::protozero::ConstBytes generic() const { return at<327>().as_bytes(); } + bool has_mm_event_record() const { return at<328>().valid(); } + ::protozero::ConstBytes mm_event_record() const { return at<328>().as_bytes(); } + bool has_sys_enter() const { return at<329>().valid(); } + ::protozero::ConstBytes sys_enter() const { return at<329>().as_bytes(); } + bool has_sys_exit() const { return at<330>().valid(); } + ::protozero::ConstBytes sys_exit() const { return at<330>().as_bytes(); } + bool has_zero() const { return at<331>().valid(); } + ::protozero::ConstBytes zero() const { return at<331>().as_bytes(); } + bool has_gpu_frequency() const { return at<332>().valid(); } + ::protozero::ConstBytes gpu_frequency() const { return at<332>().as_bytes(); } + bool has_sde_tracing_mark_write() const { return at<333>().valid(); } + ::protozero::ConstBytes sde_tracing_mark_write() const { return at<333>().as_bytes(); } + bool has_mark_victim() const { return at<334>().valid(); } + ::protozero::ConstBytes mark_victim() const { return at<334>().as_bytes(); } + bool has_ion_stat() const { return at<335>().valid(); } + ::protozero::ConstBytes ion_stat() const { return at<335>().as_bytes(); } + bool has_ion_buffer_create() const { return at<336>().valid(); } + ::protozero::ConstBytes ion_buffer_create() const { return at<336>().as_bytes(); } + bool has_ion_buffer_destroy() const { return at<337>().valid(); } + ::protozero::ConstBytes ion_buffer_destroy() const { return at<337>().as_bytes(); } + bool has_scm_call_start() const { return at<338>().valid(); } + ::protozero::ConstBytes scm_call_start() const { return at<338>().as_bytes(); } + bool has_scm_call_end() const { return at<339>().valid(); } + ::protozero::ConstBytes scm_call_end() const { return at<339>().as_bytes(); } + bool has_gpu_mem_total() const { return at<340>().valid(); } + ::protozero::ConstBytes gpu_mem_total() const { return at<340>().as_bytes(); } + bool has_thermal_temperature() const { return at<341>().valid(); } + ::protozero::ConstBytes thermal_temperature() const { return at<341>().as_bytes(); } + bool has_cdev_update() const { return at<342>().valid(); } + ::protozero::ConstBytes cdev_update() const { return at<342>().as_bytes(); } + bool has_cpuhp_exit() const { return at<343>().valid(); } + ::protozero::ConstBytes cpuhp_exit() const { return at<343>().as_bytes(); } + bool has_cpuhp_multi_enter() const { return at<344>().valid(); } + ::protozero::ConstBytes cpuhp_multi_enter() const { return at<344>().as_bytes(); } + bool has_cpuhp_enter() const { return at<345>().valid(); } + ::protozero::ConstBytes cpuhp_enter() const { return at<345>().as_bytes(); } + bool has_cpuhp_latency() const { return at<346>().valid(); } + ::protozero::ConstBytes cpuhp_latency() const { return at<346>().as_bytes(); } + bool has_fastrpc_dma_stat() const { return at<347>().valid(); } + ::protozero::ConstBytes fastrpc_dma_stat() const { return at<347>().as_bytes(); } + bool has_dpu_tracing_mark_write() const { return at<348>().valid(); } + ::protozero::ConstBytes dpu_tracing_mark_write() const { return at<348>().as_bytes(); } + bool has_g2d_tracing_mark_write() const { return at<349>().valid(); } + ::protozero::ConstBytes g2d_tracing_mark_write() const { return at<349>().as_bytes(); } + bool has_mali_tracing_mark_write() const { return at<350>().valid(); } + ::protozero::ConstBytes mali_tracing_mark_write() const { return at<350>().as_bytes(); } + bool has_dma_heap_stat() const { return at<351>().valid(); } + ::protozero::ConstBytes dma_heap_stat() const { return at<351>().as_bytes(); } + bool has_cpuhp_pause() const { return at<352>().valid(); } + ::protozero::ConstBytes cpuhp_pause() const { return at<352>().as_bytes(); } + bool has_sched_pi_setprio() const { return at<353>().valid(); } + ::protozero::ConstBytes sched_pi_setprio() const { return at<353>().as_bytes(); } + bool has_sde_sde_evtlog() const { return at<354>().valid(); } + ::protozero::ConstBytes sde_sde_evtlog() const { return at<354>().as_bytes(); } + bool has_sde_sde_perf_calc_crtc() const { return at<355>().valid(); } + ::protozero::ConstBytes sde_sde_perf_calc_crtc() const { return at<355>().as_bytes(); } + bool has_sde_sde_perf_crtc_update() const { return at<356>().valid(); } + ::protozero::ConstBytes sde_sde_perf_crtc_update() const { return at<356>().as_bytes(); } + bool has_sde_sde_perf_set_qos_luts() const { return at<357>().valid(); } + ::protozero::ConstBytes sde_sde_perf_set_qos_luts() const { return at<357>().as_bytes(); } + bool has_sde_sde_perf_update_bus() const { return at<358>().valid(); } + ::protozero::ConstBytes sde_sde_perf_update_bus() const { return at<358>().as_bytes(); } + bool has_rss_stat_throttled() const { return at<359>().valid(); } + ::protozero::ConstBytes rss_stat_throttled() const { return at<359>().as_bytes(); } + bool has_netif_receive_skb() const { return at<360>().valid(); } + ::protozero::ConstBytes netif_receive_skb() const { return at<360>().as_bytes(); } + bool has_net_dev_xmit() const { return at<361>().valid(); } + ::protozero::ConstBytes net_dev_xmit() const { return at<361>().as_bytes(); } + bool has_inet_sock_set_state() const { return at<362>().valid(); } + ::protozero::ConstBytes inet_sock_set_state() const { return at<362>().as_bytes(); } + bool has_tcp_retransmit_skb() const { return at<363>().valid(); } + ::protozero::ConstBytes tcp_retransmit_skb() const { return at<363>().as_bytes(); } + bool has_cros_ec_sensorhub_data() const { return at<364>().valid(); } + ::protozero::ConstBytes cros_ec_sensorhub_data() const { return at<364>().as_bytes(); } + bool has_napi_gro_receive_entry() const { return at<365>().valid(); } + ::protozero::ConstBytes napi_gro_receive_entry() const { return at<365>().as_bytes(); } + bool has_napi_gro_receive_exit() const { return at<366>().valid(); } + ::protozero::ConstBytes napi_gro_receive_exit() const { return at<366>().as_bytes(); } + bool has_kfree_skb() const { return at<367>().valid(); } + ::protozero::ConstBytes kfree_skb() const { return at<367>().as_bytes(); } + bool has_kvm_access_fault() const { return at<368>().valid(); } + ::protozero::ConstBytes kvm_access_fault() const { return at<368>().as_bytes(); } + bool has_kvm_ack_irq() const { return at<369>().valid(); } + ::protozero::ConstBytes kvm_ack_irq() const { return at<369>().as_bytes(); } + bool has_kvm_age_hva() const { return at<370>().valid(); } + ::protozero::ConstBytes kvm_age_hva() const { return at<370>().as_bytes(); } + bool has_kvm_age_page() const { return at<371>().valid(); } + ::protozero::ConstBytes kvm_age_page() const { return at<371>().as_bytes(); } + bool has_kvm_arm_clear_debug() const { return at<372>().valid(); } + ::protozero::ConstBytes kvm_arm_clear_debug() const { return at<372>().as_bytes(); } + bool has_kvm_arm_set_dreg32() const { return at<373>().valid(); } + ::protozero::ConstBytes kvm_arm_set_dreg32() const { return at<373>().as_bytes(); } + bool has_kvm_arm_set_regset() const { return at<374>().valid(); } + ::protozero::ConstBytes kvm_arm_set_regset() const { return at<374>().as_bytes(); } + bool has_kvm_arm_setup_debug() const { return at<375>().valid(); } + ::protozero::ConstBytes kvm_arm_setup_debug() const { return at<375>().as_bytes(); } + bool has_kvm_entry() const { return at<376>().valid(); } + ::protozero::ConstBytes kvm_entry() const { return at<376>().as_bytes(); } + bool has_kvm_exit() const { return at<377>().valid(); } + ::protozero::ConstBytes kvm_exit() const { return at<377>().as_bytes(); } + bool has_kvm_fpu() const { return at<378>().valid(); } + ::protozero::ConstBytes kvm_fpu() const { return at<378>().as_bytes(); } + bool has_kvm_get_timer_map() const { return at<379>().valid(); } + ::protozero::ConstBytes kvm_get_timer_map() const { return at<379>().as_bytes(); } + bool has_kvm_guest_fault() const { return at<380>().valid(); } + ::protozero::ConstBytes kvm_guest_fault() const { return at<380>().as_bytes(); } + bool has_kvm_handle_sys_reg() const { return at<381>().valid(); } + ::protozero::ConstBytes kvm_handle_sys_reg() const { return at<381>().as_bytes(); } + bool has_kvm_hvc_arm64() const { return at<382>().valid(); } + ::protozero::ConstBytes kvm_hvc_arm64() const { return at<382>().as_bytes(); } + bool has_kvm_irq_line() const { return at<383>().valid(); } + ::protozero::ConstBytes kvm_irq_line() const { return at<383>().as_bytes(); } + bool has_kvm_mmio() const { return at<384>().valid(); } + ::protozero::ConstBytes kvm_mmio() const { return at<384>().as_bytes(); } + bool has_kvm_mmio_emulate() const { return at<385>().valid(); } + ::protozero::ConstBytes kvm_mmio_emulate() const { return at<385>().as_bytes(); } + bool has_kvm_set_guest_debug() const { return at<386>().valid(); } + ::protozero::ConstBytes kvm_set_guest_debug() const { return at<386>().as_bytes(); } + bool has_kvm_set_irq() const { return at<387>().valid(); } + ::protozero::ConstBytes kvm_set_irq() const { return at<387>().as_bytes(); } + bool has_kvm_set_spte_hva() const { return at<388>().valid(); } + ::protozero::ConstBytes kvm_set_spte_hva() const { return at<388>().as_bytes(); } + bool has_kvm_set_way_flush() const { return at<389>().valid(); } + ::protozero::ConstBytes kvm_set_way_flush() const { return at<389>().as_bytes(); } + bool has_kvm_sys_access() const { return at<390>().valid(); } + ::protozero::ConstBytes kvm_sys_access() const { return at<390>().as_bytes(); } + bool has_kvm_test_age_hva() const { return at<391>().valid(); } + ::protozero::ConstBytes kvm_test_age_hva() const { return at<391>().as_bytes(); } + bool has_kvm_timer_emulate() const { return at<392>().valid(); } + ::protozero::ConstBytes kvm_timer_emulate() const { return at<392>().as_bytes(); } + bool has_kvm_timer_hrtimer_expire() const { return at<393>().valid(); } + ::protozero::ConstBytes kvm_timer_hrtimer_expire() const { return at<393>().as_bytes(); } + bool has_kvm_timer_restore_state() const { return at<394>().valid(); } + ::protozero::ConstBytes kvm_timer_restore_state() const { return at<394>().as_bytes(); } + bool has_kvm_timer_save_state() const { return at<395>().valid(); } + ::protozero::ConstBytes kvm_timer_save_state() const { return at<395>().as_bytes(); } + bool has_kvm_timer_update_irq() const { return at<396>().valid(); } + ::protozero::ConstBytes kvm_timer_update_irq() const { return at<396>().as_bytes(); } + bool has_kvm_toggle_cache() const { return at<397>().valid(); } + ::protozero::ConstBytes kvm_toggle_cache() const { return at<397>().as_bytes(); } + bool has_kvm_unmap_hva_range() const { return at<398>().valid(); } + ::protozero::ConstBytes kvm_unmap_hva_range() const { return at<398>().as_bytes(); } + bool has_kvm_userspace_exit() const { return at<399>().valid(); } + ::protozero::ConstBytes kvm_userspace_exit() const { return at<399>().as_bytes(); } + bool has_kvm_vcpu_wakeup() const { return at<400>().valid(); } + ::protozero::ConstBytes kvm_vcpu_wakeup() const { return at<400>().as_bytes(); } + bool has_kvm_wfx_arm64() const { return at<401>().valid(); } + ::protozero::ConstBytes kvm_wfx_arm64() const { return at<401>().as_bytes(); } + bool has_trap_reg() const { return at<402>().valid(); } + ::protozero::ConstBytes trap_reg() const { return at<402>().as_bytes(); } + bool has_vgic_update_irq_pending() const { return at<403>().valid(); } + ::protozero::ConstBytes vgic_update_irq_pending() const { return at<403>().as_bytes(); } + bool has_wakeup_source_activate() const { return at<404>().valid(); } + ::protozero::ConstBytes wakeup_source_activate() const { return at<404>().as_bytes(); } + bool has_wakeup_source_deactivate() const { return at<405>().valid(); } + ::protozero::ConstBytes wakeup_source_deactivate() const { return at<405>().as_bytes(); } + bool has_ufshcd_command() const { return at<406>().valid(); } + ::protozero::ConstBytes ufshcd_command() const { return at<406>().as_bytes(); } + bool has_ufshcd_clk_gating() const { return at<407>().valid(); } + ::protozero::ConstBytes ufshcd_clk_gating() const { return at<407>().as_bytes(); } + bool has_console() const { return at<408>().valid(); } + ::protozero::ConstBytes console() const { return at<408>().as_bytes(); } + bool has_drm_vblank_event() const { return at<409>().valid(); } + ::protozero::ConstBytes drm_vblank_event() const { return at<409>().as_bytes(); } + bool has_drm_vblank_event_delivered() const { return at<410>().valid(); } + ::protozero::ConstBytes drm_vblank_event_delivered() const { return at<410>().as_bytes(); } + bool has_drm_sched_job() const { return at<411>().valid(); } + ::protozero::ConstBytes drm_sched_job() const { return at<411>().as_bytes(); } + bool has_drm_run_job() const { return at<412>().valid(); } + ::protozero::ConstBytes drm_run_job() const { return at<412>().as_bytes(); } + bool has_drm_sched_process_job() const { return at<413>().valid(); } + ::protozero::ConstBytes drm_sched_process_job() const { return at<413>().as_bytes(); } + bool has_dma_fence_init() const { return at<414>().valid(); } + ::protozero::ConstBytes dma_fence_init() const { return at<414>().as_bytes(); } + bool has_dma_fence_emit() const { return at<415>().valid(); } + ::protozero::ConstBytes dma_fence_emit() const { return at<415>().as_bytes(); } + bool has_dma_fence_signaled() const { return at<416>().valid(); } + ::protozero::ConstBytes dma_fence_signaled() const { return at<416>().as_bytes(); } + bool has_dma_fence_wait_start() const { return at<417>().valid(); } + ::protozero::ConstBytes dma_fence_wait_start() const { return at<417>().as_bytes(); } + bool has_dma_fence_wait_end() const { return at<418>().valid(); } + ::protozero::ConstBytes dma_fence_wait_end() const { return at<418>().as_bytes(); } + bool has_f2fs_iostat() const { return at<419>().valid(); } + ::protozero::ConstBytes f2fs_iostat() const { return at<419>().as_bytes(); } + bool has_f2fs_iostat_latency() const { return at<420>().valid(); } + ::protozero::ConstBytes f2fs_iostat_latency() const { return at<420>().as_bytes(); } + bool has_sched_cpu_util_cfs() const { return at<421>().valid(); } + ::protozero::ConstBytes sched_cpu_util_cfs() const { return at<421>().as_bytes(); } + bool has_v4l2_qbuf() const { return at<422>().valid(); } + ::protozero::ConstBytes v4l2_qbuf() const { return at<422>().as_bytes(); } + bool has_v4l2_dqbuf() const { return at<423>().valid(); } + ::protozero::ConstBytes v4l2_dqbuf() const { return at<423>().as_bytes(); } + bool has_vb2_v4l2_buf_queue() const { return at<424>().valid(); } + ::protozero::ConstBytes vb2_v4l2_buf_queue() const { return at<424>().as_bytes(); } + bool has_vb2_v4l2_buf_done() const { return at<425>().valid(); } + ::protozero::ConstBytes vb2_v4l2_buf_done() const { return at<425>().as_bytes(); } + bool has_vb2_v4l2_qbuf() const { return at<426>().valid(); } + ::protozero::ConstBytes vb2_v4l2_qbuf() const { return at<426>().as_bytes(); } + bool has_vb2_v4l2_dqbuf() const { return at<427>().valid(); } + ::protozero::ConstBytes vb2_v4l2_dqbuf() const { return at<427>().as_bytes(); } + bool has_dsi_cmd_fifo_status() const { return at<428>().valid(); } + ::protozero::ConstBytes dsi_cmd_fifo_status() const { return at<428>().as_bytes(); } + bool has_dsi_rx() const { return at<429>().valid(); } + ::protozero::ConstBytes dsi_rx() const { return at<429>().as_bytes(); } + bool has_dsi_tx() const { return at<430>().valid(); } + ::protozero::ConstBytes dsi_tx() const { return at<430>().as_bytes(); } + bool has_android_fs_dataread_end() const { return at<431>().valid(); } + ::protozero::ConstBytes android_fs_dataread_end() const { return at<431>().as_bytes(); } + bool has_android_fs_dataread_start() const { return at<432>().valid(); } + ::protozero::ConstBytes android_fs_dataread_start() const { return at<432>().as_bytes(); } + bool has_android_fs_datawrite_end() const { return at<433>().valid(); } + ::protozero::ConstBytes android_fs_datawrite_end() const { return at<433>().as_bytes(); } + bool has_android_fs_datawrite_start() const { return at<434>().valid(); } + ::protozero::ConstBytes android_fs_datawrite_start() const { return at<434>().as_bytes(); } + bool has_android_fs_fsync_end() const { return at<435>().valid(); } + ::protozero::ConstBytes android_fs_fsync_end() const { return at<435>().as_bytes(); } + bool has_android_fs_fsync_start() const { return at<436>().valid(); } + ::protozero::ConstBytes android_fs_fsync_start() const { return at<436>().as_bytes(); } + bool has_funcgraph_entry() const { return at<437>().valid(); } + ::protozero::ConstBytes funcgraph_entry() const { return at<437>().as_bytes(); } + bool has_funcgraph_exit() const { return at<438>().valid(); } + ::protozero::ConstBytes funcgraph_exit() const { return at<438>().as_bytes(); } + bool has_virtio_video_cmd() const { return at<439>().valid(); } + ::protozero::ConstBytes virtio_video_cmd() const { return at<439>().as_bytes(); } + bool has_virtio_video_cmd_done() const { return at<440>().valid(); } + ::protozero::ConstBytes virtio_video_cmd_done() const { return at<440>().as_bytes(); } + bool has_virtio_video_resource_queue() const { return at<441>().valid(); } + ::protozero::ConstBytes virtio_video_resource_queue() const { return at<441>().as_bytes(); } + bool has_virtio_video_resource_queue_done() const { return at<442>().valid(); } + ::protozero::ConstBytes virtio_video_resource_queue_done() const { return at<442>().as_bytes(); } + bool has_mm_shrink_slab_start() const { return at<443>().valid(); } + ::protozero::ConstBytes mm_shrink_slab_start() const { return at<443>().as_bytes(); } + bool has_mm_shrink_slab_end() const { return at<444>().valid(); } + ::protozero::ConstBytes mm_shrink_slab_end() const { return at<444>().as_bytes(); } + bool has_trusty_smc() const { return at<445>().valid(); } + ::protozero::ConstBytes trusty_smc() const { return at<445>().as_bytes(); } + bool has_trusty_smc_done() const { return at<446>().valid(); } + ::protozero::ConstBytes trusty_smc_done() const { return at<446>().as_bytes(); } + bool has_trusty_std_call32() const { return at<447>().valid(); } + ::protozero::ConstBytes trusty_std_call32() const { return at<447>().as_bytes(); } + bool has_trusty_std_call32_done() const { return at<448>().valid(); } + ::protozero::ConstBytes trusty_std_call32_done() const { return at<448>().as_bytes(); } + bool has_trusty_share_memory() const { return at<449>().valid(); } + ::protozero::ConstBytes trusty_share_memory() const { return at<449>().as_bytes(); } + bool has_trusty_share_memory_done() const { return at<450>().valid(); } + ::protozero::ConstBytes trusty_share_memory_done() const { return at<450>().as_bytes(); } + bool has_trusty_reclaim_memory() const { return at<451>().valid(); } + ::protozero::ConstBytes trusty_reclaim_memory() const { return at<451>().as_bytes(); } + bool has_trusty_reclaim_memory_done() const { return at<452>().valid(); } + ::protozero::ConstBytes trusty_reclaim_memory_done() const { return at<452>().as_bytes(); } + bool has_trusty_irq() const { return at<453>().valid(); } + ::protozero::ConstBytes trusty_irq() const { return at<453>().as_bytes(); } + bool has_trusty_ipc_handle_event() const { return at<454>().valid(); } + ::protozero::ConstBytes trusty_ipc_handle_event() const { return at<454>().as_bytes(); } + bool has_trusty_ipc_connect() const { return at<455>().valid(); } + ::protozero::ConstBytes trusty_ipc_connect() const { return at<455>().as_bytes(); } + bool has_trusty_ipc_connect_end() const { return at<456>().valid(); } + ::protozero::ConstBytes trusty_ipc_connect_end() const { return at<456>().as_bytes(); } + bool has_trusty_ipc_write() const { return at<457>().valid(); } + ::protozero::ConstBytes trusty_ipc_write() const { return at<457>().as_bytes(); } + bool has_trusty_ipc_poll() const { return at<458>().valid(); } + ::protozero::ConstBytes trusty_ipc_poll() const { return at<458>().as_bytes(); } + bool has_trusty_ipc_read() const { return at<460>().valid(); } + ::protozero::ConstBytes trusty_ipc_read() const { return at<460>().as_bytes(); } + bool has_trusty_ipc_read_end() const { return at<461>().valid(); } + ::protozero::ConstBytes trusty_ipc_read_end() const { return at<461>().as_bytes(); } + bool has_trusty_ipc_rx() const { return at<462>().valid(); } + ::protozero::ConstBytes trusty_ipc_rx() const { return at<462>().as_bytes(); } + bool has_trusty_enqueue_nop() const { return at<464>().valid(); } + ::protozero::ConstBytes trusty_enqueue_nop() const { return at<464>().as_bytes(); } + bool has_cma_alloc_start() const { return at<465>().valid(); } + ::protozero::ConstBytes cma_alloc_start() const { return at<465>().as_bytes(); } + bool has_cma_alloc_info() const { return at<466>().valid(); } + ::protozero::ConstBytes cma_alloc_info() const { return at<466>().as_bytes(); } + bool has_lwis_tracing_mark_write() const { return at<467>().valid(); } + ::protozero::ConstBytes lwis_tracing_mark_write() const { return at<467>().as_bytes(); } + bool has_virtio_gpu_cmd_queue() const { return at<468>().valid(); } + ::protozero::ConstBytes virtio_gpu_cmd_queue() const { return at<468>().as_bytes(); } + bool has_virtio_gpu_cmd_response() const { return at<469>().valid(); } + ::protozero::ConstBytes virtio_gpu_cmd_response() const { return at<469>().as_bytes(); } + bool has_mali_mali_kcpu_cqs_set() const { return at<470>().valid(); } + ::protozero::ConstBytes mali_mali_kcpu_cqs_set() const { return at<470>().as_bytes(); } + bool has_mali_mali_kcpu_cqs_wait_start() const { return at<471>().valid(); } + ::protozero::ConstBytes mali_mali_kcpu_cqs_wait_start() const { return at<471>().as_bytes(); } + bool has_mali_mali_kcpu_cqs_wait_end() const { return at<472>().valid(); } + ::protozero::ConstBytes mali_mali_kcpu_cqs_wait_end() const { return at<472>().as_bytes(); } + bool has_mali_mali_kcpu_fence_signal() const { return at<473>().valid(); } + ::protozero::ConstBytes mali_mali_kcpu_fence_signal() const { return at<473>().as_bytes(); } + bool has_mali_mali_kcpu_fence_wait_start() const { return at<474>().valid(); } + ::protozero::ConstBytes mali_mali_kcpu_fence_wait_start() const { return at<474>().as_bytes(); } + bool has_mali_mali_kcpu_fence_wait_end() const { return at<475>().valid(); } + ::protozero::ConstBytes mali_mali_kcpu_fence_wait_end() const { return at<475>().as_bytes(); } + bool has_hyp_enter() const { return at<476>().valid(); } + ::protozero::ConstBytes hyp_enter() const { return at<476>().as_bytes(); } + bool has_hyp_exit() const { return at<477>().valid(); } + ::protozero::ConstBytes hyp_exit() const { return at<477>().as_bytes(); } + bool has_host_hcall() const { return at<478>().valid(); } + ::protozero::ConstBytes host_hcall() const { return at<478>().as_bytes(); } + bool has_host_smc() const { return at<479>().valid(); } + ::protozero::ConstBytes host_smc() const { return at<479>().as_bytes(); } + bool has_host_mem_abort() const { return at<480>().valid(); } + ::protozero::ConstBytes host_mem_abort() const { return at<480>().as_bytes(); } + bool has_suspend_resume_minimal() const { return at<481>().valid(); } + ::protozero::ConstBytes suspend_resume_minimal() const { return at<481>().as_bytes(); } + bool has_mali_mali_csf_interrupt_start() const { return at<482>().valid(); } + ::protozero::ConstBytes mali_mali_csf_interrupt_start() const { return at<482>().as_bytes(); } + bool has_mali_mali_csf_interrupt_end() const { return at<483>().valid(); } + ::protozero::ConstBytes mali_mali_csf_interrupt_end() const { return at<483>().as_bytes(); } + bool has_samsung_tracing_mark_write() const { return at<484>().valid(); } + ::protozero::ConstBytes samsung_tracing_mark_write() const { return at<484>().as_bytes(); } + bool has_binder_command() const { return at<485>().valid(); } + ::protozero::ConstBytes binder_command() const { return at<485>().as_bytes(); } + bool has_binder_return() const { return at<486>().valid(); } + ::protozero::ConstBytes binder_return() const { return at<486>().as_bytes(); } + bool has_sched_switch_with_ctrs() const { return at<487>().valid(); } + ::protozero::ConstBytes sched_switch_with_ctrs() const { return at<487>().as_bytes(); } + bool has_gpu_work_period() const { return at<488>().valid(); } + ::protozero::ConstBytes gpu_work_period() const { return at<488>().as_bytes(); } + bool has_rpm_status() const { return at<489>().valid(); } + ::protozero::ConstBytes rpm_status() const { return at<489>().as_bytes(); } + bool has_panel_write_generic() const { return at<490>().valid(); } + ::protozero::ConstBytes panel_write_generic() const { return at<490>().as_bytes(); } + bool has_sched_migrate_task() const { return at<491>().valid(); } + ::protozero::ConstBytes sched_migrate_task() const { return at<491>().as_bytes(); } + bool has_dpu_dsi_cmd_fifo_status() const { return at<492>().valid(); } + ::protozero::ConstBytes dpu_dsi_cmd_fifo_status() const { return at<492>().as_bytes(); } + bool has_dpu_dsi_rx() const { return at<493>().valid(); } + ::protozero::ConstBytes dpu_dsi_rx() const { return at<493>().as_bytes(); } + bool has_dpu_dsi_tx() const { return at<494>().valid(); } + ::protozero::ConstBytes dpu_dsi_tx() const { return at<494>().as_bytes(); } + bool has_f2fs_background_gc() const { return at<495>().valid(); } + ::protozero::ConstBytes f2fs_background_gc() const { return at<495>().as_bytes(); } + bool has_f2fs_gc_begin() const { return at<496>().valid(); } + ::protozero::ConstBytes f2fs_gc_begin() const { return at<496>().as_bytes(); } + bool has_f2fs_gc_end() const { return at<497>().valid(); } + ::protozero::ConstBytes f2fs_gc_end() const { return at<497>().as_bytes(); } + bool has_fastrpc_dma_free() const { return at<498>().valid(); } + ::protozero::ConstBytes fastrpc_dma_free() const { return at<498>().as_bytes(); } + bool has_fastrpc_dma_alloc() const { return at<499>().valid(); } + ::protozero::ConstBytes fastrpc_dma_alloc() const { return at<499>().as_bytes(); } + bool has_fastrpc_dma_unmap() const { return at<500>().valid(); } + ::protozero::ConstBytes fastrpc_dma_unmap() const { return at<500>().as_bytes(); } + bool has_fastrpc_dma_map() const { return at<501>().valid(); } + ::protozero::ConstBytes fastrpc_dma_map() const { return at<501>().as_bytes(); } +}; + +class FtraceEvent : public ::protozero::Message { + public: + using Decoder = FtraceEvent_Decoder; + enum : int32_t { + kTimestampFieldNumber = 1, + kPidFieldNumber = 2, + kCommonFlagsFieldNumber = 5, + kPrintFieldNumber = 3, + kSchedSwitchFieldNumber = 4, + kCpuFrequencyFieldNumber = 11, + kCpuFrequencyLimitsFieldNumber = 12, + kCpuIdleFieldNumber = 13, + kClockEnableFieldNumber = 14, + kClockDisableFieldNumber = 15, + kClockSetRateFieldNumber = 16, + kSchedWakeupFieldNumber = 17, + kSchedBlockedReasonFieldNumber = 18, + kSchedCpuHotplugFieldNumber = 19, + kSchedWakingFieldNumber = 20, + kIpiEntryFieldNumber = 21, + kIpiExitFieldNumber = 22, + kIpiRaiseFieldNumber = 23, + kSoftirqEntryFieldNumber = 24, + kSoftirqExitFieldNumber = 25, + kSoftirqRaiseFieldNumber = 26, + kI2cReadFieldNumber = 27, + kI2cWriteFieldNumber = 28, + kI2cResultFieldNumber = 29, + kI2cReplyFieldNumber = 30, + kSmbusReadFieldNumber = 31, + kSmbusWriteFieldNumber = 32, + kSmbusResultFieldNumber = 33, + kSmbusReplyFieldNumber = 34, + kLowmemoryKillFieldNumber = 35, + kIrqHandlerEntryFieldNumber = 36, + kIrqHandlerExitFieldNumber = 37, + kSyncPtFieldNumber = 38, + kSyncTimelineFieldNumber = 39, + kSyncWaitFieldNumber = 40, + kExt4DaWriteBeginFieldNumber = 41, + kExt4DaWriteEndFieldNumber = 42, + kExt4SyncFileEnterFieldNumber = 43, + kExt4SyncFileExitFieldNumber = 44, + kBlockRqIssueFieldNumber = 45, + kMmVmscanDirectReclaimBeginFieldNumber = 46, + kMmVmscanDirectReclaimEndFieldNumber = 47, + kMmVmscanKswapdWakeFieldNumber = 48, + kMmVmscanKswapdSleepFieldNumber = 49, + kBinderTransactionFieldNumber = 50, + kBinderTransactionReceivedFieldNumber = 51, + kBinderSetPriorityFieldNumber = 52, + kBinderLockFieldNumber = 53, + kBinderLockedFieldNumber = 54, + kBinderUnlockFieldNumber = 55, + kWorkqueueActivateWorkFieldNumber = 56, + kWorkqueueExecuteEndFieldNumber = 57, + kWorkqueueExecuteStartFieldNumber = 58, + kWorkqueueQueueWorkFieldNumber = 59, + kRegulatorDisableFieldNumber = 60, + kRegulatorDisableCompleteFieldNumber = 61, + kRegulatorEnableFieldNumber = 62, + kRegulatorEnableCompleteFieldNumber = 63, + kRegulatorEnableDelayFieldNumber = 64, + kRegulatorSetVoltageFieldNumber = 65, + kRegulatorSetVoltageCompleteFieldNumber = 66, + kCgroupAttachTaskFieldNumber = 67, + kCgroupMkdirFieldNumber = 68, + kCgroupRemountFieldNumber = 69, + kCgroupRmdirFieldNumber = 70, + kCgroupTransferTasksFieldNumber = 71, + kCgroupDestroyRootFieldNumber = 72, + kCgroupReleaseFieldNumber = 73, + kCgroupRenameFieldNumber = 74, + kCgroupSetupRootFieldNumber = 75, + kMdpCmdKickoffFieldNumber = 76, + kMdpCommitFieldNumber = 77, + kMdpPerfSetOtFieldNumber = 78, + kMdpSsppChangeFieldNumber = 79, + kTracingMarkWriteFieldNumber = 80, + kMdpCmdPingpongDoneFieldNumber = 81, + kMdpCompareBwFieldNumber = 82, + kMdpPerfSetPanicLutsFieldNumber = 83, + kMdpSsppSetFieldNumber = 84, + kMdpCmdReadptrDoneFieldNumber = 85, + kMdpMisrCrcFieldNumber = 86, + kMdpPerfSetQosLutsFieldNumber = 87, + kMdpTraceCounterFieldNumber = 88, + kMdpCmdReleaseBwFieldNumber = 89, + kMdpMixerUpdateFieldNumber = 90, + kMdpPerfSetWmLevelsFieldNumber = 91, + kMdpVideoUnderrunDoneFieldNumber = 92, + kMdpCmdWaitPingpongFieldNumber = 93, + kMdpPerfPrefillCalcFieldNumber = 94, + kMdpPerfUpdateBusFieldNumber = 95, + kRotatorBwAoAsContextFieldNumber = 96, + kMmFilemapAddToPageCacheFieldNumber = 97, + kMmFilemapDeleteFromPageCacheFieldNumber = 98, + kMmCompactionBeginFieldNumber = 99, + kMmCompactionDeferCompactionFieldNumber = 100, + kMmCompactionDeferredFieldNumber = 101, + kMmCompactionDeferResetFieldNumber = 102, + kMmCompactionEndFieldNumber = 103, + kMmCompactionFinishedFieldNumber = 104, + kMmCompactionIsolateFreepagesFieldNumber = 105, + kMmCompactionIsolateMigratepagesFieldNumber = 106, + kMmCompactionKcompactdSleepFieldNumber = 107, + kMmCompactionKcompactdWakeFieldNumber = 108, + kMmCompactionMigratepagesFieldNumber = 109, + kMmCompactionSuitableFieldNumber = 110, + kMmCompactionTryToCompactPagesFieldNumber = 111, + kMmCompactionWakeupKcompactdFieldNumber = 112, + kSuspendResumeFieldNumber = 113, + kSchedWakeupNewFieldNumber = 114, + kBlockBioBackmergeFieldNumber = 115, + kBlockBioBounceFieldNumber = 116, + kBlockBioCompleteFieldNumber = 117, + kBlockBioFrontmergeFieldNumber = 118, + kBlockBioQueueFieldNumber = 119, + kBlockBioRemapFieldNumber = 120, + kBlockDirtyBufferFieldNumber = 121, + kBlockGetrqFieldNumber = 122, + kBlockPlugFieldNumber = 123, + kBlockRqAbortFieldNumber = 124, + kBlockRqCompleteFieldNumber = 125, + kBlockRqInsertFieldNumber = 126, + kBlockRqRemapFieldNumber = 128, + kBlockRqRequeueFieldNumber = 129, + kBlockSleeprqFieldNumber = 130, + kBlockSplitFieldNumber = 131, + kBlockTouchBufferFieldNumber = 132, + kBlockUnplugFieldNumber = 133, + kExt4AllocDaBlocksFieldNumber = 134, + kExt4AllocateBlocksFieldNumber = 135, + kExt4AllocateInodeFieldNumber = 136, + kExt4BeginOrderedTruncateFieldNumber = 137, + kExt4CollapseRangeFieldNumber = 138, + kExt4DaReleaseSpaceFieldNumber = 139, + kExt4DaReserveSpaceFieldNumber = 140, + kExt4DaUpdateReserveSpaceFieldNumber = 141, + kExt4DaWritePagesFieldNumber = 142, + kExt4DaWritePagesExtentFieldNumber = 143, + kExt4DirectIOEnterFieldNumber = 144, + kExt4DirectIOExitFieldNumber = 145, + kExt4DiscardBlocksFieldNumber = 146, + kExt4DiscardPreallocationsFieldNumber = 147, + kExt4DropInodeFieldNumber = 148, + kExt4EsCacheExtentFieldNumber = 149, + kExt4EsFindDelayedExtentRangeEnterFieldNumber = 150, + kExt4EsFindDelayedExtentRangeExitFieldNumber = 151, + kExt4EsInsertExtentFieldNumber = 152, + kExt4EsLookupExtentEnterFieldNumber = 153, + kExt4EsLookupExtentExitFieldNumber = 154, + kExt4EsRemoveExtentFieldNumber = 155, + kExt4EsShrinkFieldNumber = 156, + kExt4EsShrinkCountFieldNumber = 157, + kExt4EsShrinkScanEnterFieldNumber = 158, + kExt4EsShrinkScanExitFieldNumber = 159, + kExt4EvictInodeFieldNumber = 160, + kExt4ExtConvertToInitializedEnterFieldNumber = 161, + kExt4ExtConvertToInitializedFastpathFieldNumber = 162, + kExt4ExtHandleUnwrittenExtentsFieldNumber = 163, + kExt4ExtInCacheFieldNumber = 164, + kExt4ExtLoadExtentFieldNumber = 165, + kExt4ExtMapBlocksEnterFieldNumber = 166, + kExt4ExtMapBlocksExitFieldNumber = 167, + kExt4ExtPutInCacheFieldNumber = 168, + kExt4ExtRemoveSpaceFieldNumber = 169, + kExt4ExtRemoveSpaceDoneFieldNumber = 170, + kExt4ExtRmIdxFieldNumber = 171, + kExt4ExtRmLeafFieldNumber = 172, + kExt4ExtShowExtentFieldNumber = 173, + kExt4FallocateEnterFieldNumber = 174, + kExt4FallocateExitFieldNumber = 175, + kExt4FindDelallocRangeFieldNumber = 176, + kExt4ForgetFieldNumber = 177, + kExt4FreeBlocksFieldNumber = 178, + kExt4FreeInodeFieldNumber = 179, + kExt4GetImpliedClusterAllocExitFieldNumber = 180, + kExt4GetReservedClusterAllocFieldNumber = 181, + kExt4IndMapBlocksEnterFieldNumber = 182, + kExt4IndMapBlocksExitFieldNumber = 183, + kExt4InsertRangeFieldNumber = 184, + kExt4InvalidatepageFieldNumber = 185, + kExt4JournalStartFieldNumber = 186, + kExt4JournalStartReservedFieldNumber = 187, + kExt4JournalledInvalidatepageFieldNumber = 188, + kExt4JournalledWriteEndFieldNumber = 189, + kExt4LoadInodeFieldNumber = 190, + kExt4LoadInodeBitmapFieldNumber = 191, + kExt4MarkInodeDirtyFieldNumber = 192, + kExt4MbBitmapLoadFieldNumber = 193, + kExt4MbBuddyBitmapLoadFieldNumber = 194, + kExt4MbDiscardPreallocationsFieldNumber = 195, + kExt4MbNewGroupPaFieldNumber = 196, + kExt4MbNewInodePaFieldNumber = 197, + kExt4MbReleaseGroupPaFieldNumber = 198, + kExt4MbReleaseInodePaFieldNumber = 199, + kExt4MballocAllocFieldNumber = 200, + kExt4MballocDiscardFieldNumber = 201, + kExt4MballocFreeFieldNumber = 202, + kExt4MballocPreallocFieldNumber = 203, + kExt4OtherInodeUpdateTimeFieldNumber = 204, + kExt4PunchHoleFieldNumber = 205, + kExt4ReadBlockBitmapLoadFieldNumber = 206, + kExt4ReadpageFieldNumber = 207, + kExt4ReleasepageFieldNumber = 208, + kExt4RemoveBlocksFieldNumber = 209, + kExt4RequestBlocksFieldNumber = 210, + kExt4RequestInodeFieldNumber = 211, + kExt4SyncFsFieldNumber = 212, + kExt4TrimAllFreeFieldNumber = 213, + kExt4TrimExtentFieldNumber = 214, + kExt4TruncateEnterFieldNumber = 215, + kExt4TruncateExitFieldNumber = 216, + kExt4UnlinkEnterFieldNumber = 217, + kExt4UnlinkExitFieldNumber = 218, + kExt4WriteBeginFieldNumber = 219, + kExt4WriteEndFieldNumber = 230, + kExt4WritepageFieldNumber = 231, + kExt4WritepagesFieldNumber = 232, + kExt4WritepagesResultFieldNumber = 233, + kExt4ZeroRangeFieldNumber = 234, + kTaskNewtaskFieldNumber = 235, + kTaskRenameFieldNumber = 236, + kSchedProcessExecFieldNumber = 237, + kSchedProcessExitFieldNumber = 238, + kSchedProcessForkFieldNumber = 239, + kSchedProcessFreeFieldNumber = 240, + kSchedProcessHangFieldNumber = 241, + kSchedProcessWaitFieldNumber = 242, + kF2fsDoSubmitBioFieldNumber = 243, + kF2fsEvictInodeFieldNumber = 244, + kF2fsFallocateFieldNumber = 245, + kF2fsGetDataBlockFieldNumber = 246, + kF2fsGetVictimFieldNumber = 247, + kF2fsIgetFieldNumber = 248, + kF2fsIgetExitFieldNumber = 249, + kF2fsNewInodeFieldNumber = 250, + kF2fsReadpageFieldNumber = 251, + kF2fsReserveNewBlockFieldNumber = 252, + kF2fsSetPageDirtyFieldNumber = 253, + kF2fsSubmitWritePageFieldNumber = 254, + kF2fsSyncFileEnterFieldNumber = 255, + kF2fsSyncFileExitFieldNumber = 256, + kF2fsSyncFsFieldNumber = 257, + kF2fsTruncateFieldNumber = 258, + kF2fsTruncateBlocksEnterFieldNumber = 259, + kF2fsTruncateBlocksExitFieldNumber = 260, + kF2fsTruncateDataBlocksRangeFieldNumber = 261, + kF2fsTruncateInodeBlocksEnterFieldNumber = 262, + kF2fsTruncateInodeBlocksExitFieldNumber = 263, + kF2fsTruncateNodeFieldNumber = 264, + kF2fsTruncateNodesEnterFieldNumber = 265, + kF2fsTruncateNodesExitFieldNumber = 266, + kF2fsTruncatePartialNodesFieldNumber = 267, + kF2fsUnlinkEnterFieldNumber = 268, + kF2fsUnlinkExitFieldNumber = 269, + kF2fsVmPageMkwriteFieldNumber = 270, + kF2fsWriteBeginFieldNumber = 271, + kF2fsWriteCheckpointFieldNumber = 272, + kF2fsWriteEndFieldNumber = 273, + kAllocPagesIommuEndFieldNumber = 274, + kAllocPagesIommuFailFieldNumber = 275, + kAllocPagesIommuStartFieldNumber = 276, + kAllocPagesSysEndFieldNumber = 277, + kAllocPagesSysFailFieldNumber = 278, + kAllocPagesSysStartFieldNumber = 279, + kDmaAllocContiguousRetryFieldNumber = 280, + kIommuMapRangeFieldNumber = 281, + kIommuSecPtblMapRangeEndFieldNumber = 282, + kIommuSecPtblMapRangeStartFieldNumber = 283, + kIonAllocBufferEndFieldNumber = 284, + kIonAllocBufferFailFieldNumber = 285, + kIonAllocBufferFallbackFieldNumber = 286, + kIonAllocBufferStartFieldNumber = 287, + kIonCpAllocRetryFieldNumber = 288, + kIonCpSecureBufferEndFieldNumber = 289, + kIonCpSecureBufferStartFieldNumber = 290, + kIonPrefetchingFieldNumber = 291, + kIonSecureCmaAddToPoolEndFieldNumber = 292, + kIonSecureCmaAddToPoolStartFieldNumber = 293, + kIonSecureCmaAllocateEndFieldNumber = 294, + kIonSecureCmaAllocateStartFieldNumber = 295, + kIonSecureCmaShrinkPoolEndFieldNumber = 296, + kIonSecureCmaShrinkPoolStartFieldNumber = 297, + kKfreeFieldNumber = 298, + kKmallocFieldNumber = 299, + kKmallocNodeFieldNumber = 300, + kKmemCacheAllocFieldNumber = 301, + kKmemCacheAllocNodeFieldNumber = 302, + kKmemCacheFreeFieldNumber = 303, + kMigratePagesEndFieldNumber = 304, + kMigratePagesStartFieldNumber = 305, + kMigrateRetryFieldNumber = 306, + kMmPageAllocFieldNumber = 307, + kMmPageAllocExtfragFieldNumber = 308, + kMmPageAllocZoneLockedFieldNumber = 309, + kMmPageFreeFieldNumber = 310, + kMmPageFreeBatchedFieldNumber = 311, + kMmPagePcpuDrainFieldNumber = 312, + kRssStatFieldNumber = 313, + kIonHeapShrinkFieldNumber = 314, + kIonHeapGrowFieldNumber = 315, + kFenceInitFieldNumber = 316, + kFenceDestroyFieldNumber = 317, + kFenceEnableSignalFieldNumber = 318, + kFenceSignaledFieldNumber = 319, + kClkEnableFieldNumber = 320, + kClkDisableFieldNumber = 321, + kClkSetRateFieldNumber = 322, + kBinderTransactionAllocBufFieldNumber = 323, + kSignalDeliverFieldNumber = 324, + kSignalGenerateFieldNumber = 325, + kOomScoreAdjUpdateFieldNumber = 326, + kGenericFieldNumber = 327, + kMmEventRecordFieldNumber = 328, + kSysEnterFieldNumber = 329, + kSysExitFieldNumber = 330, + kZeroFieldNumber = 331, + kGpuFrequencyFieldNumber = 332, + kSdeTracingMarkWriteFieldNumber = 333, + kMarkVictimFieldNumber = 334, + kIonStatFieldNumber = 335, + kIonBufferCreateFieldNumber = 336, + kIonBufferDestroyFieldNumber = 337, + kScmCallStartFieldNumber = 338, + kScmCallEndFieldNumber = 339, + kGpuMemTotalFieldNumber = 340, + kThermalTemperatureFieldNumber = 341, + kCdevUpdateFieldNumber = 342, + kCpuhpExitFieldNumber = 343, + kCpuhpMultiEnterFieldNumber = 344, + kCpuhpEnterFieldNumber = 345, + kCpuhpLatencyFieldNumber = 346, + kFastrpcDmaStatFieldNumber = 347, + kDpuTracingMarkWriteFieldNumber = 348, + kG2dTracingMarkWriteFieldNumber = 349, + kMaliTracingMarkWriteFieldNumber = 350, + kDmaHeapStatFieldNumber = 351, + kCpuhpPauseFieldNumber = 352, + kSchedPiSetprioFieldNumber = 353, + kSdeSdeEvtlogFieldNumber = 354, + kSdeSdePerfCalcCrtcFieldNumber = 355, + kSdeSdePerfCrtcUpdateFieldNumber = 356, + kSdeSdePerfSetQosLutsFieldNumber = 357, + kSdeSdePerfUpdateBusFieldNumber = 358, + kRssStatThrottledFieldNumber = 359, + kNetifReceiveSkbFieldNumber = 360, + kNetDevXmitFieldNumber = 361, + kInetSockSetStateFieldNumber = 362, + kTcpRetransmitSkbFieldNumber = 363, + kCrosEcSensorhubDataFieldNumber = 364, + kNapiGroReceiveEntryFieldNumber = 365, + kNapiGroReceiveExitFieldNumber = 366, + kKfreeSkbFieldNumber = 367, + kKvmAccessFaultFieldNumber = 368, + kKvmAckIrqFieldNumber = 369, + kKvmAgeHvaFieldNumber = 370, + kKvmAgePageFieldNumber = 371, + kKvmArmClearDebugFieldNumber = 372, + kKvmArmSetDreg32FieldNumber = 373, + kKvmArmSetRegsetFieldNumber = 374, + kKvmArmSetupDebugFieldNumber = 375, + kKvmEntryFieldNumber = 376, + kKvmExitFieldNumber = 377, + kKvmFpuFieldNumber = 378, + kKvmGetTimerMapFieldNumber = 379, + kKvmGuestFaultFieldNumber = 380, + kKvmHandleSysRegFieldNumber = 381, + kKvmHvcArm64FieldNumber = 382, + kKvmIrqLineFieldNumber = 383, + kKvmMmioFieldNumber = 384, + kKvmMmioEmulateFieldNumber = 385, + kKvmSetGuestDebugFieldNumber = 386, + kKvmSetIrqFieldNumber = 387, + kKvmSetSpteHvaFieldNumber = 388, + kKvmSetWayFlushFieldNumber = 389, + kKvmSysAccessFieldNumber = 390, + kKvmTestAgeHvaFieldNumber = 391, + kKvmTimerEmulateFieldNumber = 392, + kKvmTimerHrtimerExpireFieldNumber = 393, + kKvmTimerRestoreStateFieldNumber = 394, + kKvmTimerSaveStateFieldNumber = 395, + kKvmTimerUpdateIrqFieldNumber = 396, + kKvmToggleCacheFieldNumber = 397, + kKvmUnmapHvaRangeFieldNumber = 398, + kKvmUserspaceExitFieldNumber = 399, + kKvmVcpuWakeupFieldNumber = 400, + kKvmWfxArm64FieldNumber = 401, + kTrapRegFieldNumber = 402, + kVgicUpdateIrqPendingFieldNumber = 403, + kWakeupSourceActivateFieldNumber = 404, + kWakeupSourceDeactivateFieldNumber = 405, + kUfshcdCommandFieldNumber = 406, + kUfshcdClkGatingFieldNumber = 407, + kConsoleFieldNumber = 408, + kDrmVblankEventFieldNumber = 409, + kDrmVblankEventDeliveredFieldNumber = 410, + kDrmSchedJobFieldNumber = 411, + kDrmRunJobFieldNumber = 412, + kDrmSchedProcessJobFieldNumber = 413, + kDmaFenceInitFieldNumber = 414, + kDmaFenceEmitFieldNumber = 415, + kDmaFenceSignaledFieldNumber = 416, + kDmaFenceWaitStartFieldNumber = 417, + kDmaFenceWaitEndFieldNumber = 418, + kF2fsIostatFieldNumber = 419, + kF2fsIostatLatencyFieldNumber = 420, + kSchedCpuUtilCfsFieldNumber = 421, + kV4l2QbufFieldNumber = 422, + kV4l2DqbufFieldNumber = 423, + kVb2V4l2BufQueueFieldNumber = 424, + kVb2V4l2BufDoneFieldNumber = 425, + kVb2V4l2QbufFieldNumber = 426, + kVb2V4l2DqbufFieldNumber = 427, + kDsiCmdFifoStatusFieldNumber = 428, + kDsiRxFieldNumber = 429, + kDsiTxFieldNumber = 430, + kAndroidFsDatareadEndFieldNumber = 431, + kAndroidFsDatareadStartFieldNumber = 432, + kAndroidFsDatawriteEndFieldNumber = 433, + kAndroidFsDatawriteStartFieldNumber = 434, + kAndroidFsFsyncEndFieldNumber = 435, + kAndroidFsFsyncStartFieldNumber = 436, + kFuncgraphEntryFieldNumber = 437, + kFuncgraphExitFieldNumber = 438, + kVirtioVideoCmdFieldNumber = 439, + kVirtioVideoCmdDoneFieldNumber = 440, + kVirtioVideoResourceQueueFieldNumber = 441, + kVirtioVideoResourceQueueDoneFieldNumber = 442, + kMmShrinkSlabStartFieldNumber = 443, + kMmShrinkSlabEndFieldNumber = 444, + kTrustySmcFieldNumber = 445, + kTrustySmcDoneFieldNumber = 446, + kTrustyStdCall32FieldNumber = 447, + kTrustyStdCall32DoneFieldNumber = 448, + kTrustyShareMemoryFieldNumber = 449, + kTrustyShareMemoryDoneFieldNumber = 450, + kTrustyReclaimMemoryFieldNumber = 451, + kTrustyReclaimMemoryDoneFieldNumber = 452, + kTrustyIrqFieldNumber = 453, + kTrustyIpcHandleEventFieldNumber = 454, + kTrustyIpcConnectFieldNumber = 455, + kTrustyIpcConnectEndFieldNumber = 456, + kTrustyIpcWriteFieldNumber = 457, + kTrustyIpcPollFieldNumber = 458, + kTrustyIpcReadFieldNumber = 460, + kTrustyIpcReadEndFieldNumber = 461, + kTrustyIpcRxFieldNumber = 462, + kTrustyEnqueueNopFieldNumber = 464, + kCmaAllocStartFieldNumber = 465, + kCmaAllocInfoFieldNumber = 466, + kLwisTracingMarkWriteFieldNumber = 467, + kVirtioGpuCmdQueueFieldNumber = 468, + kVirtioGpuCmdResponseFieldNumber = 469, + kMaliMaliKCPUCQSSETFieldNumber = 470, + kMaliMaliKCPUCQSWAITSTARTFieldNumber = 471, + kMaliMaliKCPUCQSWAITENDFieldNumber = 472, + kMaliMaliKCPUFENCESIGNALFieldNumber = 473, + kMaliMaliKCPUFENCEWAITSTARTFieldNumber = 474, + kMaliMaliKCPUFENCEWAITENDFieldNumber = 475, + kHypEnterFieldNumber = 476, + kHypExitFieldNumber = 477, + kHostHcallFieldNumber = 478, + kHostSmcFieldNumber = 479, + kHostMemAbortFieldNumber = 480, + kSuspendResumeMinimalFieldNumber = 481, + kMaliMaliCSFINTERRUPTSTARTFieldNumber = 482, + kMaliMaliCSFINTERRUPTENDFieldNumber = 483, + kSamsungTracingMarkWriteFieldNumber = 484, + kBinderCommandFieldNumber = 485, + kBinderReturnFieldNumber = 486, + kSchedSwitchWithCtrsFieldNumber = 487, + kGpuWorkPeriodFieldNumber = 488, + kRpmStatusFieldNumber = 489, + kPanelWriteGenericFieldNumber = 490, + kSchedMigrateTaskFieldNumber = 491, + kDpuDsiCmdFifoStatusFieldNumber = 492, + kDpuDsiRxFieldNumber = 493, + kDpuDsiTxFieldNumber = 494, + kF2fsBackgroundGcFieldNumber = 495, + kF2fsGcBeginFieldNumber = 496, + kF2fsGcEndFieldNumber = 497, + kFastrpcDmaFreeFieldNumber = 498, + kFastrpcDmaAllocFieldNumber = 499, + kFastrpcDmaUnmapFieldNumber = 500, + kFastrpcDmaMapFieldNumber = 501, + }; + static constexpr const char* GetName() { return ".perfetto.protos.FtraceEvent"; } + + + using FieldMetadata_Timestamp = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + FtraceEvent>; + + static constexpr FieldMetadata_Timestamp kTimestamp{}; + void set_timestamp(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Timestamp::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pid = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + FtraceEvent>; + + static constexpr FieldMetadata_Pid kPid{}; + void set_pid(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CommonFlags = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + FtraceEvent>; + + static constexpr FieldMetadata_CommonFlags kCommonFlags{}; + void set_common_flags(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_CommonFlags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Print = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + PrintFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Print kPrint{}; + template T* set_print() { + return BeginNestedMessage(3); + } + + + using FieldMetadata_SchedSwitch = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + SchedSwitchFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_SchedSwitch kSchedSwitch{}; + template T* set_sched_switch() { + return BeginNestedMessage(4); + } + + + using FieldMetadata_CpuFrequency = + ::protozero::proto_utils::FieldMetadata< + 11, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + CpuFrequencyFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_CpuFrequency kCpuFrequency{}; + template T* set_cpu_frequency() { + return BeginNestedMessage(11); + } + + + using FieldMetadata_CpuFrequencyLimits = + ::protozero::proto_utils::FieldMetadata< + 12, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + CpuFrequencyLimitsFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_CpuFrequencyLimits kCpuFrequencyLimits{}; + template T* set_cpu_frequency_limits() { + return BeginNestedMessage(12); + } + + + using FieldMetadata_CpuIdle = + ::protozero::proto_utils::FieldMetadata< + 13, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + CpuIdleFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_CpuIdle kCpuIdle{}; + template T* set_cpu_idle() { + return BeginNestedMessage(13); + } + + + using FieldMetadata_ClockEnable = + ::protozero::proto_utils::FieldMetadata< + 14, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ClockEnableFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_ClockEnable kClockEnable{}; + template T* set_clock_enable() { + return BeginNestedMessage(14); + } + + + using FieldMetadata_ClockDisable = + ::protozero::proto_utils::FieldMetadata< + 15, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ClockDisableFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_ClockDisable kClockDisable{}; + template T* set_clock_disable() { + return BeginNestedMessage(15); + } + + + using FieldMetadata_ClockSetRate = + ::protozero::proto_utils::FieldMetadata< + 16, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ClockSetRateFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_ClockSetRate kClockSetRate{}; + template T* set_clock_set_rate() { + return BeginNestedMessage(16); + } + + + using FieldMetadata_SchedWakeup = + ::protozero::proto_utils::FieldMetadata< + 17, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + SchedWakeupFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_SchedWakeup kSchedWakeup{}; + template T* set_sched_wakeup() { + return BeginNestedMessage(17); + } + + + using FieldMetadata_SchedBlockedReason = + ::protozero::proto_utils::FieldMetadata< + 18, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + SchedBlockedReasonFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_SchedBlockedReason kSchedBlockedReason{}; + template T* set_sched_blocked_reason() { + return BeginNestedMessage(18); + } + + + using FieldMetadata_SchedCpuHotplug = + ::protozero::proto_utils::FieldMetadata< + 19, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + SchedCpuHotplugFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_SchedCpuHotplug kSchedCpuHotplug{}; + template T* set_sched_cpu_hotplug() { + return BeginNestedMessage(19); + } + + + using FieldMetadata_SchedWaking = + ::protozero::proto_utils::FieldMetadata< + 20, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + SchedWakingFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_SchedWaking kSchedWaking{}; + template T* set_sched_waking() { + return BeginNestedMessage(20); + } + + + using FieldMetadata_IpiEntry = + ::protozero::proto_utils::FieldMetadata< + 21, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + IpiEntryFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_IpiEntry kIpiEntry{}; + template T* set_ipi_entry() { + return BeginNestedMessage(21); + } + + + using FieldMetadata_IpiExit = + ::protozero::proto_utils::FieldMetadata< + 22, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + IpiExitFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_IpiExit kIpiExit{}; + template T* set_ipi_exit() { + return BeginNestedMessage(22); + } + + + using FieldMetadata_IpiRaise = + ::protozero::proto_utils::FieldMetadata< + 23, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + IpiRaiseFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_IpiRaise kIpiRaise{}; + template T* set_ipi_raise() { + return BeginNestedMessage(23); + } + + + using FieldMetadata_SoftirqEntry = + ::protozero::proto_utils::FieldMetadata< + 24, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + SoftirqEntryFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_SoftirqEntry kSoftirqEntry{}; + template T* set_softirq_entry() { + return BeginNestedMessage(24); + } + + + using FieldMetadata_SoftirqExit = + ::protozero::proto_utils::FieldMetadata< + 25, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + SoftirqExitFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_SoftirqExit kSoftirqExit{}; + template T* set_softirq_exit() { + return BeginNestedMessage(25); + } + + + using FieldMetadata_SoftirqRaise = + ::protozero::proto_utils::FieldMetadata< + 26, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + SoftirqRaiseFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_SoftirqRaise kSoftirqRaise{}; + template T* set_softirq_raise() { + return BeginNestedMessage(26); + } + + + using FieldMetadata_I2cRead = + ::protozero::proto_utils::FieldMetadata< + 27, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + I2cReadFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_I2cRead kI2cRead{}; + template T* set_i2c_read() { + return BeginNestedMessage(27); + } + + + using FieldMetadata_I2cWrite = + ::protozero::proto_utils::FieldMetadata< + 28, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + I2cWriteFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_I2cWrite kI2cWrite{}; + template T* set_i2c_write() { + return BeginNestedMessage(28); + } + + + using FieldMetadata_I2cResult = + ::protozero::proto_utils::FieldMetadata< + 29, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + I2cResultFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_I2cResult kI2cResult{}; + template T* set_i2c_result() { + return BeginNestedMessage(29); + } + + + using FieldMetadata_I2cReply = + ::protozero::proto_utils::FieldMetadata< + 30, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + I2cReplyFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_I2cReply kI2cReply{}; + template T* set_i2c_reply() { + return BeginNestedMessage(30); + } + + + using FieldMetadata_SmbusRead = + ::protozero::proto_utils::FieldMetadata< + 31, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + SmbusReadFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_SmbusRead kSmbusRead{}; + template T* set_smbus_read() { + return BeginNestedMessage(31); + } + + + using FieldMetadata_SmbusWrite = + ::protozero::proto_utils::FieldMetadata< + 32, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + SmbusWriteFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_SmbusWrite kSmbusWrite{}; + template T* set_smbus_write() { + return BeginNestedMessage(32); + } + + + using FieldMetadata_SmbusResult = + ::protozero::proto_utils::FieldMetadata< + 33, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + SmbusResultFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_SmbusResult kSmbusResult{}; + template T* set_smbus_result() { + return BeginNestedMessage(33); + } + + + using FieldMetadata_SmbusReply = + ::protozero::proto_utils::FieldMetadata< + 34, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + SmbusReplyFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_SmbusReply kSmbusReply{}; + template T* set_smbus_reply() { + return BeginNestedMessage(34); + } + + + using FieldMetadata_LowmemoryKill = + ::protozero::proto_utils::FieldMetadata< + 35, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + LowmemoryKillFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_LowmemoryKill kLowmemoryKill{}; + template T* set_lowmemory_kill() { + return BeginNestedMessage(35); + } + + + using FieldMetadata_IrqHandlerEntry = + ::protozero::proto_utils::FieldMetadata< + 36, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + IrqHandlerEntryFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_IrqHandlerEntry kIrqHandlerEntry{}; + template T* set_irq_handler_entry() { + return BeginNestedMessage(36); + } + + + using FieldMetadata_IrqHandlerExit = + ::protozero::proto_utils::FieldMetadata< + 37, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + IrqHandlerExitFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_IrqHandlerExit kIrqHandlerExit{}; + template T* set_irq_handler_exit() { + return BeginNestedMessage(37); + } + + + using FieldMetadata_SyncPt = + ::protozero::proto_utils::FieldMetadata< + 38, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + SyncPtFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_SyncPt kSyncPt{}; + template T* set_sync_pt() { + return BeginNestedMessage(38); + } + + + using FieldMetadata_SyncTimeline = + ::protozero::proto_utils::FieldMetadata< + 39, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + SyncTimelineFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_SyncTimeline kSyncTimeline{}; + template T* set_sync_timeline() { + return BeginNestedMessage(39); + } + + + using FieldMetadata_SyncWait = + ::protozero::proto_utils::FieldMetadata< + 40, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + SyncWaitFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_SyncWait kSyncWait{}; + template T* set_sync_wait() { + return BeginNestedMessage(40); + } + + + using FieldMetadata_Ext4DaWriteBegin = + ::protozero::proto_utils::FieldMetadata< + 41, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4DaWriteBeginFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4DaWriteBegin kExt4DaWriteBegin{}; + template T* set_ext4_da_write_begin() { + return BeginNestedMessage(41); + } + + + using FieldMetadata_Ext4DaWriteEnd = + ::protozero::proto_utils::FieldMetadata< + 42, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4DaWriteEndFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4DaWriteEnd kExt4DaWriteEnd{}; + template T* set_ext4_da_write_end() { + return BeginNestedMessage(42); + } + + + using FieldMetadata_Ext4SyncFileEnter = + ::protozero::proto_utils::FieldMetadata< + 43, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4SyncFileEnterFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4SyncFileEnter kExt4SyncFileEnter{}; + template T* set_ext4_sync_file_enter() { + return BeginNestedMessage(43); + } + + + using FieldMetadata_Ext4SyncFileExit = + ::protozero::proto_utils::FieldMetadata< + 44, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4SyncFileExitFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4SyncFileExit kExt4SyncFileExit{}; + template T* set_ext4_sync_file_exit() { + return BeginNestedMessage(44); + } + + + using FieldMetadata_BlockRqIssue = + ::protozero::proto_utils::FieldMetadata< + 45, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + BlockRqIssueFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_BlockRqIssue kBlockRqIssue{}; + template T* set_block_rq_issue() { + return BeginNestedMessage(45); + } + + + using FieldMetadata_MmVmscanDirectReclaimBegin = + ::protozero::proto_utils::FieldMetadata< + 46, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MmVmscanDirectReclaimBeginFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_MmVmscanDirectReclaimBegin kMmVmscanDirectReclaimBegin{}; + template T* set_mm_vmscan_direct_reclaim_begin() { + return BeginNestedMessage(46); + } + + + using FieldMetadata_MmVmscanDirectReclaimEnd = + ::protozero::proto_utils::FieldMetadata< + 47, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MmVmscanDirectReclaimEndFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_MmVmscanDirectReclaimEnd kMmVmscanDirectReclaimEnd{}; + template T* set_mm_vmscan_direct_reclaim_end() { + return BeginNestedMessage(47); + } + + + using FieldMetadata_MmVmscanKswapdWake = + ::protozero::proto_utils::FieldMetadata< + 48, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MmVmscanKswapdWakeFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_MmVmscanKswapdWake kMmVmscanKswapdWake{}; + template T* set_mm_vmscan_kswapd_wake() { + return BeginNestedMessage(48); + } + + + using FieldMetadata_MmVmscanKswapdSleep = + ::protozero::proto_utils::FieldMetadata< + 49, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MmVmscanKswapdSleepFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_MmVmscanKswapdSleep kMmVmscanKswapdSleep{}; + template T* set_mm_vmscan_kswapd_sleep() { + return BeginNestedMessage(49); + } + + + using FieldMetadata_BinderTransaction = + ::protozero::proto_utils::FieldMetadata< + 50, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + BinderTransactionFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_BinderTransaction kBinderTransaction{}; + template T* set_binder_transaction() { + return BeginNestedMessage(50); + } + + + using FieldMetadata_BinderTransactionReceived = + ::protozero::proto_utils::FieldMetadata< + 51, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + BinderTransactionReceivedFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_BinderTransactionReceived kBinderTransactionReceived{}; + template T* set_binder_transaction_received() { + return BeginNestedMessage(51); + } + + + using FieldMetadata_BinderSetPriority = + ::protozero::proto_utils::FieldMetadata< + 52, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + BinderSetPriorityFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_BinderSetPriority kBinderSetPriority{}; + template T* set_binder_set_priority() { + return BeginNestedMessage(52); + } + + + using FieldMetadata_BinderLock = + ::protozero::proto_utils::FieldMetadata< + 53, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + BinderLockFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_BinderLock kBinderLock{}; + template T* set_binder_lock() { + return BeginNestedMessage(53); + } + + + using FieldMetadata_BinderLocked = + ::protozero::proto_utils::FieldMetadata< + 54, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + BinderLockedFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_BinderLocked kBinderLocked{}; + template T* set_binder_locked() { + return BeginNestedMessage(54); + } + + + using FieldMetadata_BinderUnlock = + ::protozero::proto_utils::FieldMetadata< + 55, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + BinderUnlockFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_BinderUnlock kBinderUnlock{}; + template T* set_binder_unlock() { + return BeginNestedMessage(55); + } + + + using FieldMetadata_WorkqueueActivateWork = + ::protozero::proto_utils::FieldMetadata< + 56, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + WorkqueueActivateWorkFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_WorkqueueActivateWork kWorkqueueActivateWork{}; + template T* set_workqueue_activate_work() { + return BeginNestedMessage(56); + } + + + using FieldMetadata_WorkqueueExecuteEnd = + ::protozero::proto_utils::FieldMetadata< + 57, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + WorkqueueExecuteEndFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_WorkqueueExecuteEnd kWorkqueueExecuteEnd{}; + template T* set_workqueue_execute_end() { + return BeginNestedMessage(57); + } + + + using FieldMetadata_WorkqueueExecuteStart = + ::protozero::proto_utils::FieldMetadata< + 58, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + WorkqueueExecuteStartFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_WorkqueueExecuteStart kWorkqueueExecuteStart{}; + template T* set_workqueue_execute_start() { + return BeginNestedMessage(58); + } + + + using FieldMetadata_WorkqueueQueueWork = + ::protozero::proto_utils::FieldMetadata< + 59, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + WorkqueueQueueWorkFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_WorkqueueQueueWork kWorkqueueQueueWork{}; + template T* set_workqueue_queue_work() { + return BeginNestedMessage(59); + } + + + using FieldMetadata_RegulatorDisable = + ::protozero::proto_utils::FieldMetadata< + 60, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + RegulatorDisableFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_RegulatorDisable kRegulatorDisable{}; + template T* set_regulator_disable() { + return BeginNestedMessage(60); + } + + + using FieldMetadata_RegulatorDisableComplete = + ::protozero::proto_utils::FieldMetadata< + 61, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + RegulatorDisableCompleteFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_RegulatorDisableComplete kRegulatorDisableComplete{}; + template T* set_regulator_disable_complete() { + return BeginNestedMessage(61); + } + + + using FieldMetadata_RegulatorEnable = + ::protozero::proto_utils::FieldMetadata< + 62, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + RegulatorEnableFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_RegulatorEnable kRegulatorEnable{}; + template T* set_regulator_enable() { + return BeginNestedMessage(62); + } + + + using FieldMetadata_RegulatorEnableComplete = + ::protozero::proto_utils::FieldMetadata< + 63, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + RegulatorEnableCompleteFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_RegulatorEnableComplete kRegulatorEnableComplete{}; + template T* set_regulator_enable_complete() { + return BeginNestedMessage(63); + } + + + using FieldMetadata_RegulatorEnableDelay = + ::protozero::proto_utils::FieldMetadata< + 64, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + RegulatorEnableDelayFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_RegulatorEnableDelay kRegulatorEnableDelay{}; + template T* set_regulator_enable_delay() { + return BeginNestedMessage(64); + } + + + using FieldMetadata_RegulatorSetVoltage = + ::protozero::proto_utils::FieldMetadata< + 65, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + RegulatorSetVoltageFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_RegulatorSetVoltage kRegulatorSetVoltage{}; + template T* set_regulator_set_voltage() { + return BeginNestedMessage(65); + } + + + using FieldMetadata_RegulatorSetVoltageComplete = + ::protozero::proto_utils::FieldMetadata< + 66, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + RegulatorSetVoltageCompleteFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_RegulatorSetVoltageComplete kRegulatorSetVoltageComplete{}; + template T* set_regulator_set_voltage_complete() { + return BeginNestedMessage(66); + } + + + using FieldMetadata_CgroupAttachTask = + ::protozero::proto_utils::FieldMetadata< + 67, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + CgroupAttachTaskFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_CgroupAttachTask kCgroupAttachTask{}; + template T* set_cgroup_attach_task() { + return BeginNestedMessage(67); + } + + + using FieldMetadata_CgroupMkdir = + ::protozero::proto_utils::FieldMetadata< + 68, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + CgroupMkdirFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_CgroupMkdir kCgroupMkdir{}; + template T* set_cgroup_mkdir() { + return BeginNestedMessage(68); + } + + + using FieldMetadata_CgroupRemount = + ::protozero::proto_utils::FieldMetadata< + 69, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + CgroupRemountFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_CgroupRemount kCgroupRemount{}; + template T* set_cgroup_remount() { + return BeginNestedMessage(69); + } + + + using FieldMetadata_CgroupRmdir = + ::protozero::proto_utils::FieldMetadata< + 70, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + CgroupRmdirFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_CgroupRmdir kCgroupRmdir{}; + template T* set_cgroup_rmdir() { + return BeginNestedMessage(70); + } + + + using FieldMetadata_CgroupTransferTasks = + ::protozero::proto_utils::FieldMetadata< + 71, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + CgroupTransferTasksFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_CgroupTransferTasks kCgroupTransferTasks{}; + template T* set_cgroup_transfer_tasks() { + return BeginNestedMessage(71); + } + + + using FieldMetadata_CgroupDestroyRoot = + ::protozero::proto_utils::FieldMetadata< + 72, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + CgroupDestroyRootFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_CgroupDestroyRoot kCgroupDestroyRoot{}; + template T* set_cgroup_destroy_root() { + return BeginNestedMessage(72); + } + + + using FieldMetadata_CgroupRelease = + ::protozero::proto_utils::FieldMetadata< + 73, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + CgroupReleaseFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_CgroupRelease kCgroupRelease{}; + template T* set_cgroup_release() { + return BeginNestedMessage(73); + } + + + using FieldMetadata_CgroupRename = + ::protozero::proto_utils::FieldMetadata< + 74, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + CgroupRenameFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_CgroupRename kCgroupRename{}; + template T* set_cgroup_rename() { + return BeginNestedMessage(74); + } + + + using FieldMetadata_CgroupSetupRoot = + ::protozero::proto_utils::FieldMetadata< + 75, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + CgroupSetupRootFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_CgroupSetupRoot kCgroupSetupRoot{}; + template T* set_cgroup_setup_root() { + return BeginNestedMessage(75); + } + + + using FieldMetadata_MdpCmdKickoff = + ::protozero::proto_utils::FieldMetadata< + 76, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MdpCmdKickoffFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_MdpCmdKickoff kMdpCmdKickoff{}; + template T* set_mdp_cmd_kickoff() { + return BeginNestedMessage(76); + } + + + using FieldMetadata_MdpCommit = + ::protozero::proto_utils::FieldMetadata< + 77, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MdpCommitFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_MdpCommit kMdpCommit{}; + template T* set_mdp_commit() { + return BeginNestedMessage(77); + } + + + using FieldMetadata_MdpPerfSetOt = + ::protozero::proto_utils::FieldMetadata< + 78, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MdpPerfSetOtFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_MdpPerfSetOt kMdpPerfSetOt{}; + template T* set_mdp_perf_set_ot() { + return BeginNestedMessage(78); + } + + + using FieldMetadata_MdpSsppChange = + ::protozero::proto_utils::FieldMetadata< + 79, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MdpSsppChangeFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_MdpSsppChange kMdpSsppChange{}; + template T* set_mdp_sspp_change() { + return BeginNestedMessage(79); + } + + + using FieldMetadata_TracingMarkWrite = + ::protozero::proto_utils::FieldMetadata< + 80, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TracingMarkWriteFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_TracingMarkWrite kTracingMarkWrite{}; + template T* set_tracing_mark_write() { + return BeginNestedMessage(80); + } + + + using FieldMetadata_MdpCmdPingpongDone = + ::protozero::proto_utils::FieldMetadata< + 81, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MdpCmdPingpongDoneFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_MdpCmdPingpongDone kMdpCmdPingpongDone{}; + template T* set_mdp_cmd_pingpong_done() { + return BeginNestedMessage(81); + } + + + using FieldMetadata_MdpCompareBw = + ::protozero::proto_utils::FieldMetadata< + 82, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MdpCompareBwFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_MdpCompareBw kMdpCompareBw{}; + template T* set_mdp_compare_bw() { + return BeginNestedMessage(82); + } + + + using FieldMetadata_MdpPerfSetPanicLuts = + ::protozero::proto_utils::FieldMetadata< + 83, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MdpPerfSetPanicLutsFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_MdpPerfSetPanicLuts kMdpPerfSetPanicLuts{}; + template T* set_mdp_perf_set_panic_luts() { + return BeginNestedMessage(83); + } + + + using FieldMetadata_MdpSsppSet = + ::protozero::proto_utils::FieldMetadata< + 84, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MdpSsppSetFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_MdpSsppSet kMdpSsppSet{}; + template T* set_mdp_sspp_set() { + return BeginNestedMessage(84); + } + + + using FieldMetadata_MdpCmdReadptrDone = + ::protozero::proto_utils::FieldMetadata< + 85, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MdpCmdReadptrDoneFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_MdpCmdReadptrDone kMdpCmdReadptrDone{}; + template T* set_mdp_cmd_readptr_done() { + return BeginNestedMessage(85); + } + + + using FieldMetadata_MdpMisrCrc = + ::protozero::proto_utils::FieldMetadata< + 86, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MdpMisrCrcFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_MdpMisrCrc kMdpMisrCrc{}; + template T* set_mdp_misr_crc() { + return BeginNestedMessage(86); + } + + + using FieldMetadata_MdpPerfSetQosLuts = + ::protozero::proto_utils::FieldMetadata< + 87, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MdpPerfSetQosLutsFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_MdpPerfSetQosLuts kMdpPerfSetQosLuts{}; + template T* set_mdp_perf_set_qos_luts() { + return BeginNestedMessage(87); + } + + + using FieldMetadata_MdpTraceCounter = + ::protozero::proto_utils::FieldMetadata< + 88, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MdpTraceCounterFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_MdpTraceCounter kMdpTraceCounter{}; + template T* set_mdp_trace_counter() { + return BeginNestedMessage(88); + } + + + using FieldMetadata_MdpCmdReleaseBw = + ::protozero::proto_utils::FieldMetadata< + 89, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MdpCmdReleaseBwFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_MdpCmdReleaseBw kMdpCmdReleaseBw{}; + template T* set_mdp_cmd_release_bw() { + return BeginNestedMessage(89); + } + + + using FieldMetadata_MdpMixerUpdate = + ::protozero::proto_utils::FieldMetadata< + 90, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MdpMixerUpdateFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_MdpMixerUpdate kMdpMixerUpdate{}; + template T* set_mdp_mixer_update() { + return BeginNestedMessage(90); + } + + + using FieldMetadata_MdpPerfSetWmLevels = + ::protozero::proto_utils::FieldMetadata< + 91, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MdpPerfSetWmLevelsFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_MdpPerfSetWmLevels kMdpPerfSetWmLevels{}; + template T* set_mdp_perf_set_wm_levels() { + return BeginNestedMessage(91); + } + + + using FieldMetadata_MdpVideoUnderrunDone = + ::protozero::proto_utils::FieldMetadata< + 92, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MdpVideoUnderrunDoneFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_MdpVideoUnderrunDone kMdpVideoUnderrunDone{}; + template T* set_mdp_video_underrun_done() { + return BeginNestedMessage(92); + } + + + using FieldMetadata_MdpCmdWaitPingpong = + ::protozero::proto_utils::FieldMetadata< + 93, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MdpCmdWaitPingpongFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_MdpCmdWaitPingpong kMdpCmdWaitPingpong{}; + template T* set_mdp_cmd_wait_pingpong() { + return BeginNestedMessage(93); + } + + + using FieldMetadata_MdpPerfPrefillCalc = + ::protozero::proto_utils::FieldMetadata< + 94, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MdpPerfPrefillCalcFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_MdpPerfPrefillCalc kMdpPerfPrefillCalc{}; + template T* set_mdp_perf_prefill_calc() { + return BeginNestedMessage(94); + } + + + using FieldMetadata_MdpPerfUpdateBus = + ::protozero::proto_utils::FieldMetadata< + 95, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MdpPerfUpdateBusFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_MdpPerfUpdateBus kMdpPerfUpdateBus{}; + template T* set_mdp_perf_update_bus() { + return BeginNestedMessage(95); + } + + + using FieldMetadata_RotatorBwAoAsContext = + ::protozero::proto_utils::FieldMetadata< + 96, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + RotatorBwAoAsContextFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_RotatorBwAoAsContext kRotatorBwAoAsContext{}; + template T* set_rotator_bw_ao_as_context() { + return BeginNestedMessage(96); + } + + + using FieldMetadata_MmFilemapAddToPageCache = + ::protozero::proto_utils::FieldMetadata< + 97, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MmFilemapAddToPageCacheFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_MmFilemapAddToPageCache kMmFilemapAddToPageCache{}; + template T* set_mm_filemap_add_to_page_cache() { + return BeginNestedMessage(97); + } + + + using FieldMetadata_MmFilemapDeleteFromPageCache = + ::protozero::proto_utils::FieldMetadata< + 98, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MmFilemapDeleteFromPageCacheFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_MmFilemapDeleteFromPageCache kMmFilemapDeleteFromPageCache{}; + template T* set_mm_filemap_delete_from_page_cache() { + return BeginNestedMessage(98); + } + + + using FieldMetadata_MmCompactionBegin = + ::protozero::proto_utils::FieldMetadata< + 99, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MmCompactionBeginFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_MmCompactionBegin kMmCompactionBegin{}; + template T* set_mm_compaction_begin() { + return BeginNestedMessage(99); + } + + + using FieldMetadata_MmCompactionDeferCompaction = + ::protozero::proto_utils::FieldMetadata< + 100, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MmCompactionDeferCompactionFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_MmCompactionDeferCompaction kMmCompactionDeferCompaction{}; + template T* set_mm_compaction_defer_compaction() { + return BeginNestedMessage(100); + } + + + using FieldMetadata_MmCompactionDeferred = + ::protozero::proto_utils::FieldMetadata< + 101, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MmCompactionDeferredFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_MmCompactionDeferred kMmCompactionDeferred{}; + template T* set_mm_compaction_deferred() { + return BeginNestedMessage(101); + } + + + using FieldMetadata_MmCompactionDeferReset = + ::protozero::proto_utils::FieldMetadata< + 102, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MmCompactionDeferResetFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_MmCompactionDeferReset kMmCompactionDeferReset{}; + template T* set_mm_compaction_defer_reset() { + return BeginNestedMessage(102); + } + + + using FieldMetadata_MmCompactionEnd = + ::protozero::proto_utils::FieldMetadata< + 103, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MmCompactionEndFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_MmCompactionEnd kMmCompactionEnd{}; + template T* set_mm_compaction_end() { + return BeginNestedMessage(103); + } + + + using FieldMetadata_MmCompactionFinished = + ::protozero::proto_utils::FieldMetadata< + 104, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MmCompactionFinishedFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_MmCompactionFinished kMmCompactionFinished{}; + template T* set_mm_compaction_finished() { + return BeginNestedMessage(104); + } + + + using FieldMetadata_MmCompactionIsolateFreepages = + ::protozero::proto_utils::FieldMetadata< + 105, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MmCompactionIsolateFreepagesFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_MmCompactionIsolateFreepages kMmCompactionIsolateFreepages{}; + template T* set_mm_compaction_isolate_freepages() { + return BeginNestedMessage(105); + } + + + using FieldMetadata_MmCompactionIsolateMigratepages = + ::protozero::proto_utils::FieldMetadata< + 106, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MmCompactionIsolateMigratepagesFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_MmCompactionIsolateMigratepages kMmCompactionIsolateMigratepages{}; + template T* set_mm_compaction_isolate_migratepages() { + return BeginNestedMessage(106); + } + + + using FieldMetadata_MmCompactionKcompactdSleep = + ::protozero::proto_utils::FieldMetadata< + 107, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MmCompactionKcompactdSleepFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_MmCompactionKcompactdSleep kMmCompactionKcompactdSleep{}; + template T* set_mm_compaction_kcompactd_sleep() { + return BeginNestedMessage(107); + } + + + using FieldMetadata_MmCompactionKcompactdWake = + ::protozero::proto_utils::FieldMetadata< + 108, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MmCompactionKcompactdWakeFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_MmCompactionKcompactdWake kMmCompactionKcompactdWake{}; + template T* set_mm_compaction_kcompactd_wake() { + return BeginNestedMessage(108); + } + + + using FieldMetadata_MmCompactionMigratepages = + ::protozero::proto_utils::FieldMetadata< + 109, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MmCompactionMigratepagesFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_MmCompactionMigratepages kMmCompactionMigratepages{}; + template T* set_mm_compaction_migratepages() { + return BeginNestedMessage(109); + } + + + using FieldMetadata_MmCompactionSuitable = + ::protozero::proto_utils::FieldMetadata< + 110, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MmCompactionSuitableFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_MmCompactionSuitable kMmCompactionSuitable{}; + template T* set_mm_compaction_suitable() { + return BeginNestedMessage(110); + } + + + using FieldMetadata_MmCompactionTryToCompactPages = + ::protozero::proto_utils::FieldMetadata< + 111, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MmCompactionTryToCompactPagesFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_MmCompactionTryToCompactPages kMmCompactionTryToCompactPages{}; + template T* set_mm_compaction_try_to_compact_pages() { + return BeginNestedMessage(111); + } + + + using FieldMetadata_MmCompactionWakeupKcompactd = + ::protozero::proto_utils::FieldMetadata< + 112, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MmCompactionWakeupKcompactdFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_MmCompactionWakeupKcompactd kMmCompactionWakeupKcompactd{}; + template T* set_mm_compaction_wakeup_kcompactd() { + return BeginNestedMessage(112); + } + + + using FieldMetadata_SuspendResume = + ::protozero::proto_utils::FieldMetadata< + 113, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + SuspendResumeFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_SuspendResume kSuspendResume{}; + template T* set_suspend_resume() { + return BeginNestedMessage(113); + } + + + using FieldMetadata_SchedWakeupNew = + ::protozero::proto_utils::FieldMetadata< + 114, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + SchedWakeupNewFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_SchedWakeupNew kSchedWakeupNew{}; + template T* set_sched_wakeup_new() { + return BeginNestedMessage(114); + } + + + using FieldMetadata_BlockBioBackmerge = + ::protozero::proto_utils::FieldMetadata< + 115, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + BlockBioBackmergeFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_BlockBioBackmerge kBlockBioBackmerge{}; + template T* set_block_bio_backmerge() { + return BeginNestedMessage(115); + } + + + using FieldMetadata_BlockBioBounce = + ::protozero::proto_utils::FieldMetadata< + 116, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + BlockBioBounceFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_BlockBioBounce kBlockBioBounce{}; + template T* set_block_bio_bounce() { + return BeginNestedMessage(116); + } + + + using FieldMetadata_BlockBioComplete = + ::protozero::proto_utils::FieldMetadata< + 117, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + BlockBioCompleteFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_BlockBioComplete kBlockBioComplete{}; + template T* set_block_bio_complete() { + return BeginNestedMessage(117); + } + + + using FieldMetadata_BlockBioFrontmerge = + ::protozero::proto_utils::FieldMetadata< + 118, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + BlockBioFrontmergeFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_BlockBioFrontmerge kBlockBioFrontmerge{}; + template T* set_block_bio_frontmerge() { + return BeginNestedMessage(118); + } + + + using FieldMetadata_BlockBioQueue = + ::protozero::proto_utils::FieldMetadata< + 119, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + BlockBioQueueFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_BlockBioQueue kBlockBioQueue{}; + template T* set_block_bio_queue() { + return BeginNestedMessage(119); + } + + + using FieldMetadata_BlockBioRemap = + ::protozero::proto_utils::FieldMetadata< + 120, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + BlockBioRemapFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_BlockBioRemap kBlockBioRemap{}; + template T* set_block_bio_remap() { + return BeginNestedMessage(120); + } + + + using FieldMetadata_BlockDirtyBuffer = + ::protozero::proto_utils::FieldMetadata< + 121, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + BlockDirtyBufferFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_BlockDirtyBuffer kBlockDirtyBuffer{}; + template T* set_block_dirty_buffer() { + return BeginNestedMessage(121); + } + + + using FieldMetadata_BlockGetrq = + ::protozero::proto_utils::FieldMetadata< + 122, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + BlockGetrqFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_BlockGetrq kBlockGetrq{}; + template T* set_block_getrq() { + return BeginNestedMessage(122); + } + + + using FieldMetadata_BlockPlug = + ::protozero::proto_utils::FieldMetadata< + 123, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + BlockPlugFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_BlockPlug kBlockPlug{}; + template T* set_block_plug() { + return BeginNestedMessage(123); + } + + + using FieldMetadata_BlockRqAbort = + ::protozero::proto_utils::FieldMetadata< + 124, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + BlockRqAbortFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_BlockRqAbort kBlockRqAbort{}; + template T* set_block_rq_abort() { + return BeginNestedMessage(124); + } + + + using FieldMetadata_BlockRqComplete = + ::protozero::proto_utils::FieldMetadata< + 125, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + BlockRqCompleteFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_BlockRqComplete kBlockRqComplete{}; + template T* set_block_rq_complete() { + return BeginNestedMessage(125); + } + + + using FieldMetadata_BlockRqInsert = + ::protozero::proto_utils::FieldMetadata< + 126, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + BlockRqInsertFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_BlockRqInsert kBlockRqInsert{}; + template T* set_block_rq_insert() { + return BeginNestedMessage(126); + } + + + using FieldMetadata_BlockRqRemap = + ::protozero::proto_utils::FieldMetadata< + 128, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + BlockRqRemapFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_BlockRqRemap kBlockRqRemap{}; + template T* set_block_rq_remap() { + return BeginNestedMessage(128); + } + + + using FieldMetadata_BlockRqRequeue = + ::protozero::proto_utils::FieldMetadata< + 129, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + BlockRqRequeueFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_BlockRqRequeue kBlockRqRequeue{}; + template T* set_block_rq_requeue() { + return BeginNestedMessage(129); + } + + + using FieldMetadata_BlockSleeprq = + ::protozero::proto_utils::FieldMetadata< + 130, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + BlockSleeprqFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_BlockSleeprq kBlockSleeprq{}; + template T* set_block_sleeprq() { + return BeginNestedMessage(130); + } + + + using FieldMetadata_BlockSplit = + ::protozero::proto_utils::FieldMetadata< + 131, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + BlockSplitFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_BlockSplit kBlockSplit{}; + template T* set_block_split() { + return BeginNestedMessage(131); + } + + + using FieldMetadata_BlockTouchBuffer = + ::protozero::proto_utils::FieldMetadata< + 132, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + BlockTouchBufferFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_BlockTouchBuffer kBlockTouchBuffer{}; + template T* set_block_touch_buffer() { + return BeginNestedMessage(132); + } + + + using FieldMetadata_BlockUnplug = + ::protozero::proto_utils::FieldMetadata< + 133, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + BlockUnplugFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_BlockUnplug kBlockUnplug{}; + template T* set_block_unplug() { + return BeginNestedMessage(133); + } + + + using FieldMetadata_Ext4AllocDaBlocks = + ::protozero::proto_utils::FieldMetadata< + 134, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4AllocDaBlocksFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4AllocDaBlocks kExt4AllocDaBlocks{}; + template T* set_ext4_alloc_da_blocks() { + return BeginNestedMessage(134); + } + + + using FieldMetadata_Ext4AllocateBlocks = + ::protozero::proto_utils::FieldMetadata< + 135, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4AllocateBlocksFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4AllocateBlocks kExt4AllocateBlocks{}; + template T* set_ext4_allocate_blocks() { + return BeginNestedMessage(135); + } + + + using FieldMetadata_Ext4AllocateInode = + ::protozero::proto_utils::FieldMetadata< + 136, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4AllocateInodeFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4AllocateInode kExt4AllocateInode{}; + template T* set_ext4_allocate_inode() { + return BeginNestedMessage(136); + } + + + using FieldMetadata_Ext4BeginOrderedTruncate = + ::protozero::proto_utils::FieldMetadata< + 137, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4BeginOrderedTruncateFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4BeginOrderedTruncate kExt4BeginOrderedTruncate{}; + template T* set_ext4_begin_ordered_truncate() { + return BeginNestedMessage(137); + } + + + using FieldMetadata_Ext4CollapseRange = + ::protozero::proto_utils::FieldMetadata< + 138, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4CollapseRangeFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4CollapseRange kExt4CollapseRange{}; + template T* set_ext4_collapse_range() { + return BeginNestedMessage(138); + } + + + using FieldMetadata_Ext4DaReleaseSpace = + ::protozero::proto_utils::FieldMetadata< + 139, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4DaReleaseSpaceFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4DaReleaseSpace kExt4DaReleaseSpace{}; + template T* set_ext4_da_release_space() { + return BeginNestedMessage(139); + } + + + using FieldMetadata_Ext4DaReserveSpace = + ::protozero::proto_utils::FieldMetadata< + 140, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4DaReserveSpaceFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4DaReserveSpace kExt4DaReserveSpace{}; + template T* set_ext4_da_reserve_space() { + return BeginNestedMessage(140); + } + + + using FieldMetadata_Ext4DaUpdateReserveSpace = + ::protozero::proto_utils::FieldMetadata< + 141, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4DaUpdateReserveSpaceFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4DaUpdateReserveSpace kExt4DaUpdateReserveSpace{}; + template T* set_ext4_da_update_reserve_space() { + return BeginNestedMessage(141); + } + + + using FieldMetadata_Ext4DaWritePages = + ::protozero::proto_utils::FieldMetadata< + 142, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4DaWritePagesFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4DaWritePages kExt4DaWritePages{}; + template T* set_ext4_da_write_pages() { + return BeginNestedMessage(142); + } + + + using FieldMetadata_Ext4DaWritePagesExtent = + ::protozero::proto_utils::FieldMetadata< + 143, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4DaWritePagesExtentFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4DaWritePagesExtent kExt4DaWritePagesExtent{}; + template T* set_ext4_da_write_pages_extent() { + return BeginNestedMessage(143); + } + + + using FieldMetadata_Ext4DirectIOEnter = + ::protozero::proto_utils::FieldMetadata< + 144, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4DirectIOEnterFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4DirectIOEnter kExt4DirectIOEnter{}; + template T* set_ext4_direct_io_enter() { + return BeginNestedMessage(144); + } + + + using FieldMetadata_Ext4DirectIOExit = + ::protozero::proto_utils::FieldMetadata< + 145, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4DirectIOExitFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4DirectIOExit kExt4DirectIOExit{}; + template T* set_ext4_direct_io_exit() { + return BeginNestedMessage(145); + } + + + using FieldMetadata_Ext4DiscardBlocks = + ::protozero::proto_utils::FieldMetadata< + 146, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4DiscardBlocksFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4DiscardBlocks kExt4DiscardBlocks{}; + template T* set_ext4_discard_blocks() { + return BeginNestedMessage(146); + } + + + using FieldMetadata_Ext4DiscardPreallocations = + ::protozero::proto_utils::FieldMetadata< + 147, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4DiscardPreallocationsFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4DiscardPreallocations kExt4DiscardPreallocations{}; + template T* set_ext4_discard_preallocations() { + return BeginNestedMessage(147); + } + + + using FieldMetadata_Ext4DropInode = + ::protozero::proto_utils::FieldMetadata< + 148, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4DropInodeFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4DropInode kExt4DropInode{}; + template T* set_ext4_drop_inode() { + return BeginNestedMessage(148); + } + + + using FieldMetadata_Ext4EsCacheExtent = + ::protozero::proto_utils::FieldMetadata< + 149, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4EsCacheExtentFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4EsCacheExtent kExt4EsCacheExtent{}; + template T* set_ext4_es_cache_extent() { + return BeginNestedMessage(149); + } + + + using FieldMetadata_Ext4EsFindDelayedExtentRangeEnter = + ::protozero::proto_utils::FieldMetadata< + 150, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4EsFindDelayedExtentRangeEnterFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4EsFindDelayedExtentRangeEnter kExt4EsFindDelayedExtentRangeEnter{}; + template T* set_ext4_es_find_delayed_extent_range_enter() { + return BeginNestedMessage(150); + } + + + using FieldMetadata_Ext4EsFindDelayedExtentRangeExit = + ::protozero::proto_utils::FieldMetadata< + 151, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4EsFindDelayedExtentRangeExitFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4EsFindDelayedExtentRangeExit kExt4EsFindDelayedExtentRangeExit{}; + template T* set_ext4_es_find_delayed_extent_range_exit() { + return BeginNestedMessage(151); + } + + + using FieldMetadata_Ext4EsInsertExtent = + ::protozero::proto_utils::FieldMetadata< + 152, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4EsInsertExtentFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4EsInsertExtent kExt4EsInsertExtent{}; + template T* set_ext4_es_insert_extent() { + return BeginNestedMessage(152); + } + + + using FieldMetadata_Ext4EsLookupExtentEnter = + ::protozero::proto_utils::FieldMetadata< + 153, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4EsLookupExtentEnterFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4EsLookupExtentEnter kExt4EsLookupExtentEnter{}; + template T* set_ext4_es_lookup_extent_enter() { + return BeginNestedMessage(153); + } + + + using FieldMetadata_Ext4EsLookupExtentExit = + ::protozero::proto_utils::FieldMetadata< + 154, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4EsLookupExtentExitFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4EsLookupExtentExit kExt4EsLookupExtentExit{}; + template T* set_ext4_es_lookup_extent_exit() { + return BeginNestedMessage(154); + } + + + using FieldMetadata_Ext4EsRemoveExtent = + ::protozero::proto_utils::FieldMetadata< + 155, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4EsRemoveExtentFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4EsRemoveExtent kExt4EsRemoveExtent{}; + template T* set_ext4_es_remove_extent() { + return BeginNestedMessage(155); + } + + + using FieldMetadata_Ext4EsShrink = + ::protozero::proto_utils::FieldMetadata< + 156, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4EsShrinkFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4EsShrink kExt4EsShrink{}; + template T* set_ext4_es_shrink() { + return BeginNestedMessage(156); + } + + + using FieldMetadata_Ext4EsShrinkCount = + ::protozero::proto_utils::FieldMetadata< + 157, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4EsShrinkCountFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4EsShrinkCount kExt4EsShrinkCount{}; + template T* set_ext4_es_shrink_count() { + return BeginNestedMessage(157); + } + + + using FieldMetadata_Ext4EsShrinkScanEnter = + ::protozero::proto_utils::FieldMetadata< + 158, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4EsShrinkScanEnterFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4EsShrinkScanEnter kExt4EsShrinkScanEnter{}; + template T* set_ext4_es_shrink_scan_enter() { + return BeginNestedMessage(158); + } + + + using FieldMetadata_Ext4EsShrinkScanExit = + ::protozero::proto_utils::FieldMetadata< + 159, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4EsShrinkScanExitFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4EsShrinkScanExit kExt4EsShrinkScanExit{}; + template T* set_ext4_es_shrink_scan_exit() { + return BeginNestedMessage(159); + } + + + using FieldMetadata_Ext4EvictInode = + ::protozero::proto_utils::FieldMetadata< + 160, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4EvictInodeFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4EvictInode kExt4EvictInode{}; + template T* set_ext4_evict_inode() { + return BeginNestedMessage(160); + } + + + using FieldMetadata_Ext4ExtConvertToInitializedEnter = + ::protozero::proto_utils::FieldMetadata< + 161, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4ExtConvertToInitializedEnterFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4ExtConvertToInitializedEnter kExt4ExtConvertToInitializedEnter{}; + template T* set_ext4_ext_convert_to_initialized_enter() { + return BeginNestedMessage(161); + } + + + using FieldMetadata_Ext4ExtConvertToInitializedFastpath = + ::protozero::proto_utils::FieldMetadata< + 162, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4ExtConvertToInitializedFastpathFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4ExtConvertToInitializedFastpath kExt4ExtConvertToInitializedFastpath{}; + template T* set_ext4_ext_convert_to_initialized_fastpath() { + return BeginNestedMessage(162); + } + + + using FieldMetadata_Ext4ExtHandleUnwrittenExtents = + ::protozero::proto_utils::FieldMetadata< + 163, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4ExtHandleUnwrittenExtentsFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4ExtHandleUnwrittenExtents kExt4ExtHandleUnwrittenExtents{}; + template T* set_ext4_ext_handle_unwritten_extents() { + return BeginNestedMessage(163); + } + + + using FieldMetadata_Ext4ExtInCache = + ::protozero::proto_utils::FieldMetadata< + 164, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4ExtInCacheFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4ExtInCache kExt4ExtInCache{}; + template T* set_ext4_ext_in_cache() { + return BeginNestedMessage(164); + } + + + using FieldMetadata_Ext4ExtLoadExtent = + ::protozero::proto_utils::FieldMetadata< + 165, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4ExtLoadExtentFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4ExtLoadExtent kExt4ExtLoadExtent{}; + template T* set_ext4_ext_load_extent() { + return BeginNestedMessage(165); + } + + + using FieldMetadata_Ext4ExtMapBlocksEnter = + ::protozero::proto_utils::FieldMetadata< + 166, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4ExtMapBlocksEnterFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4ExtMapBlocksEnter kExt4ExtMapBlocksEnter{}; + template T* set_ext4_ext_map_blocks_enter() { + return BeginNestedMessage(166); + } + + + using FieldMetadata_Ext4ExtMapBlocksExit = + ::protozero::proto_utils::FieldMetadata< + 167, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4ExtMapBlocksExitFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4ExtMapBlocksExit kExt4ExtMapBlocksExit{}; + template T* set_ext4_ext_map_blocks_exit() { + return BeginNestedMessage(167); + } + + + using FieldMetadata_Ext4ExtPutInCache = + ::protozero::proto_utils::FieldMetadata< + 168, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4ExtPutInCacheFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4ExtPutInCache kExt4ExtPutInCache{}; + template T* set_ext4_ext_put_in_cache() { + return BeginNestedMessage(168); + } + + + using FieldMetadata_Ext4ExtRemoveSpace = + ::protozero::proto_utils::FieldMetadata< + 169, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4ExtRemoveSpaceFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4ExtRemoveSpace kExt4ExtRemoveSpace{}; + template T* set_ext4_ext_remove_space() { + return BeginNestedMessage(169); + } + + + using FieldMetadata_Ext4ExtRemoveSpaceDone = + ::protozero::proto_utils::FieldMetadata< + 170, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4ExtRemoveSpaceDoneFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4ExtRemoveSpaceDone kExt4ExtRemoveSpaceDone{}; + template T* set_ext4_ext_remove_space_done() { + return BeginNestedMessage(170); + } + + + using FieldMetadata_Ext4ExtRmIdx = + ::protozero::proto_utils::FieldMetadata< + 171, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4ExtRmIdxFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4ExtRmIdx kExt4ExtRmIdx{}; + template T* set_ext4_ext_rm_idx() { + return BeginNestedMessage(171); + } + + + using FieldMetadata_Ext4ExtRmLeaf = + ::protozero::proto_utils::FieldMetadata< + 172, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4ExtRmLeafFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4ExtRmLeaf kExt4ExtRmLeaf{}; + template T* set_ext4_ext_rm_leaf() { + return BeginNestedMessage(172); + } + + + using FieldMetadata_Ext4ExtShowExtent = + ::protozero::proto_utils::FieldMetadata< + 173, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4ExtShowExtentFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4ExtShowExtent kExt4ExtShowExtent{}; + template T* set_ext4_ext_show_extent() { + return BeginNestedMessage(173); + } + + + using FieldMetadata_Ext4FallocateEnter = + ::protozero::proto_utils::FieldMetadata< + 174, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4FallocateEnterFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4FallocateEnter kExt4FallocateEnter{}; + template T* set_ext4_fallocate_enter() { + return BeginNestedMessage(174); + } + + + using FieldMetadata_Ext4FallocateExit = + ::protozero::proto_utils::FieldMetadata< + 175, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4FallocateExitFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4FallocateExit kExt4FallocateExit{}; + template T* set_ext4_fallocate_exit() { + return BeginNestedMessage(175); + } + + + using FieldMetadata_Ext4FindDelallocRange = + ::protozero::proto_utils::FieldMetadata< + 176, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4FindDelallocRangeFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4FindDelallocRange kExt4FindDelallocRange{}; + template T* set_ext4_find_delalloc_range() { + return BeginNestedMessage(176); + } + + + using FieldMetadata_Ext4Forget = + ::protozero::proto_utils::FieldMetadata< + 177, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4ForgetFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4Forget kExt4Forget{}; + template T* set_ext4_forget() { + return BeginNestedMessage(177); + } + + + using FieldMetadata_Ext4FreeBlocks = + ::protozero::proto_utils::FieldMetadata< + 178, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4FreeBlocksFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4FreeBlocks kExt4FreeBlocks{}; + template T* set_ext4_free_blocks() { + return BeginNestedMessage(178); + } + + + using FieldMetadata_Ext4FreeInode = + ::protozero::proto_utils::FieldMetadata< + 179, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4FreeInodeFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4FreeInode kExt4FreeInode{}; + template T* set_ext4_free_inode() { + return BeginNestedMessage(179); + } + + + using FieldMetadata_Ext4GetImpliedClusterAllocExit = + ::protozero::proto_utils::FieldMetadata< + 180, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4GetImpliedClusterAllocExitFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4GetImpliedClusterAllocExit kExt4GetImpliedClusterAllocExit{}; + template T* set_ext4_get_implied_cluster_alloc_exit() { + return BeginNestedMessage(180); + } + + + using FieldMetadata_Ext4GetReservedClusterAlloc = + ::protozero::proto_utils::FieldMetadata< + 181, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4GetReservedClusterAllocFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4GetReservedClusterAlloc kExt4GetReservedClusterAlloc{}; + template T* set_ext4_get_reserved_cluster_alloc() { + return BeginNestedMessage(181); + } + + + using FieldMetadata_Ext4IndMapBlocksEnter = + ::protozero::proto_utils::FieldMetadata< + 182, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4IndMapBlocksEnterFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4IndMapBlocksEnter kExt4IndMapBlocksEnter{}; + template T* set_ext4_ind_map_blocks_enter() { + return BeginNestedMessage(182); + } + + + using FieldMetadata_Ext4IndMapBlocksExit = + ::protozero::proto_utils::FieldMetadata< + 183, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4IndMapBlocksExitFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4IndMapBlocksExit kExt4IndMapBlocksExit{}; + template T* set_ext4_ind_map_blocks_exit() { + return BeginNestedMessage(183); + } + + + using FieldMetadata_Ext4InsertRange = + ::protozero::proto_utils::FieldMetadata< + 184, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4InsertRangeFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4InsertRange kExt4InsertRange{}; + template T* set_ext4_insert_range() { + return BeginNestedMessage(184); + } + + + using FieldMetadata_Ext4Invalidatepage = + ::protozero::proto_utils::FieldMetadata< + 185, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4InvalidatepageFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4Invalidatepage kExt4Invalidatepage{}; + template T* set_ext4_invalidatepage() { + return BeginNestedMessage(185); + } + + + using FieldMetadata_Ext4JournalStart = + ::protozero::proto_utils::FieldMetadata< + 186, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4JournalStartFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4JournalStart kExt4JournalStart{}; + template T* set_ext4_journal_start() { + return BeginNestedMessage(186); + } + + + using FieldMetadata_Ext4JournalStartReserved = + ::protozero::proto_utils::FieldMetadata< + 187, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4JournalStartReservedFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4JournalStartReserved kExt4JournalStartReserved{}; + template T* set_ext4_journal_start_reserved() { + return BeginNestedMessage(187); + } + + + using FieldMetadata_Ext4JournalledInvalidatepage = + ::protozero::proto_utils::FieldMetadata< + 188, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4JournalledInvalidatepageFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4JournalledInvalidatepage kExt4JournalledInvalidatepage{}; + template T* set_ext4_journalled_invalidatepage() { + return BeginNestedMessage(188); + } + + + using FieldMetadata_Ext4JournalledWriteEnd = + ::protozero::proto_utils::FieldMetadata< + 189, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4JournalledWriteEndFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4JournalledWriteEnd kExt4JournalledWriteEnd{}; + template T* set_ext4_journalled_write_end() { + return BeginNestedMessage(189); + } + + + using FieldMetadata_Ext4LoadInode = + ::protozero::proto_utils::FieldMetadata< + 190, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4LoadInodeFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4LoadInode kExt4LoadInode{}; + template T* set_ext4_load_inode() { + return BeginNestedMessage(190); + } + + + using FieldMetadata_Ext4LoadInodeBitmap = + ::protozero::proto_utils::FieldMetadata< + 191, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4LoadInodeBitmapFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4LoadInodeBitmap kExt4LoadInodeBitmap{}; + template T* set_ext4_load_inode_bitmap() { + return BeginNestedMessage(191); + } + + + using FieldMetadata_Ext4MarkInodeDirty = + ::protozero::proto_utils::FieldMetadata< + 192, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4MarkInodeDirtyFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4MarkInodeDirty kExt4MarkInodeDirty{}; + template T* set_ext4_mark_inode_dirty() { + return BeginNestedMessage(192); + } + + + using FieldMetadata_Ext4MbBitmapLoad = + ::protozero::proto_utils::FieldMetadata< + 193, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4MbBitmapLoadFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4MbBitmapLoad kExt4MbBitmapLoad{}; + template T* set_ext4_mb_bitmap_load() { + return BeginNestedMessage(193); + } + + + using FieldMetadata_Ext4MbBuddyBitmapLoad = + ::protozero::proto_utils::FieldMetadata< + 194, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4MbBuddyBitmapLoadFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4MbBuddyBitmapLoad kExt4MbBuddyBitmapLoad{}; + template T* set_ext4_mb_buddy_bitmap_load() { + return BeginNestedMessage(194); + } + + + using FieldMetadata_Ext4MbDiscardPreallocations = + ::protozero::proto_utils::FieldMetadata< + 195, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4MbDiscardPreallocationsFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4MbDiscardPreallocations kExt4MbDiscardPreallocations{}; + template T* set_ext4_mb_discard_preallocations() { + return BeginNestedMessage(195); + } + + + using FieldMetadata_Ext4MbNewGroupPa = + ::protozero::proto_utils::FieldMetadata< + 196, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4MbNewGroupPaFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4MbNewGroupPa kExt4MbNewGroupPa{}; + template T* set_ext4_mb_new_group_pa() { + return BeginNestedMessage(196); + } + + + using FieldMetadata_Ext4MbNewInodePa = + ::protozero::proto_utils::FieldMetadata< + 197, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4MbNewInodePaFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4MbNewInodePa kExt4MbNewInodePa{}; + template T* set_ext4_mb_new_inode_pa() { + return BeginNestedMessage(197); + } + + + using FieldMetadata_Ext4MbReleaseGroupPa = + ::protozero::proto_utils::FieldMetadata< + 198, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4MbReleaseGroupPaFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4MbReleaseGroupPa kExt4MbReleaseGroupPa{}; + template T* set_ext4_mb_release_group_pa() { + return BeginNestedMessage(198); + } + + + using FieldMetadata_Ext4MbReleaseInodePa = + ::protozero::proto_utils::FieldMetadata< + 199, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4MbReleaseInodePaFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4MbReleaseInodePa kExt4MbReleaseInodePa{}; + template T* set_ext4_mb_release_inode_pa() { + return BeginNestedMessage(199); + } + + + using FieldMetadata_Ext4MballocAlloc = + ::protozero::proto_utils::FieldMetadata< + 200, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4MballocAllocFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4MballocAlloc kExt4MballocAlloc{}; + template T* set_ext4_mballoc_alloc() { + return BeginNestedMessage(200); + } + + + using FieldMetadata_Ext4MballocDiscard = + ::protozero::proto_utils::FieldMetadata< + 201, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4MballocDiscardFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4MballocDiscard kExt4MballocDiscard{}; + template T* set_ext4_mballoc_discard() { + return BeginNestedMessage(201); + } + + + using FieldMetadata_Ext4MballocFree = + ::protozero::proto_utils::FieldMetadata< + 202, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4MballocFreeFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4MballocFree kExt4MballocFree{}; + template T* set_ext4_mballoc_free() { + return BeginNestedMessage(202); + } + + + using FieldMetadata_Ext4MballocPrealloc = + ::protozero::proto_utils::FieldMetadata< + 203, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4MballocPreallocFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4MballocPrealloc kExt4MballocPrealloc{}; + template T* set_ext4_mballoc_prealloc() { + return BeginNestedMessage(203); + } + + + using FieldMetadata_Ext4OtherInodeUpdateTime = + ::protozero::proto_utils::FieldMetadata< + 204, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4OtherInodeUpdateTimeFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4OtherInodeUpdateTime kExt4OtherInodeUpdateTime{}; + template T* set_ext4_other_inode_update_time() { + return BeginNestedMessage(204); + } + + + using FieldMetadata_Ext4PunchHole = + ::protozero::proto_utils::FieldMetadata< + 205, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4PunchHoleFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4PunchHole kExt4PunchHole{}; + template T* set_ext4_punch_hole() { + return BeginNestedMessage(205); + } + + + using FieldMetadata_Ext4ReadBlockBitmapLoad = + ::protozero::proto_utils::FieldMetadata< + 206, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4ReadBlockBitmapLoadFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4ReadBlockBitmapLoad kExt4ReadBlockBitmapLoad{}; + template T* set_ext4_read_block_bitmap_load() { + return BeginNestedMessage(206); + } + + + using FieldMetadata_Ext4Readpage = + ::protozero::proto_utils::FieldMetadata< + 207, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4ReadpageFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4Readpage kExt4Readpage{}; + template T* set_ext4_readpage() { + return BeginNestedMessage(207); + } + + + using FieldMetadata_Ext4Releasepage = + ::protozero::proto_utils::FieldMetadata< + 208, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4ReleasepageFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4Releasepage kExt4Releasepage{}; + template T* set_ext4_releasepage() { + return BeginNestedMessage(208); + } + + + using FieldMetadata_Ext4RemoveBlocks = + ::protozero::proto_utils::FieldMetadata< + 209, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4RemoveBlocksFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4RemoveBlocks kExt4RemoveBlocks{}; + template T* set_ext4_remove_blocks() { + return BeginNestedMessage(209); + } + + + using FieldMetadata_Ext4RequestBlocks = + ::protozero::proto_utils::FieldMetadata< + 210, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4RequestBlocksFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4RequestBlocks kExt4RequestBlocks{}; + template T* set_ext4_request_blocks() { + return BeginNestedMessage(210); + } + + + using FieldMetadata_Ext4RequestInode = + ::protozero::proto_utils::FieldMetadata< + 211, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4RequestInodeFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4RequestInode kExt4RequestInode{}; + template T* set_ext4_request_inode() { + return BeginNestedMessage(211); + } + + + using FieldMetadata_Ext4SyncFs = + ::protozero::proto_utils::FieldMetadata< + 212, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4SyncFsFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4SyncFs kExt4SyncFs{}; + template T* set_ext4_sync_fs() { + return BeginNestedMessage(212); + } + + + using FieldMetadata_Ext4TrimAllFree = + ::protozero::proto_utils::FieldMetadata< + 213, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4TrimAllFreeFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4TrimAllFree kExt4TrimAllFree{}; + template T* set_ext4_trim_all_free() { + return BeginNestedMessage(213); + } + + + using FieldMetadata_Ext4TrimExtent = + ::protozero::proto_utils::FieldMetadata< + 214, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4TrimExtentFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4TrimExtent kExt4TrimExtent{}; + template T* set_ext4_trim_extent() { + return BeginNestedMessage(214); + } + + + using FieldMetadata_Ext4TruncateEnter = + ::protozero::proto_utils::FieldMetadata< + 215, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4TruncateEnterFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4TruncateEnter kExt4TruncateEnter{}; + template T* set_ext4_truncate_enter() { + return BeginNestedMessage(215); + } + + + using FieldMetadata_Ext4TruncateExit = + ::protozero::proto_utils::FieldMetadata< + 216, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4TruncateExitFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4TruncateExit kExt4TruncateExit{}; + template T* set_ext4_truncate_exit() { + return BeginNestedMessage(216); + } + + + using FieldMetadata_Ext4UnlinkEnter = + ::protozero::proto_utils::FieldMetadata< + 217, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4UnlinkEnterFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4UnlinkEnter kExt4UnlinkEnter{}; + template T* set_ext4_unlink_enter() { + return BeginNestedMessage(217); + } + + + using FieldMetadata_Ext4UnlinkExit = + ::protozero::proto_utils::FieldMetadata< + 218, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4UnlinkExitFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4UnlinkExit kExt4UnlinkExit{}; + template T* set_ext4_unlink_exit() { + return BeginNestedMessage(218); + } + + + using FieldMetadata_Ext4WriteBegin = + ::protozero::proto_utils::FieldMetadata< + 219, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4WriteBeginFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4WriteBegin kExt4WriteBegin{}; + template T* set_ext4_write_begin() { + return BeginNestedMessage(219); + } + + + using FieldMetadata_Ext4WriteEnd = + ::protozero::proto_utils::FieldMetadata< + 230, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4WriteEndFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4WriteEnd kExt4WriteEnd{}; + template T* set_ext4_write_end() { + return BeginNestedMessage(230); + } + + + using FieldMetadata_Ext4Writepage = + ::protozero::proto_utils::FieldMetadata< + 231, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4WritepageFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4Writepage kExt4Writepage{}; + template T* set_ext4_writepage() { + return BeginNestedMessage(231); + } + + + using FieldMetadata_Ext4Writepages = + ::protozero::proto_utils::FieldMetadata< + 232, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4WritepagesFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4Writepages kExt4Writepages{}; + template T* set_ext4_writepages() { + return BeginNestedMessage(232); + } + + + using FieldMetadata_Ext4WritepagesResult = + ::protozero::proto_utils::FieldMetadata< + 233, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4WritepagesResultFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4WritepagesResult kExt4WritepagesResult{}; + template T* set_ext4_writepages_result() { + return BeginNestedMessage(233); + } + + + using FieldMetadata_Ext4ZeroRange = + ::protozero::proto_utils::FieldMetadata< + 234, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Ext4ZeroRangeFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Ext4ZeroRange kExt4ZeroRange{}; + template T* set_ext4_zero_range() { + return BeginNestedMessage(234); + } + + + using FieldMetadata_TaskNewtask = + ::protozero::proto_utils::FieldMetadata< + 235, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TaskNewtaskFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_TaskNewtask kTaskNewtask{}; + template T* set_task_newtask() { + return BeginNestedMessage(235); + } + + + using FieldMetadata_TaskRename = + ::protozero::proto_utils::FieldMetadata< + 236, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TaskRenameFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_TaskRename kTaskRename{}; + template T* set_task_rename() { + return BeginNestedMessage(236); + } + + + using FieldMetadata_SchedProcessExec = + ::protozero::proto_utils::FieldMetadata< + 237, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + SchedProcessExecFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_SchedProcessExec kSchedProcessExec{}; + template T* set_sched_process_exec() { + return BeginNestedMessage(237); + } + + + using FieldMetadata_SchedProcessExit = + ::protozero::proto_utils::FieldMetadata< + 238, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + SchedProcessExitFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_SchedProcessExit kSchedProcessExit{}; + template T* set_sched_process_exit() { + return BeginNestedMessage(238); + } + + + using FieldMetadata_SchedProcessFork = + ::protozero::proto_utils::FieldMetadata< + 239, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + SchedProcessForkFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_SchedProcessFork kSchedProcessFork{}; + template T* set_sched_process_fork() { + return BeginNestedMessage(239); + } + + + using FieldMetadata_SchedProcessFree = + ::protozero::proto_utils::FieldMetadata< + 240, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + SchedProcessFreeFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_SchedProcessFree kSchedProcessFree{}; + template T* set_sched_process_free() { + return BeginNestedMessage(240); + } + + + using FieldMetadata_SchedProcessHang = + ::protozero::proto_utils::FieldMetadata< + 241, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + SchedProcessHangFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_SchedProcessHang kSchedProcessHang{}; + template T* set_sched_process_hang() { + return BeginNestedMessage(241); + } + + + using FieldMetadata_SchedProcessWait = + ::protozero::proto_utils::FieldMetadata< + 242, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + SchedProcessWaitFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_SchedProcessWait kSchedProcessWait{}; + template T* set_sched_process_wait() { + return BeginNestedMessage(242); + } + + + using FieldMetadata_F2fsDoSubmitBio = + ::protozero::proto_utils::FieldMetadata< + 243, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + F2fsDoSubmitBioFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_F2fsDoSubmitBio kF2fsDoSubmitBio{}; + template T* set_f2fs_do_submit_bio() { + return BeginNestedMessage(243); + } + + + using FieldMetadata_F2fsEvictInode = + ::protozero::proto_utils::FieldMetadata< + 244, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + F2fsEvictInodeFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_F2fsEvictInode kF2fsEvictInode{}; + template T* set_f2fs_evict_inode() { + return BeginNestedMessage(244); + } + + + using FieldMetadata_F2fsFallocate = + ::protozero::proto_utils::FieldMetadata< + 245, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + F2fsFallocateFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_F2fsFallocate kF2fsFallocate{}; + template T* set_f2fs_fallocate() { + return BeginNestedMessage(245); + } + + + using FieldMetadata_F2fsGetDataBlock = + ::protozero::proto_utils::FieldMetadata< + 246, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + F2fsGetDataBlockFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_F2fsGetDataBlock kF2fsGetDataBlock{}; + template T* set_f2fs_get_data_block() { + return BeginNestedMessage(246); + } + + + using FieldMetadata_F2fsGetVictim = + ::protozero::proto_utils::FieldMetadata< + 247, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + F2fsGetVictimFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_F2fsGetVictim kF2fsGetVictim{}; + template T* set_f2fs_get_victim() { + return BeginNestedMessage(247); + } + + + using FieldMetadata_F2fsIget = + ::protozero::proto_utils::FieldMetadata< + 248, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + F2fsIgetFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_F2fsIget kF2fsIget{}; + template T* set_f2fs_iget() { + return BeginNestedMessage(248); + } + + + using FieldMetadata_F2fsIgetExit = + ::protozero::proto_utils::FieldMetadata< + 249, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + F2fsIgetExitFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_F2fsIgetExit kF2fsIgetExit{}; + template T* set_f2fs_iget_exit() { + return BeginNestedMessage(249); + } + + + using FieldMetadata_F2fsNewInode = + ::protozero::proto_utils::FieldMetadata< + 250, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + F2fsNewInodeFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_F2fsNewInode kF2fsNewInode{}; + template T* set_f2fs_new_inode() { + return BeginNestedMessage(250); + } + + + using FieldMetadata_F2fsReadpage = + ::protozero::proto_utils::FieldMetadata< + 251, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + F2fsReadpageFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_F2fsReadpage kF2fsReadpage{}; + template T* set_f2fs_readpage() { + return BeginNestedMessage(251); + } + + + using FieldMetadata_F2fsReserveNewBlock = + ::protozero::proto_utils::FieldMetadata< + 252, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + F2fsReserveNewBlockFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_F2fsReserveNewBlock kF2fsReserveNewBlock{}; + template T* set_f2fs_reserve_new_block() { + return BeginNestedMessage(252); + } + + + using FieldMetadata_F2fsSetPageDirty = + ::protozero::proto_utils::FieldMetadata< + 253, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + F2fsSetPageDirtyFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_F2fsSetPageDirty kF2fsSetPageDirty{}; + template T* set_f2fs_set_page_dirty() { + return BeginNestedMessage(253); + } + + + using FieldMetadata_F2fsSubmitWritePage = + ::protozero::proto_utils::FieldMetadata< + 254, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + F2fsSubmitWritePageFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_F2fsSubmitWritePage kF2fsSubmitWritePage{}; + template T* set_f2fs_submit_write_page() { + return BeginNestedMessage(254); + } + + + using FieldMetadata_F2fsSyncFileEnter = + ::protozero::proto_utils::FieldMetadata< + 255, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + F2fsSyncFileEnterFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_F2fsSyncFileEnter kF2fsSyncFileEnter{}; + template T* set_f2fs_sync_file_enter() { + return BeginNestedMessage(255); + } + + + using FieldMetadata_F2fsSyncFileExit = + ::protozero::proto_utils::FieldMetadata< + 256, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + F2fsSyncFileExitFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_F2fsSyncFileExit kF2fsSyncFileExit{}; + template T* set_f2fs_sync_file_exit() { + return BeginNestedMessage(256); + } + + + using FieldMetadata_F2fsSyncFs = + ::protozero::proto_utils::FieldMetadata< + 257, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + F2fsSyncFsFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_F2fsSyncFs kF2fsSyncFs{}; + template T* set_f2fs_sync_fs() { + return BeginNestedMessage(257); + } + + + using FieldMetadata_F2fsTruncate = + ::protozero::proto_utils::FieldMetadata< + 258, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + F2fsTruncateFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_F2fsTruncate kF2fsTruncate{}; + template T* set_f2fs_truncate() { + return BeginNestedMessage(258); + } + + + using FieldMetadata_F2fsTruncateBlocksEnter = + ::protozero::proto_utils::FieldMetadata< + 259, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + F2fsTruncateBlocksEnterFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_F2fsTruncateBlocksEnter kF2fsTruncateBlocksEnter{}; + template T* set_f2fs_truncate_blocks_enter() { + return BeginNestedMessage(259); + } + + + using FieldMetadata_F2fsTruncateBlocksExit = + ::protozero::proto_utils::FieldMetadata< + 260, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + F2fsTruncateBlocksExitFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_F2fsTruncateBlocksExit kF2fsTruncateBlocksExit{}; + template T* set_f2fs_truncate_blocks_exit() { + return BeginNestedMessage(260); + } + + + using FieldMetadata_F2fsTruncateDataBlocksRange = + ::protozero::proto_utils::FieldMetadata< + 261, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + F2fsTruncateDataBlocksRangeFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_F2fsTruncateDataBlocksRange kF2fsTruncateDataBlocksRange{}; + template T* set_f2fs_truncate_data_blocks_range() { + return BeginNestedMessage(261); + } + + + using FieldMetadata_F2fsTruncateInodeBlocksEnter = + ::protozero::proto_utils::FieldMetadata< + 262, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + F2fsTruncateInodeBlocksEnterFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_F2fsTruncateInodeBlocksEnter kF2fsTruncateInodeBlocksEnter{}; + template T* set_f2fs_truncate_inode_blocks_enter() { + return BeginNestedMessage(262); + } + + + using FieldMetadata_F2fsTruncateInodeBlocksExit = + ::protozero::proto_utils::FieldMetadata< + 263, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + F2fsTruncateInodeBlocksExitFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_F2fsTruncateInodeBlocksExit kF2fsTruncateInodeBlocksExit{}; + template T* set_f2fs_truncate_inode_blocks_exit() { + return BeginNestedMessage(263); + } + + + using FieldMetadata_F2fsTruncateNode = + ::protozero::proto_utils::FieldMetadata< + 264, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + F2fsTruncateNodeFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_F2fsTruncateNode kF2fsTruncateNode{}; + template T* set_f2fs_truncate_node() { + return BeginNestedMessage(264); + } + + + using FieldMetadata_F2fsTruncateNodesEnter = + ::protozero::proto_utils::FieldMetadata< + 265, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + F2fsTruncateNodesEnterFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_F2fsTruncateNodesEnter kF2fsTruncateNodesEnter{}; + template T* set_f2fs_truncate_nodes_enter() { + return BeginNestedMessage(265); + } + + + using FieldMetadata_F2fsTruncateNodesExit = + ::protozero::proto_utils::FieldMetadata< + 266, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + F2fsTruncateNodesExitFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_F2fsTruncateNodesExit kF2fsTruncateNodesExit{}; + template T* set_f2fs_truncate_nodes_exit() { + return BeginNestedMessage(266); + } + + + using FieldMetadata_F2fsTruncatePartialNodes = + ::protozero::proto_utils::FieldMetadata< + 267, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + F2fsTruncatePartialNodesFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_F2fsTruncatePartialNodes kF2fsTruncatePartialNodes{}; + template T* set_f2fs_truncate_partial_nodes() { + return BeginNestedMessage(267); + } + + + using FieldMetadata_F2fsUnlinkEnter = + ::protozero::proto_utils::FieldMetadata< + 268, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + F2fsUnlinkEnterFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_F2fsUnlinkEnter kF2fsUnlinkEnter{}; + template T* set_f2fs_unlink_enter() { + return BeginNestedMessage(268); + } + + + using FieldMetadata_F2fsUnlinkExit = + ::protozero::proto_utils::FieldMetadata< + 269, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + F2fsUnlinkExitFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_F2fsUnlinkExit kF2fsUnlinkExit{}; + template T* set_f2fs_unlink_exit() { + return BeginNestedMessage(269); + } + + + using FieldMetadata_F2fsVmPageMkwrite = + ::protozero::proto_utils::FieldMetadata< + 270, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + F2fsVmPageMkwriteFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_F2fsVmPageMkwrite kF2fsVmPageMkwrite{}; + template T* set_f2fs_vm_page_mkwrite() { + return BeginNestedMessage(270); + } + + + using FieldMetadata_F2fsWriteBegin = + ::protozero::proto_utils::FieldMetadata< + 271, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + F2fsWriteBeginFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_F2fsWriteBegin kF2fsWriteBegin{}; + template T* set_f2fs_write_begin() { + return BeginNestedMessage(271); + } + + + using FieldMetadata_F2fsWriteCheckpoint = + ::protozero::proto_utils::FieldMetadata< + 272, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + F2fsWriteCheckpointFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_F2fsWriteCheckpoint kF2fsWriteCheckpoint{}; + template T* set_f2fs_write_checkpoint() { + return BeginNestedMessage(272); + } + + + using FieldMetadata_F2fsWriteEnd = + ::protozero::proto_utils::FieldMetadata< + 273, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + F2fsWriteEndFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_F2fsWriteEnd kF2fsWriteEnd{}; + template T* set_f2fs_write_end() { + return BeginNestedMessage(273); + } + + + using FieldMetadata_AllocPagesIommuEnd = + ::protozero::proto_utils::FieldMetadata< + 274, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + AllocPagesIommuEndFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_AllocPagesIommuEnd kAllocPagesIommuEnd{}; + template T* set_alloc_pages_iommu_end() { + return BeginNestedMessage(274); + } + + + using FieldMetadata_AllocPagesIommuFail = + ::protozero::proto_utils::FieldMetadata< + 275, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + AllocPagesIommuFailFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_AllocPagesIommuFail kAllocPagesIommuFail{}; + template T* set_alloc_pages_iommu_fail() { + return BeginNestedMessage(275); + } + + + using FieldMetadata_AllocPagesIommuStart = + ::protozero::proto_utils::FieldMetadata< + 276, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + AllocPagesIommuStartFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_AllocPagesIommuStart kAllocPagesIommuStart{}; + template T* set_alloc_pages_iommu_start() { + return BeginNestedMessage(276); + } + + + using FieldMetadata_AllocPagesSysEnd = + ::protozero::proto_utils::FieldMetadata< + 277, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + AllocPagesSysEndFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_AllocPagesSysEnd kAllocPagesSysEnd{}; + template T* set_alloc_pages_sys_end() { + return BeginNestedMessage(277); + } + + + using FieldMetadata_AllocPagesSysFail = + ::protozero::proto_utils::FieldMetadata< + 278, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + AllocPagesSysFailFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_AllocPagesSysFail kAllocPagesSysFail{}; + template T* set_alloc_pages_sys_fail() { + return BeginNestedMessage(278); + } + + + using FieldMetadata_AllocPagesSysStart = + ::protozero::proto_utils::FieldMetadata< + 279, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + AllocPagesSysStartFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_AllocPagesSysStart kAllocPagesSysStart{}; + template T* set_alloc_pages_sys_start() { + return BeginNestedMessage(279); + } + + + using FieldMetadata_DmaAllocContiguousRetry = + ::protozero::proto_utils::FieldMetadata< + 280, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + DmaAllocContiguousRetryFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_DmaAllocContiguousRetry kDmaAllocContiguousRetry{}; + template T* set_dma_alloc_contiguous_retry() { + return BeginNestedMessage(280); + } + + + using FieldMetadata_IommuMapRange = + ::protozero::proto_utils::FieldMetadata< + 281, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + IommuMapRangeFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_IommuMapRange kIommuMapRange{}; + template T* set_iommu_map_range() { + return BeginNestedMessage(281); + } + + + using FieldMetadata_IommuSecPtblMapRangeEnd = + ::protozero::proto_utils::FieldMetadata< + 282, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + IommuSecPtblMapRangeEndFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_IommuSecPtblMapRangeEnd kIommuSecPtblMapRangeEnd{}; + template T* set_iommu_sec_ptbl_map_range_end() { + return BeginNestedMessage(282); + } + + + using FieldMetadata_IommuSecPtblMapRangeStart = + ::protozero::proto_utils::FieldMetadata< + 283, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + IommuSecPtblMapRangeStartFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_IommuSecPtblMapRangeStart kIommuSecPtblMapRangeStart{}; + template T* set_iommu_sec_ptbl_map_range_start() { + return BeginNestedMessage(283); + } + + + using FieldMetadata_IonAllocBufferEnd = + ::protozero::proto_utils::FieldMetadata< + 284, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + IonAllocBufferEndFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_IonAllocBufferEnd kIonAllocBufferEnd{}; + template T* set_ion_alloc_buffer_end() { + return BeginNestedMessage(284); + } + + + using FieldMetadata_IonAllocBufferFail = + ::protozero::proto_utils::FieldMetadata< + 285, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + IonAllocBufferFailFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_IonAllocBufferFail kIonAllocBufferFail{}; + template T* set_ion_alloc_buffer_fail() { + return BeginNestedMessage(285); + } + + + using FieldMetadata_IonAllocBufferFallback = + ::protozero::proto_utils::FieldMetadata< + 286, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + IonAllocBufferFallbackFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_IonAllocBufferFallback kIonAllocBufferFallback{}; + template T* set_ion_alloc_buffer_fallback() { + return BeginNestedMessage(286); + } + + + using FieldMetadata_IonAllocBufferStart = + ::protozero::proto_utils::FieldMetadata< + 287, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + IonAllocBufferStartFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_IonAllocBufferStart kIonAllocBufferStart{}; + template T* set_ion_alloc_buffer_start() { + return BeginNestedMessage(287); + } + + + using FieldMetadata_IonCpAllocRetry = + ::protozero::proto_utils::FieldMetadata< + 288, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + IonCpAllocRetryFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_IonCpAllocRetry kIonCpAllocRetry{}; + template T* set_ion_cp_alloc_retry() { + return BeginNestedMessage(288); + } + + + using FieldMetadata_IonCpSecureBufferEnd = + ::protozero::proto_utils::FieldMetadata< + 289, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + IonCpSecureBufferEndFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_IonCpSecureBufferEnd kIonCpSecureBufferEnd{}; + template T* set_ion_cp_secure_buffer_end() { + return BeginNestedMessage(289); + } + + + using FieldMetadata_IonCpSecureBufferStart = + ::protozero::proto_utils::FieldMetadata< + 290, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + IonCpSecureBufferStartFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_IonCpSecureBufferStart kIonCpSecureBufferStart{}; + template T* set_ion_cp_secure_buffer_start() { + return BeginNestedMessage(290); + } + + + using FieldMetadata_IonPrefetching = + ::protozero::proto_utils::FieldMetadata< + 291, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + IonPrefetchingFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_IonPrefetching kIonPrefetching{}; + template T* set_ion_prefetching() { + return BeginNestedMessage(291); + } + + + using FieldMetadata_IonSecureCmaAddToPoolEnd = + ::protozero::proto_utils::FieldMetadata< + 292, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + IonSecureCmaAddToPoolEndFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_IonSecureCmaAddToPoolEnd kIonSecureCmaAddToPoolEnd{}; + template T* set_ion_secure_cma_add_to_pool_end() { + return BeginNestedMessage(292); + } + + + using FieldMetadata_IonSecureCmaAddToPoolStart = + ::protozero::proto_utils::FieldMetadata< + 293, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + IonSecureCmaAddToPoolStartFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_IonSecureCmaAddToPoolStart kIonSecureCmaAddToPoolStart{}; + template T* set_ion_secure_cma_add_to_pool_start() { + return BeginNestedMessage(293); + } + + + using FieldMetadata_IonSecureCmaAllocateEnd = + ::protozero::proto_utils::FieldMetadata< + 294, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + IonSecureCmaAllocateEndFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_IonSecureCmaAllocateEnd kIonSecureCmaAllocateEnd{}; + template T* set_ion_secure_cma_allocate_end() { + return BeginNestedMessage(294); + } + + + using FieldMetadata_IonSecureCmaAllocateStart = + ::protozero::proto_utils::FieldMetadata< + 295, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + IonSecureCmaAllocateStartFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_IonSecureCmaAllocateStart kIonSecureCmaAllocateStart{}; + template T* set_ion_secure_cma_allocate_start() { + return BeginNestedMessage(295); + } + + + using FieldMetadata_IonSecureCmaShrinkPoolEnd = + ::protozero::proto_utils::FieldMetadata< + 296, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + IonSecureCmaShrinkPoolEndFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_IonSecureCmaShrinkPoolEnd kIonSecureCmaShrinkPoolEnd{}; + template T* set_ion_secure_cma_shrink_pool_end() { + return BeginNestedMessage(296); + } + + + using FieldMetadata_IonSecureCmaShrinkPoolStart = + ::protozero::proto_utils::FieldMetadata< + 297, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + IonSecureCmaShrinkPoolStartFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_IonSecureCmaShrinkPoolStart kIonSecureCmaShrinkPoolStart{}; + template T* set_ion_secure_cma_shrink_pool_start() { + return BeginNestedMessage(297); + } + + + using FieldMetadata_Kfree = + ::protozero::proto_utils::FieldMetadata< + 298, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + KfreeFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Kfree kKfree{}; + template T* set_kfree() { + return BeginNestedMessage(298); + } + + + using FieldMetadata_Kmalloc = + ::protozero::proto_utils::FieldMetadata< + 299, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + KmallocFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Kmalloc kKmalloc{}; + template T* set_kmalloc() { + return BeginNestedMessage(299); + } + + + using FieldMetadata_KmallocNode = + ::protozero::proto_utils::FieldMetadata< + 300, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + KmallocNodeFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_KmallocNode kKmallocNode{}; + template T* set_kmalloc_node() { + return BeginNestedMessage(300); + } + + + using FieldMetadata_KmemCacheAlloc = + ::protozero::proto_utils::FieldMetadata< + 301, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + KmemCacheAllocFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_KmemCacheAlloc kKmemCacheAlloc{}; + template T* set_kmem_cache_alloc() { + return BeginNestedMessage(301); + } + + + using FieldMetadata_KmemCacheAllocNode = + ::protozero::proto_utils::FieldMetadata< + 302, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + KmemCacheAllocNodeFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_KmemCacheAllocNode kKmemCacheAllocNode{}; + template T* set_kmem_cache_alloc_node() { + return BeginNestedMessage(302); + } + + + using FieldMetadata_KmemCacheFree = + ::protozero::proto_utils::FieldMetadata< + 303, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + KmemCacheFreeFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_KmemCacheFree kKmemCacheFree{}; + template T* set_kmem_cache_free() { + return BeginNestedMessage(303); + } + + + using FieldMetadata_MigratePagesEnd = + ::protozero::proto_utils::FieldMetadata< + 304, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MigratePagesEndFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_MigratePagesEnd kMigratePagesEnd{}; + template T* set_migrate_pages_end() { + return BeginNestedMessage(304); + } + + + using FieldMetadata_MigratePagesStart = + ::protozero::proto_utils::FieldMetadata< + 305, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MigratePagesStartFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_MigratePagesStart kMigratePagesStart{}; + template T* set_migrate_pages_start() { + return BeginNestedMessage(305); + } + + + using FieldMetadata_MigrateRetry = + ::protozero::proto_utils::FieldMetadata< + 306, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MigrateRetryFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_MigrateRetry kMigrateRetry{}; + template T* set_migrate_retry() { + return BeginNestedMessage(306); + } + + + using FieldMetadata_MmPageAlloc = + ::protozero::proto_utils::FieldMetadata< + 307, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MmPageAllocFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_MmPageAlloc kMmPageAlloc{}; + template T* set_mm_page_alloc() { + return BeginNestedMessage(307); + } + + + using FieldMetadata_MmPageAllocExtfrag = + ::protozero::proto_utils::FieldMetadata< + 308, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MmPageAllocExtfragFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_MmPageAllocExtfrag kMmPageAllocExtfrag{}; + template T* set_mm_page_alloc_extfrag() { + return BeginNestedMessage(308); + } + + + using FieldMetadata_MmPageAllocZoneLocked = + ::protozero::proto_utils::FieldMetadata< + 309, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MmPageAllocZoneLockedFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_MmPageAllocZoneLocked kMmPageAllocZoneLocked{}; + template T* set_mm_page_alloc_zone_locked() { + return BeginNestedMessage(309); + } + + + using FieldMetadata_MmPageFree = + ::protozero::proto_utils::FieldMetadata< + 310, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MmPageFreeFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_MmPageFree kMmPageFree{}; + template T* set_mm_page_free() { + return BeginNestedMessage(310); + } + + + using FieldMetadata_MmPageFreeBatched = + ::protozero::proto_utils::FieldMetadata< + 311, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MmPageFreeBatchedFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_MmPageFreeBatched kMmPageFreeBatched{}; + template T* set_mm_page_free_batched() { + return BeginNestedMessage(311); + } + + + using FieldMetadata_MmPagePcpuDrain = + ::protozero::proto_utils::FieldMetadata< + 312, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MmPagePcpuDrainFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_MmPagePcpuDrain kMmPagePcpuDrain{}; + template T* set_mm_page_pcpu_drain() { + return BeginNestedMessage(312); + } + + + using FieldMetadata_RssStat = + ::protozero::proto_utils::FieldMetadata< + 313, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + RssStatFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_RssStat kRssStat{}; + template T* set_rss_stat() { + return BeginNestedMessage(313); + } + + + using FieldMetadata_IonHeapShrink = + ::protozero::proto_utils::FieldMetadata< + 314, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + IonHeapShrinkFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_IonHeapShrink kIonHeapShrink{}; + template T* set_ion_heap_shrink() { + return BeginNestedMessage(314); + } + + + using FieldMetadata_IonHeapGrow = + ::protozero::proto_utils::FieldMetadata< + 315, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + IonHeapGrowFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_IonHeapGrow kIonHeapGrow{}; + template T* set_ion_heap_grow() { + return BeginNestedMessage(315); + } + + + using FieldMetadata_FenceInit = + ::protozero::proto_utils::FieldMetadata< + 316, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + FenceInitFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_FenceInit kFenceInit{}; + template T* set_fence_init() { + return BeginNestedMessage(316); + } + + + using FieldMetadata_FenceDestroy = + ::protozero::proto_utils::FieldMetadata< + 317, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + FenceDestroyFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_FenceDestroy kFenceDestroy{}; + template T* set_fence_destroy() { + return BeginNestedMessage(317); + } + + + using FieldMetadata_FenceEnableSignal = + ::protozero::proto_utils::FieldMetadata< + 318, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + FenceEnableSignalFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_FenceEnableSignal kFenceEnableSignal{}; + template T* set_fence_enable_signal() { + return BeginNestedMessage(318); + } + + + using FieldMetadata_FenceSignaled = + ::protozero::proto_utils::FieldMetadata< + 319, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + FenceSignaledFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_FenceSignaled kFenceSignaled{}; + template T* set_fence_signaled() { + return BeginNestedMessage(319); + } + + + using FieldMetadata_ClkEnable = + ::protozero::proto_utils::FieldMetadata< + 320, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ClkEnableFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_ClkEnable kClkEnable{}; + template T* set_clk_enable() { + return BeginNestedMessage(320); + } + + + using FieldMetadata_ClkDisable = + ::protozero::proto_utils::FieldMetadata< + 321, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ClkDisableFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_ClkDisable kClkDisable{}; + template T* set_clk_disable() { + return BeginNestedMessage(321); + } + + + using FieldMetadata_ClkSetRate = + ::protozero::proto_utils::FieldMetadata< + 322, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ClkSetRateFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_ClkSetRate kClkSetRate{}; + template T* set_clk_set_rate() { + return BeginNestedMessage(322); + } + + + using FieldMetadata_BinderTransactionAllocBuf = + ::protozero::proto_utils::FieldMetadata< + 323, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + BinderTransactionAllocBufFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_BinderTransactionAllocBuf kBinderTransactionAllocBuf{}; + template T* set_binder_transaction_alloc_buf() { + return BeginNestedMessage(323); + } + + + using FieldMetadata_SignalDeliver = + ::protozero::proto_utils::FieldMetadata< + 324, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + SignalDeliverFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_SignalDeliver kSignalDeliver{}; + template T* set_signal_deliver() { + return BeginNestedMessage(324); + } + + + using FieldMetadata_SignalGenerate = + ::protozero::proto_utils::FieldMetadata< + 325, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + SignalGenerateFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_SignalGenerate kSignalGenerate{}; + template T* set_signal_generate() { + return BeginNestedMessage(325); + } + + + using FieldMetadata_OomScoreAdjUpdate = + ::protozero::proto_utils::FieldMetadata< + 326, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + OomScoreAdjUpdateFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_OomScoreAdjUpdate kOomScoreAdjUpdate{}; + template T* set_oom_score_adj_update() { + return BeginNestedMessage(326); + } + + + using FieldMetadata_Generic = + ::protozero::proto_utils::FieldMetadata< + 327, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + GenericFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Generic kGeneric{}; + template T* set_generic() { + return BeginNestedMessage(327); + } + + + using FieldMetadata_MmEventRecord = + ::protozero::proto_utils::FieldMetadata< + 328, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MmEventRecordFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_MmEventRecord kMmEventRecord{}; + template T* set_mm_event_record() { + return BeginNestedMessage(328); + } + + + using FieldMetadata_SysEnter = + ::protozero::proto_utils::FieldMetadata< + 329, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + SysEnterFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_SysEnter kSysEnter{}; + template T* set_sys_enter() { + return BeginNestedMessage(329); + } + + + using FieldMetadata_SysExit = + ::protozero::proto_utils::FieldMetadata< + 330, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + SysExitFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_SysExit kSysExit{}; + template T* set_sys_exit() { + return BeginNestedMessage(330); + } + + + using FieldMetadata_Zero = + ::protozero::proto_utils::FieldMetadata< + 331, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ZeroFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Zero kZero{}; + template T* set_zero() { + return BeginNestedMessage(331); + } + + + using FieldMetadata_GpuFrequency = + ::protozero::proto_utils::FieldMetadata< + 332, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + GpuFrequencyFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_GpuFrequency kGpuFrequency{}; + template T* set_gpu_frequency() { + return BeginNestedMessage(332); + } + + + using FieldMetadata_SdeTracingMarkWrite = + ::protozero::proto_utils::FieldMetadata< + 333, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + SdeTracingMarkWriteFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_SdeTracingMarkWrite kSdeTracingMarkWrite{}; + template T* set_sde_tracing_mark_write() { + return BeginNestedMessage(333); + } + + + using FieldMetadata_MarkVictim = + ::protozero::proto_utils::FieldMetadata< + 334, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MarkVictimFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_MarkVictim kMarkVictim{}; + template T* set_mark_victim() { + return BeginNestedMessage(334); + } + + + using FieldMetadata_IonStat = + ::protozero::proto_utils::FieldMetadata< + 335, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + IonStatFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_IonStat kIonStat{}; + template T* set_ion_stat() { + return BeginNestedMessage(335); + } + + + using FieldMetadata_IonBufferCreate = + ::protozero::proto_utils::FieldMetadata< + 336, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + IonBufferCreateFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_IonBufferCreate kIonBufferCreate{}; + template T* set_ion_buffer_create() { + return BeginNestedMessage(336); + } + + + using FieldMetadata_IonBufferDestroy = + ::protozero::proto_utils::FieldMetadata< + 337, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + IonBufferDestroyFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_IonBufferDestroy kIonBufferDestroy{}; + template T* set_ion_buffer_destroy() { + return BeginNestedMessage(337); + } + + + using FieldMetadata_ScmCallStart = + ::protozero::proto_utils::FieldMetadata< + 338, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ScmCallStartFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_ScmCallStart kScmCallStart{}; + template T* set_scm_call_start() { + return BeginNestedMessage(338); + } + + + using FieldMetadata_ScmCallEnd = + ::protozero::proto_utils::FieldMetadata< + 339, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ScmCallEndFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_ScmCallEnd kScmCallEnd{}; + template T* set_scm_call_end() { + return BeginNestedMessage(339); + } + + + using FieldMetadata_GpuMemTotal = + ::protozero::proto_utils::FieldMetadata< + 340, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + GpuMemTotalFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_GpuMemTotal kGpuMemTotal{}; + template T* set_gpu_mem_total() { + return BeginNestedMessage(340); + } + + + using FieldMetadata_ThermalTemperature = + ::protozero::proto_utils::FieldMetadata< + 341, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ThermalTemperatureFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_ThermalTemperature kThermalTemperature{}; + template T* set_thermal_temperature() { + return BeginNestedMessage(341); + } + + + using FieldMetadata_CdevUpdate = + ::protozero::proto_utils::FieldMetadata< + 342, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + CdevUpdateFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_CdevUpdate kCdevUpdate{}; + template T* set_cdev_update() { + return BeginNestedMessage(342); + } + + + using FieldMetadata_CpuhpExit = + ::protozero::proto_utils::FieldMetadata< + 343, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + CpuhpExitFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_CpuhpExit kCpuhpExit{}; + template T* set_cpuhp_exit() { + return BeginNestedMessage(343); + } + + + using FieldMetadata_CpuhpMultiEnter = + ::protozero::proto_utils::FieldMetadata< + 344, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + CpuhpMultiEnterFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_CpuhpMultiEnter kCpuhpMultiEnter{}; + template T* set_cpuhp_multi_enter() { + return BeginNestedMessage(344); + } + + + using FieldMetadata_CpuhpEnter = + ::protozero::proto_utils::FieldMetadata< + 345, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + CpuhpEnterFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_CpuhpEnter kCpuhpEnter{}; + template T* set_cpuhp_enter() { + return BeginNestedMessage(345); + } + + + using FieldMetadata_CpuhpLatency = + ::protozero::proto_utils::FieldMetadata< + 346, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + CpuhpLatencyFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_CpuhpLatency kCpuhpLatency{}; + template T* set_cpuhp_latency() { + return BeginNestedMessage(346); + } + + + using FieldMetadata_FastrpcDmaStat = + ::protozero::proto_utils::FieldMetadata< + 347, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + FastrpcDmaStatFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_FastrpcDmaStat kFastrpcDmaStat{}; + template T* set_fastrpc_dma_stat() { + return BeginNestedMessage(347); + } + + + using FieldMetadata_DpuTracingMarkWrite = + ::protozero::proto_utils::FieldMetadata< + 348, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + DpuTracingMarkWriteFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_DpuTracingMarkWrite kDpuTracingMarkWrite{}; + template T* set_dpu_tracing_mark_write() { + return BeginNestedMessage(348); + } + + + using FieldMetadata_G2dTracingMarkWrite = + ::protozero::proto_utils::FieldMetadata< + 349, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + G2dTracingMarkWriteFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_G2dTracingMarkWrite kG2dTracingMarkWrite{}; + template T* set_g2d_tracing_mark_write() { + return BeginNestedMessage(349); + } + + + using FieldMetadata_MaliTracingMarkWrite = + ::protozero::proto_utils::FieldMetadata< + 350, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MaliTracingMarkWriteFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_MaliTracingMarkWrite kMaliTracingMarkWrite{}; + template T* set_mali_tracing_mark_write() { + return BeginNestedMessage(350); + } + + + using FieldMetadata_DmaHeapStat = + ::protozero::proto_utils::FieldMetadata< + 351, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + DmaHeapStatFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_DmaHeapStat kDmaHeapStat{}; + template T* set_dma_heap_stat() { + return BeginNestedMessage(351); + } + + + using FieldMetadata_CpuhpPause = + ::protozero::proto_utils::FieldMetadata< + 352, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + CpuhpPauseFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_CpuhpPause kCpuhpPause{}; + template T* set_cpuhp_pause() { + return BeginNestedMessage(352); + } + + + using FieldMetadata_SchedPiSetprio = + ::protozero::proto_utils::FieldMetadata< + 353, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + SchedPiSetprioFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_SchedPiSetprio kSchedPiSetprio{}; + template T* set_sched_pi_setprio() { + return BeginNestedMessage(353); + } + + + using FieldMetadata_SdeSdeEvtlog = + ::protozero::proto_utils::FieldMetadata< + 354, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + SdeSdeEvtlogFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_SdeSdeEvtlog kSdeSdeEvtlog{}; + template T* set_sde_sde_evtlog() { + return BeginNestedMessage(354); + } + + + using FieldMetadata_SdeSdePerfCalcCrtc = + ::protozero::proto_utils::FieldMetadata< + 355, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + SdeSdePerfCalcCrtcFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_SdeSdePerfCalcCrtc kSdeSdePerfCalcCrtc{}; + template T* set_sde_sde_perf_calc_crtc() { + return BeginNestedMessage(355); + } + + + using FieldMetadata_SdeSdePerfCrtcUpdate = + ::protozero::proto_utils::FieldMetadata< + 356, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + SdeSdePerfCrtcUpdateFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_SdeSdePerfCrtcUpdate kSdeSdePerfCrtcUpdate{}; + template T* set_sde_sde_perf_crtc_update() { + return BeginNestedMessage(356); + } + + + using FieldMetadata_SdeSdePerfSetQosLuts = + ::protozero::proto_utils::FieldMetadata< + 357, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + SdeSdePerfSetQosLutsFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_SdeSdePerfSetQosLuts kSdeSdePerfSetQosLuts{}; + template T* set_sde_sde_perf_set_qos_luts() { + return BeginNestedMessage(357); + } + + + using FieldMetadata_SdeSdePerfUpdateBus = + ::protozero::proto_utils::FieldMetadata< + 358, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + SdeSdePerfUpdateBusFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_SdeSdePerfUpdateBus kSdeSdePerfUpdateBus{}; + template T* set_sde_sde_perf_update_bus() { + return BeginNestedMessage(358); + } + + + using FieldMetadata_RssStatThrottled = + ::protozero::proto_utils::FieldMetadata< + 359, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + RssStatThrottledFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_RssStatThrottled kRssStatThrottled{}; + template T* set_rss_stat_throttled() { + return BeginNestedMessage(359); + } + + + using FieldMetadata_NetifReceiveSkb = + ::protozero::proto_utils::FieldMetadata< + 360, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + NetifReceiveSkbFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_NetifReceiveSkb kNetifReceiveSkb{}; + template T* set_netif_receive_skb() { + return BeginNestedMessage(360); + } + + + using FieldMetadata_NetDevXmit = + ::protozero::proto_utils::FieldMetadata< + 361, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + NetDevXmitFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_NetDevXmit kNetDevXmit{}; + template T* set_net_dev_xmit() { + return BeginNestedMessage(361); + } + + + using FieldMetadata_InetSockSetState = + ::protozero::proto_utils::FieldMetadata< + 362, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + InetSockSetStateFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_InetSockSetState kInetSockSetState{}; + template T* set_inet_sock_set_state() { + return BeginNestedMessage(362); + } + + + using FieldMetadata_TcpRetransmitSkb = + ::protozero::proto_utils::FieldMetadata< + 363, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TcpRetransmitSkbFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_TcpRetransmitSkb kTcpRetransmitSkb{}; + template T* set_tcp_retransmit_skb() { + return BeginNestedMessage(363); + } + + + using FieldMetadata_CrosEcSensorhubData = + ::protozero::proto_utils::FieldMetadata< + 364, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + CrosEcSensorhubDataFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_CrosEcSensorhubData kCrosEcSensorhubData{}; + template T* set_cros_ec_sensorhub_data() { + return BeginNestedMessage(364); + } + + + using FieldMetadata_NapiGroReceiveEntry = + ::protozero::proto_utils::FieldMetadata< + 365, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + NapiGroReceiveEntryFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_NapiGroReceiveEntry kNapiGroReceiveEntry{}; + template T* set_napi_gro_receive_entry() { + return BeginNestedMessage(365); + } + + + using FieldMetadata_NapiGroReceiveExit = + ::protozero::proto_utils::FieldMetadata< + 366, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + NapiGroReceiveExitFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_NapiGroReceiveExit kNapiGroReceiveExit{}; + template T* set_napi_gro_receive_exit() { + return BeginNestedMessage(366); + } + + + using FieldMetadata_KfreeSkb = + ::protozero::proto_utils::FieldMetadata< + 367, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + KfreeSkbFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_KfreeSkb kKfreeSkb{}; + template T* set_kfree_skb() { + return BeginNestedMessage(367); + } + + + using FieldMetadata_KvmAccessFault = + ::protozero::proto_utils::FieldMetadata< + 368, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + KvmAccessFaultFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_KvmAccessFault kKvmAccessFault{}; + template T* set_kvm_access_fault() { + return BeginNestedMessage(368); + } + + + using FieldMetadata_KvmAckIrq = + ::protozero::proto_utils::FieldMetadata< + 369, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + KvmAckIrqFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_KvmAckIrq kKvmAckIrq{}; + template T* set_kvm_ack_irq() { + return BeginNestedMessage(369); + } + + + using FieldMetadata_KvmAgeHva = + ::protozero::proto_utils::FieldMetadata< + 370, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + KvmAgeHvaFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_KvmAgeHva kKvmAgeHva{}; + template T* set_kvm_age_hva() { + return BeginNestedMessage(370); + } + + + using FieldMetadata_KvmAgePage = + ::protozero::proto_utils::FieldMetadata< + 371, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + KvmAgePageFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_KvmAgePage kKvmAgePage{}; + template T* set_kvm_age_page() { + return BeginNestedMessage(371); + } + + + using FieldMetadata_KvmArmClearDebug = + ::protozero::proto_utils::FieldMetadata< + 372, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + KvmArmClearDebugFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_KvmArmClearDebug kKvmArmClearDebug{}; + template T* set_kvm_arm_clear_debug() { + return BeginNestedMessage(372); + } + + + using FieldMetadata_KvmArmSetDreg32 = + ::protozero::proto_utils::FieldMetadata< + 373, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + KvmArmSetDreg32FtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_KvmArmSetDreg32 kKvmArmSetDreg32{}; + template T* set_kvm_arm_set_dreg32() { + return BeginNestedMessage(373); + } + + + using FieldMetadata_KvmArmSetRegset = + ::protozero::proto_utils::FieldMetadata< + 374, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + KvmArmSetRegsetFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_KvmArmSetRegset kKvmArmSetRegset{}; + template T* set_kvm_arm_set_regset() { + return BeginNestedMessage(374); + } + + + using FieldMetadata_KvmArmSetupDebug = + ::protozero::proto_utils::FieldMetadata< + 375, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + KvmArmSetupDebugFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_KvmArmSetupDebug kKvmArmSetupDebug{}; + template T* set_kvm_arm_setup_debug() { + return BeginNestedMessage(375); + } + + + using FieldMetadata_KvmEntry = + ::protozero::proto_utils::FieldMetadata< + 376, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + KvmEntryFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_KvmEntry kKvmEntry{}; + template T* set_kvm_entry() { + return BeginNestedMessage(376); + } + + + using FieldMetadata_KvmExit = + ::protozero::proto_utils::FieldMetadata< + 377, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + KvmExitFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_KvmExit kKvmExit{}; + template T* set_kvm_exit() { + return BeginNestedMessage(377); + } + + + using FieldMetadata_KvmFpu = + ::protozero::proto_utils::FieldMetadata< + 378, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + KvmFpuFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_KvmFpu kKvmFpu{}; + template T* set_kvm_fpu() { + return BeginNestedMessage(378); + } + + + using FieldMetadata_KvmGetTimerMap = + ::protozero::proto_utils::FieldMetadata< + 379, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + KvmGetTimerMapFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_KvmGetTimerMap kKvmGetTimerMap{}; + template T* set_kvm_get_timer_map() { + return BeginNestedMessage(379); + } + + + using FieldMetadata_KvmGuestFault = + ::protozero::proto_utils::FieldMetadata< + 380, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + KvmGuestFaultFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_KvmGuestFault kKvmGuestFault{}; + template T* set_kvm_guest_fault() { + return BeginNestedMessage(380); + } + + + using FieldMetadata_KvmHandleSysReg = + ::protozero::proto_utils::FieldMetadata< + 381, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + KvmHandleSysRegFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_KvmHandleSysReg kKvmHandleSysReg{}; + template T* set_kvm_handle_sys_reg() { + return BeginNestedMessage(381); + } + + + using FieldMetadata_KvmHvcArm64 = + ::protozero::proto_utils::FieldMetadata< + 382, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + KvmHvcArm64FtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_KvmHvcArm64 kKvmHvcArm64{}; + template T* set_kvm_hvc_arm64() { + return BeginNestedMessage(382); + } + + + using FieldMetadata_KvmIrqLine = + ::protozero::proto_utils::FieldMetadata< + 383, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + KvmIrqLineFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_KvmIrqLine kKvmIrqLine{}; + template T* set_kvm_irq_line() { + return BeginNestedMessage(383); + } + + + using FieldMetadata_KvmMmio = + ::protozero::proto_utils::FieldMetadata< + 384, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + KvmMmioFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_KvmMmio kKvmMmio{}; + template T* set_kvm_mmio() { + return BeginNestedMessage(384); + } + + + using FieldMetadata_KvmMmioEmulate = + ::protozero::proto_utils::FieldMetadata< + 385, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + KvmMmioEmulateFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_KvmMmioEmulate kKvmMmioEmulate{}; + template T* set_kvm_mmio_emulate() { + return BeginNestedMessage(385); + } + + + using FieldMetadata_KvmSetGuestDebug = + ::protozero::proto_utils::FieldMetadata< + 386, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + KvmSetGuestDebugFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_KvmSetGuestDebug kKvmSetGuestDebug{}; + template T* set_kvm_set_guest_debug() { + return BeginNestedMessage(386); + } + + + using FieldMetadata_KvmSetIrq = + ::protozero::proto_utils::FieldMetadata< + 387, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + KvmSetIrqFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_KvmSetIrq kKvmSetIrq{}; + template T* set_kvm_set_irq() { + return BeginNestedMessage(387); + } + + + using FieldMetadata_KvmSetSpteHva = + ::protozero::proto_utils::FieldMetadata< + 388, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + KvmSetSpteHvaFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_KvmSetSpteHva kKvmSetSpteHva{}; + template T* set_kvm_set_spte_hva() { + return BeginNestedMessage(388); + } + + + using FieldMetadata_KvmSetWayFlush = + ::protozero::proto_utils::FieldMetadata< + 389, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + KvmSetWayFlushFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_KvmSetWayFlush kKvmSetWayFlush{}; + template T* set_kvm_set_way_flush() { + return BeginNestedMessage(389); + } + + + using FieldMetadata_KvmSysAccess = + ::protozero::proto_utils::FieldMetadata< + 390, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + KvmSysAccessFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_KvmSysAccess kKvmSysAccess{}; + template T* set_kvm_sys_access() { + return BeginNestedMessage(390); + } + + + using FieldMetadata_KvmTestAgeHva = + ::protozero::proto_utils::FieldMetadata< + 391, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + KvmTestAgeHvaFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_KvmTestAgeHva kKvmTestAgeHva{}; + template T* set_kvm_test_age_hva() { + return BeginNestedMessage(391); + } + + + using FieldMetadata_KvmTimerEmulate = + ::protozero::proto_utils::FieldMetadata< + 392, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + KvmTimerEmulateFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_KvmTimerEmulate kKvmTimerEmulate{}; + template T* set_kvm_timer_emulate() { + return BeginNestedMessage(392); + } + + + using FieldMetadata_KvmTimerHrtimerExpire = + ::protozero::proto_utils::FieldMetadata< + 393, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + KvmTimerHrtimerExpireFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_KvmTimerHrtimerExpire kKvmTimerHrtimerExpire{}; + template T* set_kvm_timer_hrtimer_expire() { + return BeginNestedMessage(393); + } + + + using FieldMetadata_KvmTimerRestoreState = + ::protozero::proto_utils::FieldMetadata< + 394, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + KvmTimerRestoreStateFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_KvmTimerRestoreState kKvmTimerRestoreState{}; + template T* set_kvm_timer_restore_state() { + return BeginNestedMessage(394); + } + + + using FieldMetadata_KvmTimerSaveState = + ::protozero::proto_utils::FieldMetadata< + 395, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + KvmTimerSaveStateFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_KvmTimerSaveState kKvmTimerSaveState{}; + template T* set_kvm_timer_save_state() { + return BeginNestedMessage(395); + } + + + using FieldMetadata_KvmTimerUpdateIrq = + ::protozero::proto_utils::FieldMetadata< + 396, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + KvmTimerUpdateIrqFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_KvmTimerUpdateIrq kKvmTimerUpdateIrq{}; + template T* set_kvm_timer_update_irq() { + return BeginNestedMessage(396); + } + + + using FieldMetadata_KvmToggleCache = + ::protozero::proto_utils::FieldMetadata< + 397, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + KvmToggleCacheFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_KvmToggleCache kKvmToggleCache{}; + template T* set_kvm_toggle_cache() { + return BeginNestedMessage(397); + } + + + using FieldMetadata_KvmUnmapHvaRange = + ::protozero::proto_utils::FieldMetadata< + 398, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + KvmUnmapHvaRangeFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_KvmUnmapHvaRange kKvmUnmapHvaRange{}; + template T* set_kvm_unmap_hva_range() { + return BeginNestedMessage(398); + } + + + using FieldMetadata_KvmUserspaceExit = + ::protozero::proto_utils::FieldMetadata< + 399, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + KvmUserspaceExitFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_KvmUserspaceExit kKvmUserspaceExit{}; + template T* set_kvm_userspace_exit() { + return BeginNestedMessage(399); + } + + + using FieldMetadata_KvmVcpuWakeup = + ::protozero::proto_utils::FieldMetadata< + 400, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + KvmVcpuWakeupFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_KvmVcpuWakeup kKvmVcpuWakeup{}; + template T* set_kvm_vcpu_wakeup() { + return BeginNestedMessage(400); + } + + + using FieldMetadata_KvmWfxArm64 = + ::protozero::proto_utils::FieldMetadata< + 401, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + KvmWfxArm64FtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_KvmWfxArm64 kKvmWfxArm64{}; + template T* set_kvm_wfx_arm64() { + return BeginNestedMessage(401); + } + + + using FieldMetadata_TrapReg = + ::protozero::proto_utils::FieldMetadata< + 402, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TrapRegFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_TrapReg kTrapReg{}; + template T* set_trap_reg() { + return BeginNestedMessage(402); + } + + + using FieldMetadata_VgicUpdateIrqPending = + ::protozero::proto_utils::FieldMetadata< + 403, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + VgicUpdateIrqPendingFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_VgicUpdateIrqPending kVgicUpdateIrqPending{}; + template T* set_vgic_update_irq_pending() { + return BeginNestedMessage(403); + } + + + using FieldMetadata_WakeupSourceActivate = + ::protozero::proto_utils::FieldMetadata< + 404, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + WakeupSourceActivateFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_WakeupSourceActivate kWakeupSourceActivate{}; + template T* set_wakeup_source_activate() { + return BeginNestedMessage(404); + } + + + using FieldMetadata_WakeupSourceDeactivate = + ::protozero::proto_utils::FieldMetadata< + 405, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + WakeupSourceDeactivateFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_WakeupSourceDeactivate kWakeupSourceDeactivate{}; + template T* set_wakeup_source_deactivate() { + return BeginNestedMessage(405); + } + + + using FieldMetadata_UfshcdCommand = + ::protozero::proto_utils::FieldMetadata< + 406, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + UfshcdCommandFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_UfshcdCommand kUfshcdCommand{}; + template T* set_ufshcd_command() { + return BeginNestedMessage(406); + } + + + using FieldMetadata_UfshcdClkGating = + ::protozero::proto_utils::FieldMetadata< + 407, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + UfshcdClkGatingFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_UfshcdClkGating kUfshcdClkGating{}; + template T* set_ufshcd_clk_gating() { + return BeginNestedMessage(407); + } + + + using FieldMetadata_Console = + ::protozero::proto_utils::FieldMetadata< + 408, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ConsoleFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Console kConsole{}; + template T* set_console() { + return BeginNestedMessage(408); + } + + + using FieldMetadata_DrmVblankEvent = + ::protozero::proto_utils::FieldMetadata< + 409, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + DrmVblankEventFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_DrmVblankEvent kDrmVblankEvent{}; + template T* set_drm_vblank_event() { + return BeginNestedMessage(409); + } + + + using FieldMetadata_DrmVblankEventDelivered = + ::protozero::proto_utils::FieldMetadata< + 410, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + DrmVblankEventDeliveredFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_DrmVblankEventDelivered kDrmVblankEventDelivered{}; + template T* set_drm_vblank_event_delivered() { + return BeginNestedMessage(410); + } + + + using FieldMetadata_DrmSchedJob = + ::protozero::proto_utils::FieldMetadata< + 411, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + DrmSchedJobFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_DrmSchedJob kDrmSchedJob{}; + template T* set_drm_sched_job() { + return BeginNestedMessage(411); + } + + + using FieldMetadata_DrmRunJob = + ::protozero::proto_utils::FieldMetadata< + 412, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + DrmRunJobFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_DrmRunJob kDrmRunJob{}; + template T* set_drm_run_job() { + return BeginNestedMessage(412); + } + + + using FieldMetadata_DrmSchedProcessJob = + ::protozero::proto_utils::FieldMetadata< + 413, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + DrmSchedProcessJobFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_DrmSchedProcessJob kDrmSchedProcessJob{}; + template T* set_drm_sched_process_job() { + return BeginNestedMessage(413); + } + + + using FieldMetadata_DmaFenceInit = + ::protozero::proto_utils::FieldMetadata< + 414, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + DmaFenceInitFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_DmaFenceInit kDmaFenceInit{}; + template T* set_dma_fence_init() { + return BeginNestedMessage(414); + } + + + using FieldMetadata_DmaFenceEmit = + ::protozero::proto_utils::FieldMetadata< + 415, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + DmaFenceEmitFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_DmaFenceEmit kDmaFenceEmit{}; + template T* set_dma_fence_emit() { + return BeginNestedMessage(415); + } + + + using FieldMetadata_DmaFenceSignaled = + ::protozero::proto_utils::FieldMetadata< + 416, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + DmaFenceSignaledFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_DmaFenceSignaled kDmaFenceSignaled{}; + template T* set_dma_fence_signaled() { + return BeginNestedMessage(416); + } + + + using FieldMetadata_DmaFenceWaitStart = + ::protozero::proto_utils::FieldMetadata< + 417, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + DmaFenceWaitStartFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_DmaFenceWaitStart kDmaFenceWaitStart{}; + template T* set_dma_fence_wait_start() { + return BeginNestedMessage(417); + } + + + using FieldMetadata_DmaFenceWaitEnd = + ::protozero::proto_utils::FieldMetadata< + 418, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + DmaFenceWaitEndFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_DmaFenceWaitEnd kDmaFenceWaitEnd{}; + template T* set_dma_fence_wait_end() { + return BeginNestedMessage(418); + } + + + using FieldMetadata_F2fsIostat = + ::protozero::proto_utils::FieldMetadata< + 419, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + F2fsIostatFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_F2fsIostat kF2fsIostat{}; + template T* set_f2fs_iostat() { + return BeginNestedMessage(419); + } + + + using FieldMetadata_F2fsIostatLatency = + ::protozero::proto_utils::FieldMetadata< + 420, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + F2fsIostatLatencyFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_F2fsIostatLatency kF2fsIostatLatency{}; + template T* set_f2fs_iostat_latency() { + return BeginNestedMessage(420); + } + + + using FieldMetadata_SchedCpuUtilCfs = + ::protozero::proto_utils::FieldMetadata< + 421, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + SchedCpuUtilCfsFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_SchedCpuUtilCfs kSchedCpuUtilCfs{}; + template T* set_sched_cpu_util_cfs() { + return BeginNestedMessage(421); + } + + + using FieldMetadata_V4l2Qbuf = + ::protozero::proto_utils::FieldMetadata< + 422, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + V4l2QbufFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_V4l2Qbuf kV4l2Qbuf{}; + template T* set_v4l2_qbuf() { + return BeginNestedMessage(422); + } + + + using FieldMetadata_V4l2Dqbuf = + ::protozero::proto_utils::FieldMetadata< + 423, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + V4l2DqbufFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_V4l2Dqbuf kV4l2Dqbuf{}; + template T* set_v4l2_dqbuf() { + return BeginNestedMessage(423); + } + + + using FieldMetadata_Vb2V4l2BufQueue = + ::protozero::proto_utils::FieldMetadata< + 424, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Vb2V4l2BufQueueFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Vb2V4l2BufQueue kVb2V4l2BufQueue{}; + template T* set_vb2_v4l2_buf_queue() { + return BeginNestedMessage(424); + } + + + using FieldMetadata_Vb2V4l2BufDone = + ::protozero::proto_utils::FieldMetadata< + 425, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Vb2V4l2BufDoneFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Vb2V4l2BufDone kVb2V4l2BufDone{}; + template T* set_vb2_v4l2_buf_done() { + return BeginNestedMessage(425); + } + + + using FieldMetadata_Vb2V4l2Qbuf = + ::protozero::proto_utils::FieldMetadata< + 426, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Vb2V4l2QbufFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Vb2V4l2Qbuf kVb2V4l2Qbuf{}; + template T* set_vb2_v4l2_qbuf() { + return BeginNestedMessage(426); + } + + + using FieldMetadata_Vb2V4l2Dqbuf = + ::protozero::proto_utils::FieldMetadata< + 427, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Vb2V4l2DqbufFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_Vb2V4l2Dqbuf kVb2V4l2Dqbuf{}; + template T* set_vb2_v4l2_dqbuf() { + return BeginNestedMessage(427); + } + + + using FieldMetadata_DsiCmdFifoStatus = + ::protozero::proto_utils::FieldMetadata< + 428, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + DsiCmdFifoStatusFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_DsiCmdFifoStatus kDsiCmdFifoStatus{}; + template T* set_dsi_cmd_fifo_status() { + return BeginNestedMessage(428); + } + + + using FieldMetadata_DsiRx = + ::protozero::proto_utils::FieldMetadata< + 429, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + DsiRxFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_DsiRx kDsiRx{}; + template T* set_dsi_rx() { + return BeginNestedMessage(429); + } + + + using FieldMetadata_DsiTx = + ::protozero::proto_utils::FieldMetadata< + 430, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + DsiTxFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_DsiTx kDsiTx{}; + template T* set_dsi_tx() { + return BeginNestedMessage(430); + } + + + using FieldMetadata_AndroidFsDatareadEnd = + ::protozero::proto_utils::FieldMetadata< + 431, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + AndroidFsDatareadEndFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_AndroidFsDatareadEnd kAndroidFsDatareadEnd{}; + template T* set_android_fs_dataread_end() { + return BeginNestedMessage(431); + } + + + using FieldMetadata_AndroidFsDatareadStart = + ::protozero::proto_utils::FieldMetadata< + 432, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + AndroidFsDatareadStartFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_AndroidFsDatareadStart kAndroidFsDatareadStart{}; + template T* set_android_fs_dataread_start() { + return BeginNestedMessage(432); + } + + + using FieldMetadata_AndroidFsDatawriteEnd = + ::protozero::proto_utils::FieldMetadata< + 433, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + AndroidFsDatawriteEndFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_AndroidFsDatawriteEnd kAndroidFsDatawriteEnd{}; + template T* set_android_fs_datawrite_end() { + return BeginNestedMessage(433); + } + + + using FieldMetadata_AndroidFsDatawriteStart = + ::protozero::proto_utils::FieldMetadata< + 434, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + AndroidFsDatawriteStartFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_AndroidFsDatawriteStart kAndroidFsDatawriteStart{}; + template T* set_android_fs_datawrite_start() { + return BeginNestedMessage(434); + } + + + using FieldMetadata_AndroidFsFsyncEnd = + ::protozero::proto_utils::FieldMetadata< + 435, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + AndroidFsFsyncEndFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_AndroidFsFsyncEnd kAndroidFsFsyncEnd{}; + template T* set_android_fs_fsync_end() { + return BeginNestedMessage(435); + } + + + using FieldMetadata_AndroidFsFsyncStart = + ::protozero::proto_utils::FieldMetadata< + 436, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + AndroidFsFsyncStartFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_AndroidFsFsyncStart kAndroidFsFsyncStart{}; + template T* set_android_fs_fsync_start() { + return BeginNestedMessage(436); + } + + + using FieldMetadata_FuncgraphEntry = + ::protozero::proto_utils::FieldMetadata< + 437, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + FuncgraphEntryFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_FuncgraphEntry kFuncgraphEntry{}; + template T* set_funcgraph_entry() { + return BeginNestedMessage(437); + } + + + using FieldMetadata_FuncgraphExit = + ::protozero::proto_utils::FieldMetadata< + 438, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + FuncgraphExitFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_FuncgraphExit kFuncgraphExit{}; + template T* set_funcgraph_exit() { + return BeginNestedMessage(438); + } + + + using FieldMetadata_VirtioVideoCmd = + ::protozero::proto_utils::FieldMetadata< + 439, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + VirtioVideoCmdFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_VirtioVideoCmd kVirtioVideoCmd{}; + template T* set_virtio_video_cmd() { + return BeginNestedMessage(439); + } + + + using FieldMetadata_VirtioVideoCmdDone = + ::protozero::proto_utils::FieldMetadata< + 440, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + VirtioVideoCmdDoneFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_VirtioVideoCmdDone kVirtioVideoCmdDone{}; + template T* set_virtio_video_cmd_done() { + return BeginNestedMessage(440); + } + + + using FieldMetadata_VirtioVideoResourceQueue = + ::protozero::proto_utils::FieldMetadata< + 441, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + VirtioVideoResourceQueueFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_VirtioVideoResourceQueue kVirtioVideoResourceQueue{}; + template T* set_virtio_video_resource_queue() { + return BeginNestedMessage(441); + } + + + using FieldMetadata_VirtioVideoResourceQueueDone = + ::protozero::proto_utils::FieldMetadata< + 442, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + VirtioVideoResourceQueueDoneFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_VirtioVideoResourceQueueDone kVirtioVideoResourceQueueDone{}; + template T* set_virtio_video_resource_queue_done() { + return BeginNestedMessage(442); + } + + + using FieldMetadata_MmShrinkSlabStart = + ::protozero::proto_utils::FieldMetadata< + 443, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MmShrinkSlabStartFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_MmShrinkSlabStart kMmShrinkSlabStart{}; + template T* set_mm_shrink_slab_start() { + return BeginNestedMessage(443); + } + + + using FieldMetadata_MmShrinkSlabEnd = + ::protozero::proto_utils::FieldMetadata< + 444, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MmShrinkSlabEndFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_MmShrinkSlabEnd kMmShrinkSlabEnd{}; + template T* set_mm_shrink_slab_end() { + return BeginNestedMessage(444); + } + + + using FieldMetadata_TrustySmc = + ::protozero::proto_utils::FieldMetadata< + 445, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TrustySmcFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_TrustySmc kTrustySmc{}; + template T* set_trusty_smc() { + return BeginNestedMessage(445); + } + + + using FieldMetadata_TrustySmcDone = + ::protozero::proto_utils::FieldMetadata< + 446, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TrustySmcDoneFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_TrustySmcDone kTrustySmcDone{}; + template T* set_trusty_smc_done() { + return BeginNestedMessage(446); + } + + + using FieldMetadata_TrustyStdCall32 = + ::protozero::proto_utils::FieldMetadata< + 447, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TrustyStdCall32FtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_TrustyStdCall32 kTrustyStdCall32{}; + template T* set_trusty_std_call32() { + return BeginNestedMessage(447); + } + + + using FieldMetadata_TrustyStdCall32Done = + ::protozero::proto_utils::FieldMetadata< + 448, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TrustyStdCall32DoneFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_TrustyStdCall32Done kTrustyStdCall32Done{}; + template T* set_trusty_std_call32_done() { + return BeginNestedMessage(448); + } + + + using FieldMetadata_TrustyShareMemory = + ::protozero::proto_utils::FieldMetadata< + 449, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TrustyShareMemoryFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_TrustyShareMemory kTrustyShareMemory{}; + template T* set_trusty_share_memory() { + return BeginNestedMessage(449); + } + + + using FieldMetadata_TrustyShareMemoryDone = + ::protozero::proto_utils::FieldMetadata< + 450, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TrustyShareMemoryDoneFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_TrustyShareMemoryDone kTrustyShareMemoryDone{}; + template T* set_trusty_share_memory_done() { + return BeginNestedMessage(450); + } + + + using FieldMetadata_TrustyReclaimMemory = + ::protozero::proto_utils::FieldMetadata< + 451, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TrustyReclaimMemoryFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_TrustyReclaimMemory kTrustyReclaimMemory{}; + template T* set_trusty_reclaim_memory() { + return BeginNestedMessage(451); + } + + + using FieldMetadata_TrustyReclaimMemoryDone = + ::protozero::proto_utils::FieldMetadata< + 452, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TrustyReclaimMemoryDoneFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_TrustyReclaimMemoryDone kTrustyReclaimMemoryDone{}; + template T* set_trusty_reclaim_memory_done() { + return BeginNestedMessage(452); + } + + + using FieldMetadata_TrustyIrq = + ::protozero::proto_utils::FieldMetadata< + 453, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TrustyIrqFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_TrustyIrq kTrustyIrq{}; + template T* set_trusty_irq() { + return BeginNestedMessage(453); + } + + + using FieldMetadata_TrustyIpcHandleEvent = + ::protozero::proto_utils::FieldMetadata< + 454, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TrustyIpcHandleEventFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_TrustyIpcHandleEvent kTrustyIpcHandleEvent{}; + template T* set_trusty_ipc_handle_event() { + return BeginNestedMessage(454); + } + + + using FieldMetadata_TrustyIpcConnect = + ::protozero::proto_utils::FieldMetadata< + 455, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TrustyIpcConnectFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_TrustyIpcConnect kTrustyIpcConnect{}; + template T* set_trusty_ipc_connect() { + return BeginNestedMessage(455); + } + + + using FieldMetadata_TrustyIpcConnectEnd = + ::protozero::proto_utils::FieldMetadata< + 456, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TrustyIpcConnectEndFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_TrustyIpcConnectEnd kTrustyIpcConnectEnd{}; + template T* set_trusty_ipc_connect_end() { + return BeginNestedMessage(456); + } + + + using FieldMetadata_TrustyIpcWrite = + ::protozero::proto_utils::FieldMetadata< + 457, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TrustyIpcWriteFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_TrustyIpcWrite kTrustyIpcWrite{}; + template T* set_trusty_ipc_write() { + return BeginNestedMessage(457); + } + + + using FieldMetadata_TrustyIpcPoll = + ::protozero::proto_utils::FieldMetadata< + 458, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TrustyIpcPollFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_TrustyIpcPoll kTrustyIpcPoll{}; + template T* set_trusty_ipc_poll() { + return BeginNestedMessage(458); + } + + + using FieldMetadata_TrustyIpcRead = + ::protozero::proto_utils::FieldMetadata< + 460, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TrustyIpcReadFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_TrustyIpcRead kTrustyIpcRead{}; + template T* set_trusty_ipc_read() { + return BeginNestedMessage(460); + } + + + using FieldMetadata_TrustyIpcReadEnd = + ::protozero::proto_utils::FieldMetadata< + 461, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TrustyIpcReadEndFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_TrustyIpcReadEnd kTrustyIpcReadEnd{}; + template T* set_trusty_ipc_read_end() { + return BeginNestedMessage(461); + } + + + using FieldMetadata_TrustyIpcRx = + ::protozero::proto_utils::FieldMetadata< + 462, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TrustyIpcRxFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_TrustyIpcRx kTrustyIpcRx{}; + template T* set_trusty_ipc_rx() { + return BeginNestedMessage(462); + } + + + using FieldMetadata_TrustyEnqueueNop = + ::protozero::proto_utils::FieldMetadata< + 464, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TrustyEnqueueNopFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_TrustyEnqueueNop kTrustyEnqueueNop{}; + template T* set_trusty_enqueue_nop() { + return BeginNestedMessage(464); + } + + + using FieldMetadata_CmaAllocStart = + ::protozero::proto_utils::FieldMetadata< + 465, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + CmaAllocStartFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_CmaAllocStart kCmaAllocStart{}; + template T* set_cma_alloc_start() { + return BeginNestedMessage(465); + } + + + using FieldMetadata_CmaAllocInfo = + ::protozero::proto_utils::FieldMetadata< + 466, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + CmaAllocInfoFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_CmaAllocInfo kCmaAllocInfo{}; + template T* set_cma_alloc_info() { + return BeginNestedMessage(466); + } + + + using FieldMetadata_LwisTracingMarkWrite = + ::protozero::proto_utils::FieldMetadata< + 467, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + LwisTracingMarkWriteFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_LwisTracingMarkWrite kLwisTracingMarkWrite{}; + template T* set_lwis_tracing_mark_write() { + return BeginNestedMessage(467); + } + + + using FieldMetadata_VirtioGpuCmdQueue = + ::protozero::proto_utils::FieldMetadata< + 468, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + VirtioGpuCmdQueueFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_VirtioGpuCmdQueue kVirtioGpuCmdQueue{}; + template T* set_virtio_gpu_cmd_queue() { + return BeginNestedMessage(468); + } + + + using FieldMetadata_VirtioGpuCmdResponse = + ::protozero::proto_utils::FieldMetadata< + 469, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + VirtioGpuCmdResponseFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_VirtioGpuCmdResponse kVirtioGpuCmdResponse{}; + template T* set_virtio_gpu_cmd_response() { + return BeginNestedMessage(469); + } + + + using FieldMetadata_MaliMaliKCPUCQSSET = + ::protozero::proto_utils::FieldMetadata< + 470, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MaliMaliKCPUCQSSETFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_MaliMaliKCPUCQSSET kMaliMaliKCPUCQSSET{}; + template T* set_mali_mali_kcpu_cqs_set() { + return BeginNestedMessage(470); + } + + + using FieldMetadata_MaliMaliKCPUCQSWAITSTART = + ::protozero::proto_utils::FieldMetadata< + 471, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MaliMaliKCPUCQSWAITSTARTFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_MaliMaliKCPUCQSWAITSTART kMaliMaliKCPUCQSWAITSTART{}; + template T* set_mali_mali_kcpu_cqs_wait_start() { + return BeginNestedMessage(471); + } + + + using FieldMetadata_MaliMaliKCPUCQSWAITEND = + ::protozero::proto_utils::FieldMetadata< + 472, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MaliMaliKCPUCQSWAITENDFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_MaliMaliKCPUCQSWAITEND kMaliMaliKCPUCQSWAITEND{}; + template T* set_mali_mali_kcpu_cqs_wait_end() { + return BeginNestedMessage(472); + } + + + using FieldMetadata_MaliMaliKCPUFENCESIGNAL = + ::protozero::proto_utils::FieldMetadata< + 473, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MaliMaliKCPUFENCESIGNALFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_MaliMaliKCPUFENCESIGNAL kMaliMaliKCPUFENCESIGNAL{}; + template T* set_mali_mali_kcpu_fence_signal() { + return BeginNestedMessage(473); + } + + + using FieldMetadata_MaliMaliKCPUFENCEWAITSTART = + ::protozero::proto_utils::FieldMetadata< + 474, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MaliMaliKCPUFENCEWAITSTARTFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_MaliMaliKCPUFENCEWAITSTART kMaliMaliKCPUFENCEWAITSTART{}; + template T* set_mali_mali_kcpu_fence_wait_start() { + return BeginNestedMessage(474); + } + + + using FieldMetadata_MaliMaliKCPUFENCEWAITEND = + ::protozero::proto_utils::FieldMetadata< + 475, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MaliMaliKCPUFENCEWAITENDFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_MaliMaliKCPUFENCEWAITEND kMaliMaliKCPUFENCEWAITEND{}; + template T* set_mali_mali_kcpu_fence_wait_end() { + return BeginNestedMessage(475); + } + + + using FieldMetadata_HypEnter = + ::protozero::proto_utils::FieldMetadata< + 476, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + HypEnterFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_HypEnter kHypEnter{}; + template T* set_hyp_enter() { + return BeginNestedMessage(476); + } + + + using FieldMetadata_HypExit = + ::protozero::proto_utils::FieldMetadata< + 477, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + HypExitFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_HypExit kHypExit{}; + template T* set_hyp_exit() { + return BeginNestedMessage(477); + } + + + using FieldMetadata_HostHcall = + ::protozero::proto_utils::FieldMetadata< + 478, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + HostHcallFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_HostHcall kHostHcall{}; + template T* set_host_hcall() { + return BeginNestedMessage(478); + } + + + using FieldMetadata_HostSmc = + ::protozero::proto_utils::FieldMetadata< + 479, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + HostSmcFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_HostSmc kHostSmc{}; + template T* set_host_smc() { + return BeginNestedMessage(479); + } + + + using FieldMetadata_HostMemAbort = + ::protozero::proto_utils::FieldMetadata< + 480, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + HostMemAbortFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_HostMemAbort kHostMemAbort{}; + template T* set_host_mem_abort() { + return BeginNestedMessage(480); + } + + + using FieldMetadata_SuspendResumeMinimal = + ::protozero::proto_utils::FieldMetadata< + 481, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + SuspendResumeMinimalFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_SuspendResumeMinimal kSuspendResumeMinimal{}; + template T* set_suspend_resume_minimal() { + return BeginNestedMessage(481); + } + + + using FieldMetadata_MaliMaliCSFINTERRUPTSTART = + ::protozero::proto_utils::FieldMetadata< + 482, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MaliMaliCSFINTERRUPTSTARTFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_MaliMaliCSFINTERRUPTSTART kMaliMaliCSFINTERRUPTSTART{}; + template T* set_mali_mali_csf_interrupt_start() { + return BeginNestedMessage(482); + } + + + using FieldMetadata_MaliMaliCSFINTERRUPTEND = + ::protozero::proto_utils::FieldMetadata< + 483, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MaliMaliCSFINTERRUPTENDFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_MaliMaliCSFINTERRUPTEND kMaliMaliCSFINTERRUPTEND{}; + template T* set_mali_mali_csf_interrupt_end() { + return BeginNestedMessage(483); + } + + + using FieldMetadata_SamsungTracingMarkWrite = + ::protozero::proto_utils::FieldMetadata< + 484, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + SamsungTracingMarkWriteFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_SamsungTracingMarkWrite kSamsungTracingMarkWrite{}; + template T* set_samsung_tracing_mark_write() { + return BeginNestedMessage(484); + } + + + using FieldMetadata_BinderCommand = + ::protozero::proto_utils::FieldMetadata< + 485, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + BinderCommandFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_BinderCommand kBinderCommand{}; + template T* set_binder_command() { + return BeginNestedMessage(485); + } + + + using FieldMetadata_BinderReturn = + ::protozero::proto_utils::FieldMetadata< + 486, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + BinderReturnFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_BinderReturn kBinderReturn{}; + template T* set_binder_return() { + return BeginNestedMessage(486); + } + + + using FieldMetadata_SchedSwitchWithCtrs = + ::protozero::proto_utils::FieldMetadata< + 487, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + SchedSwitchWithCtrsFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_SchedSwitchWithCtrs kSchedSwitchWithCtrs{}; + template T* set_sched_switch_with_ctrs() { + return BeginNestedMessage(487); + } + + + using FieldMetadata_GpuWorkPeriod = + ::protozero::proto_utils::FieldMetadata< + 488, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + GpuWorkPeriodFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_GpuWorkPeriod kGpuWorkPeriod{}; + template T* set_gpu_work_period() { + return BeginNestedMessage(488); + } + + + using FieldMetadata_RpmStatus = + ::protozero::proto_utils::FieldMetadata< + 489, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + RpmStatusFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_RpmStatus kRpmStatus{}; + template T* set_rpm_status() { + return BeginNestedMessage(489); + } + + + using FieldMetadata_PanelWriteGeneric = + ::protozero::proto_utils::FieldMetadata< + 490, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + PanelWriteGenericFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_PanelWriteGeneric kPanelWriteGeneric{}; + template T* set_panel_write_generic() { + return BeginNestedMessage(490); + } + + + using FieldMetadata_SchedMigrateTask = + ::protozero::proto_utils::FieldMetadata< + 491, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + SchedMigrateTaskFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_SchedMigrateTask kSchedMigrateTask{}; + template T* set_sched_migrate_task() { + return BeginNestedMessage(491); + } + + + using FieldMetadata_DpuDsiCmdFifoStatus = + ::protozero::proto_utils::FieldMetadata< + 492, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + DpuDsiCmdFifoStatusFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_DpuDsiCmdFifoStatus kDpuDsiCmdFifoStatus{}; + template T* set_dpu_dsi_cmd_fifo_status() { + return BeginNestedMessage(492); + } + + + using FieldMetadata_DpuDsiRx = + ::protozero::proto_utils::FieldMetadata< + 493, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + DpuDsiRxFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_DpuDsiRx kDpuDsiRx{}; + template T* set_dpu_dsi_rx() { + return BeginNestedMessage(493); + } + + + using FieldMetadata_DpuDsiTx = + ::protozero::proto_utils::FieldMetadata< + 494, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + DpuDsiTxFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_DpuDsiTx kDpuDsiTx{}; + template T* set_dpu_dsi_tx() { + return BeginNestedMessage(494); + } + + + using FieldMetadata_F2fsBackgroundGc = + ::protozero::proto_utils::FieldMetadata< + 495, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + F2fsBackgroundGcFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_F2fsBackgroundGc kF2fsBackgroundGc{}; + template T* set_f2fs_background_gc() { + return BeginNestedMessage(495); + } + + + using FieldMetadata_F2fsGcBegin = + ::protozero::proto_utils::FieldMetadata< + 496, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + F2fsGcBeginFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_F2fsGcBegin kF2fsGcBegin{}; + template T* set_f2fs_gc_begin() { + return BeginNestedMessage(496); + } + + + using FieldMetadata_F2fsGcEnd = + ::protozero::proto_utils::FieldMetadata< + 497, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + F2fsGcEndFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_F2fsGcEnd kF2fsGcEnd{}; + template T* set_f2fs_gc_end() { + return BeginNestedMessage(497); + } + + + using FieldMetadata_FastrpcDmaFree = + ::protozero::proto_utils::FieldMetadata< + 498, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + FastrpcDmaFreeFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_FastrpcDmaFree kFastrpcDmaFree{}; + template T* set_fastrpc_dma_free() { + return BeginNestedMessage(498); + } + + + using FieldMetadata_FastrpcDmaAlloc = + ::protozero::proto_utils::FieldMetadata< + 499, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + FastrpcDmaAllocFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_FastrpcDmaAlloc kFastrpcDmaAlloc{}; + template T* set_fastrpc_dma_alloc() { + return BeginNestedMessage(499); + } + + + using FieldMetadata_FastrpcDmaUnmap = + ::protozero::proto_utils::FieldMetadata< + 500, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + FastrpcDmaUnmapFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_FastrpcDmaUnmap kFastrpcDmaUnmap{}; + template T* set_fastrpc_dma_unmap() { + return BeginNestedMessage(500); + } + + + using FieldMetadata_FastrpcDmaMap = + ::protozero::proto_utils::FieldMetadata< + 501, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + FastrpcDmaMapFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_FastrpcDmaMap kFastrpcDmaMap{}; + template T* set_fastrpc_dma_map() { + return BeginNestedMessage(501); + } + +}; + +class WorkqueueQueueWorkFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + WorkqueueQueueWorkFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit WorkqueueQueueWorkFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit WorkqueueQueueWorkFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_work() const { return at<1>().valid(); } + uint64_t work() const { return at<1>().as_uint64(); } + bool has_function() const { return at<2>().valid(); } + uint64_t function() const { return at<2>().as_uint64(); } + bool has_workqueue() const { return at<3>().valid(); } + uint64_t workqueue() const { return at<3>().as_uint64(); } + bool has_req_cpu() const { return at<4>().valid(); } + uint32_t req_cpu() const { return at<4>().as_uint32(); } + bool has_cpu() const { return at<5>().valid(); } + uint32_t cpu() const { return at<5>().as_uint32(); } +}; + +class WorkqueueQueueWorkFtraceEvent : public ::protozero::Message { + public: + using Decoder = WorkqueueQueueWorkFtraceEvent_Decoder; + enum : int32_t { + kWorkFieldNumber = 1, + kFunctionFieldNumber = 2, + kWorkqueueFieldNumber = 3, + kReqCpuFieldNumber = 4, + kCpuFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.WorkqueueQueueWorkFtraceEvent"; } + + + using FieldMetadata_Work = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + WorkqueueQueueWorkFtraceEvent>; + + static constexpr FieldMetadata_Work kWork{}; + void set_work(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Work::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Function = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + WorkqueueQueueWorkFtraceEvent>; + + static constexpr FieldMetadata_Function kFunction{}; + void set_function(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Function::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Workqueue = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + WorkqueueQueueWorkFtraceEvent>; + + static constexpr FieldMetadata_Workqueue kWorkqueue{}; + void set_workqueue(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Workqueue::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ReqCpu = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + WorkqueueQueueWorkFtraceEvent>; + + static constexpr FieldMetadata_ReqCpu kReqCpu{}; + void set_req_cpu(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ReqCpu::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Cpu = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + WorkqueueQueueWorkFtraceEvent>; + + static constexpr FieldMetadata_Cpu kCpu{}; + void set_cpu(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Cpu::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class WorkqueueExecuteStartFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + WorkqueueExecuteStartFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit WorkqueueExecuteStartFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit WorkqueueExecuteStartFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_work() const { return at<1>().valid(); } + uint64_t work() const { return at<1>().as_uint64(); } + bool has_function() const { return at<2>().valid(); } + uint64_t function() const { return at<2>().as_uint64(); } +}; + +class WorkqueueExecuteStartFtraceEvent : public ::protozero::Message { + public: + using Decoder = WorkqueueExecuteStartFtraceEvent_Decoder; + enum : int32_t { + kWorkFieldNumber = 1, + kFunctionFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.WorkqueueExecuteStartFtraceEvent"; } + + + using FieldMetadata_Work = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + WorkqueueExecuteStartFtraceEvent>; + + static constexpr FieldMetadata_Work kWork{}; + void set_work(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Work::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Function = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + WorkqueueExecuteStartFtraceEvent>; + + static constexpr FieldMetadata_Function kFunction{}; + void set_function(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Function::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class WorkqueueExecuteEndFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + WorkqueueExecuteEndFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit WorkqueueExecuteEndFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit WorkqueueExecuteEndFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_work() const { return at<1>().valid(); } + uint64_t work() const { return at<1>().as_uint64(); } + bool has_function() const { return at<2>().valid(); } + uint64_t function() const { return at<2>().as_uint64(); } +}; + +class WorkqueueExecuteEndFtraceEvent : public ::protozero::Message { + public: + using Decoder = WorkqueueExecuteEndFtraceEvent_Decoder; + enum : int32_t { + kWorkFieldNumber = 1, + kFunctionFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.WorkqueueExecuteEndFtraceEvent"; } + + + using FieldMetadata_Work = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + WorkqueueExecuteEndFtraceEvent>; + + static constexpr FieldMetadata_Work kWork{}; + void set_work(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Work::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Function = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + WorkqueueExecuteEndFtraceEvent>; + + static constexpr FieldMetadata_Function kFunction{}; + void set_function(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Function::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class WorkqueueActivateWorkFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + WorkqueueActivateWorkFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit WorkqueueActivateWorkFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit WorkqueueActivateWorkFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_work() const { return at<1>().valid(); } + uint64_t work() const { return at<1>().as_uint64(); } +}; + +class WorkqueueActivateWorkFtraceEvent : public ::protozero::Message { + public: + using Decoder = WorkqueueActivateWorkFtraceEvent_Decoder; + enum : int32_t { + kWorkFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.WorkqueueActivateWorkFtraceEvent"; } + + + using FieldMetadata_Work = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + WorkqueueActivateWorkFtraceEvent>; + + static constexpr FieldMetadata_Work kWork{}; + void set_work(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Work::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class MmShrinkSlabEndFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + MmShrinkSlabEndFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MmShrinkSlabEndFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MmShrinkSlabEndFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_new_scan() const { return at<1>().valid(); } + int64_t new_scan() const { return at<1>().as_int64(); } + bool has_retval() const { return at<2>().valid(); } + int32_t retval() const { return at<2>().as_int32(); } + bool has_shr() const { return at<3>().valid(); } + uint64_t shr() const { return at<3>().as_uint64(); } + bool has_shrink() const { return at<4>().valid(); } + uint64_t shrink() const { return at<4>().as_uint64(); } + bool has_total_scan() const { return at<5>().valid(); } + int64_t total_scan() const { return at<5>().as_int64(); } + bool has_unused_scan() const { return at<6>().valid(); } + int64_t unused_scan() const { return at<6>().as_int64(); } + bool has_nid() const { return at<7>().valid(); } + int32_t nid() const { return at<7>().as_int32(); } +}; + +class MmShrinkSlabEndFtraceEvent : public ::protozero::Message { + public: + using Decoder = MmShrinkSlabEndFtraceEvent_Decoder; + enum : int32_t { + kNewScanFieldNumber = 1, + kRetvalFieldNumber = 2, + kShrFieldNumber = 3, + kShrinkFieldNumber = 4, + kTotalScanFieldNumber = 5, + kUnusedScanFieldNumber = 6, + kNidFieldNumber = 7, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MmShrinkSlabEndFtraceEvent"; } + + + using FieldMetadata_NewScan = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + MmShrinkSlabEndFtraceEvent>; + + static constexpr FieldMetadata_NewScan kNewScan{}; + void set_new_scan(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_NewScan::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Retval = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MmShrinkSlabEndFtraceEvent>; + + static constexpr FieldMetadata_Retval kRetval{}; + void set_retval(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Retval::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Shr = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MmShrinkSlabEndFtraceEvent>; + + static constexpr FieldMetadata_Shr kShr{}; + void set_shr(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Shr::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Shrink = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MmShrinkSlabEndFtraceEvent>; + + static constexpr FieldMetadata_Shrink kShrink{}; + void set_shrink(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Shrink::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TotalScan = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + MmShrinkSlabEndFtraceEvent>; + + static constexpr FieldMetadata_TotalScan kTotalScan{}; + void set_total_scan(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_TotalScan::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_UnusedScan = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + MmShrinkSlabEndFtraceEvent>; + + static constexpr FieldMetadata_UnusedScan kUnusedScan{}; + void set_unused_scan(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_UnusedScan::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Nid = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MmShrinkSlabEndFtraceEvent>; + + static constexpr FieldMetadata_Nid kNid{}; + void set_nid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Nid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class MmShrinkSlabStartFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + MmShrinkSlabStartFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MmShrinkSlabStartFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MmShrinkSlabStartFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_cache_items() const { return at<1>().valid(); } + uint64_t cache_items() const { return at<1>().as_uint64(); } + bool has_delta() const { return at<2>().valid(); } + uint64_t delta() const { return at<2>().as_uint64(); } + bool has_gfp_flags() const { return at<3>().valid(); } + uint32_t gfp_flags() const { return at<3>().as_uint32(); } + bool has_lru_pgs() const { return at<4>().valid(); } + uint64_t lru_pgs() const { return at<4>().as_uint64(); } + bool has_nr_objects_to_shrink() const { return at<5>().valid(); } + int64_t nr_objects_to_shrink() const { return at<5>().as_int64(); } + bool has_pgs_scanned() const { return at<6>().valid(); } + uint64_t pgs_scanned() const { return at<6>().as_uint64(); } + bool has_shr() const { return at<7>().valid(); } + uint64_t shr() const { return at<7>().as_uint64(); } + bool has_shrink() const { return at<8>().valid(); } + uint64_t shrink() const { return at<8>().as_uint64(); } + bool has_total_scan() const { return at<9>().valid(); } + uint64_t total_scan() const { return at<9>().as_uint64(); } + bool has_nid() const { return at<10>().valid(); } + int32_t nid() const { return at<10>().as_int32(); } + bool has_priority() const { return at<11>().valid(); } + int32_t priority() const { return at<11>().as_int32(); } +}; + +class MmShrinkSlabStartFtraceEvent : public ::protozero::Message { + public: + using Decoder = MmShrinkSlabStartFtraceEvent_Decoder; + enum : int32_t { + kCacheItemsFieldNumber = 1, + kDeltaFieldNumber = 2, + kGfpFlagsFieldNumber = 3, + kLruPgsFieldNumber = 4, + kNrObjectsToShrinkFieldNumber = 5, + kPgsScannedFieldNumber = 6, + kShrFieldNumber = 7, + kShrinkFieldNumber = 8, + kTotalScanFieldNumber = 9, + kNidFieldNumber = 10, + kPriorityFieldNumber = 11, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MmShrinkSlabStartFtraceEvent"; } + + + using FieldMetadata_CacheItems = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MmShrinkSlabStartFtraceEvent>; + + static constexpr FieldMetadata_CacheItems kCacheItems{}; + void set_cache_items(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_CacheItems::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Delta = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MmShrinkSlabStartFtraceEvent>; + + static constexpr FieldMetadata_Delta kDelta{}; + void set_delta(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Delta::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_GfpFlags = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MmShrinkSlabStartFtraceEvent>; + + static constexpr FieldMetadata_GfpFlags kGfpFlags{}; + void set_gfp_flags(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_GfpFlags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_LruPgs = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MmShrinkSlabStartFtraceEvent>; + + static constexpr FieldMetadata_LruPgs kLruPgs{}; + void set_lru_pgs(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_LruPgs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NrObjectsToShrink = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + MmShrinkSlabStartFtraceEvent>; + + static constexpr FieldMetadata_NrObjectsToShrink kNrObjectsToShrink{}; + void set_nr_objects_to_shrink(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_NrObjectsToShrink::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PgsScanned = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MmShrinkSlabStartFtraceEvent>; + + static constexpr FieldMetadata_PgsScanned kPgsScanned{}; + void set_pgs_scanned(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_PgsScanned::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Shr = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MmShrinkSlabStartFtraceEvent>; + + static constexpr FieldMetadata_Shr kShr{}; + void set_shr(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Shr::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Shrink = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MmShrinkSlabStartFtraceEvent>; + + static constexpr FieldMetadata_Shrink kShrink{}; + void set_shrink(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Shrink::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TotalScan = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MmShrinkSlabStartFtraceEvent>; + + static constexpr FieldMetadata_TotalScan kTotalScan{}; + void set_total_scan(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_TotalScan::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Nid = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MmShrinkSlabStartFtraceEvent>; + + static constexpr FieldMetadata_Nid kNid{}; + void set_nid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Nid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Priority = + ::protozero::proto_utils::FieldMetadata< + 11, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MmShrinkSlabStartFtraceEvent>; + + static constexpr FieldMetadata_Priority kPriority{}; + void set_priority(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Priority::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class MmVmscanKswapdSleepFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + MmVmscanKswapdSleepFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MmVmscanKswapdSleepFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MmVmscanKswapdSleepFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_nid() const { return at<1>().valid(); } + int32_t nid() const { return at<1>().as_int32(); } +}; + +class MmVmscanKswapdSleepFtraceEvent : public ::protozero::Message { + public: + using Decoder = MmVmscanKswapdSleepFtraceEvent_Decoder; + enum : int32_t { + kNidFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MmVmscanKswapdSleepFtraceEvent"; } + + + using FieldMetadata_Nid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MmVmscanKswapdSleepFtraceEvent>; + + static constexpr FieldMetadata_Nid kNid{}; + void set_nid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Nid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class MmVmscanKswapdWakeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + MmVmscanKswapdWakeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MmVmscanKswapdWakeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MmVmscanKswapdWakeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_nid() const { return at<1>().valid(); } + int32_t nid() const { return at<1>().as_int32(); } + bool has_order() const { return at<2>().valid(); } + int32_t order() const { return at<2>().as_int32(); } + bool has_zid() const { return at<3>().valid(); } + int32_t zid() const { return at<3>().as_int32(); } +}; + +class MmVmscanKswapdWakeFtraceEvent : public ::protozero::Message { + public: + using Decoder = MmVmscanKswapdWakeFtraceEvent_Decoder; + enum : int32_t { + kNidFieldNumber = 1, + kOrderFieldNumber = 2, + kZidFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MmVmscanKswapdWakeFtraceEvent"; } + + + using FieldMetadata_Nid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MmVmscanKswapdWakeFtraceEvent>; + + static constexpr FieldMetadata_Nid kNid{}; + void set_nid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Nid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Order = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MmVmscanKswapdWakeFtraceEvent>; + + static constexpr FieldMetadata_Order kOrder{}; + void set_order(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Order::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Zid = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MmVmscanKswapdWakeFtraceEvent>; + + static constexpr FieldMetadata_Zid kZid{}; + void set_zid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Zid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class MmVmscanDirectReclaimEndFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + MmVmscanDirectReclaimEndFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MmVmscanDirectReclaimEndFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MmVmscanDirectReclaimEndFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_nr_reclaimed() const { return at<1>().valid(); } + uint64_t nr_reclaimed() const { return at<1>().as_uint64(); } +}; + +class MmVmscanDirectReclaimEndFtraceEvent : public ::protozero::Message { + public: + using Decoder = MmVmscanDirectReclaimEndFtraceEvent_Decoder; + enum : int32_t { + kNrReclaimedFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MmVmscanDirectReclaimEndFtraceEvent"; } + + + using FieldMetadata_NrReclaimed = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MmVmscanDirectReclaimEndFtraceEvent>; + + static constexpr FieldMetadata_NrReclaimed kNrReclaimed{}; + void set_nr_reclaimed(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_NrReclaimed::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class MmVmscanDirectReclaimBeginFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + MmVmscanDirectReclaimBeginFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MmVmscanDirectReclaimBeginFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MmVmscanDirectReclaimBeginFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_order() const { return at<1>().valid(); } + int32_t order() const { return at<1>().as_int32(); } + bool has_may_writepage() const { return at<2>().valid(); } + int32_t may_writepage() const { return at<2>().as_int32(); } + bool has_gfp_flags() const { return at<3>().valid(); } + uint32_t gfp_flags() const { return at<3>().as_uint32(); } +}; + +class MmVmscanDirectReclaimBeginFtraceEvent : public ::protozero::Message { + public: + using Decoder = MmVmscanDirectReclaimBeginFtraceEvent_Decoder; + enum : int32_t { + kOrderFieldNumber = 1, + kMayWritepageFieldNumber = 2, + kGfpFlagsFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MmVmscanDirectReclaimBeginFtraceEvent"; } + + + using FieldMetadata_Order = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MmVmscanDirectReclaimBeginFtraceEvent>; + + static constexpr FieldMetadata_Order kOrder{}; + void set_order(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Order::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_MayWritepage = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MmVmscanDirectReclaimBeginFtraceEvent>; + + static constexpr FieldMetadata_MayWritepage kMayWritepage{}; + void set_may_writepage(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_MayWritepage::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_GfpFlags = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MmVmscanDirectReclaimBeginFtraceEvent>; + + static constexpr FieldMetadata_GfpFlags kGfpFlags{}; + void set_gfp_flags(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_GfpFlags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class VirtioVideoResourceQueueDoneFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + VirtioVideoResourceQueueDoneFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit VirtioVideoResourceQueueDoneFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit VirtioVideoResourceQueueDoneFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_data_size0() const { return at<1>().valid(); } + uint32_t data_size0() const { return at<1>().as_uint32(); } + bool has_data_size1() const { return at<2>().valid(); } + uint32_t data_size1() const { return at<2>().as_uint32(); } + bool has_data_size2() const { return at<3>().valid(); } + uint32_t data_size2() const { return at<3>().as_uint32(); } + bool has_data_size3() const { return at<4>().valid(); } + uint32_t data_size3() const { return at<4>().as_uint32(); } + bool has_queue_type() const { return at<5>().valid(); } + uint32_t queue_type() const { return at<5>().as_uint32(); } + bool has_resource_id() const { return at<6>().valid(); } + int32_t resource_id() const { return at<6>().as_int32(); } + bool has_stream_id() const { return at<7>().valid(); } + int32_t stream_id() const { return at<7>().as_int32(); } + bool has_timestamp() const { return at<8>().valid(); } + uint64_t timestamp() const { return at<8>().as_uint64(); } +}; + +class VirtioVideoResourceQueueDoneFtraceEvent : public ::protozero::Message { + public: + using Decoder = VirtioVideoResourceQueueDoneFtraceEvent_Decoder; + enum : int32_t { + kDataSize0FieldNumber = 1, + kDataSize1FieldNumber = 2, + kDataSize2FieldNumber = 3, + kDataSize3FieldNumber = 4, + kQueueTypeFieldNumber = 5, + kResourceIdFieldNumber = 6, + kStreamIdFieldNumber = 7, + kTimestampFieldNumber = 8, + }; + static constexpr const char* GetName() { return ".perfetto.protos.VirtioVideoResourceQueueDoneFtraceEvent"; } + + + using FieldMetadata_DataSize0 = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + VirtioVideoResourceQueueDoneFtraceEvent>; + + static constexpr FieldMetadata_DataSize0 kDataSize0{}; + void set_data_size0(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_DataSize0::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DataSize1 = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + VirtioVideoResourceQueueDoneFtraceEvent>; + + static constexpr FieldMetadata_DataSize1 kDataSize1{}; + void set_data_size1(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_DataSize1::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DataSize2 = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + VirtioVideoResourceQueueDoneFtraceEvent>; + + static constexpr FieldMetadata_DataSize2 kDataSize2{}; + void set_data_size2(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_DataSize2::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DataSize3 = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + VirtioVideoResourceQueueDoneFtraceEvent>; + + static constexpr FieldMetadata_DataSize3 kDataSize3{}; + void set_data_size3(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_DataSize3::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_QueueType = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + VirtioVideoResourceQueueDoneFtraceEvent>; + + static constexpr FieldMetadata_QueueType kQueueType{}; + void set_queue_type(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_QueueType::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ResourceId = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + VirtioVideoResourceQueueDoneFtraceEvent>; + + static constexpr FieldMetadata_ResourceId kResourceId{}; + void set_resource_id(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ResourceId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_StreamId = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + VirtioVideoResourceQueueDoneFtraceEvent>; + + static constexpr FieldMetadata_StreamId kStreamId{}; + void set_stream_id(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_StreamId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Timestamp = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + VirtioVideoResourceQueueDoneFtraceEvent>; + + static constexpr FieldMetadata_Timestamp kTimestamp{}; + void set_timestamp(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Timestamp::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class VirtioVideoResourceQueueFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + VirtioVideoResourceQueueFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit VirtioVideoResourceQueueFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit VirtioVideoResourceQueueFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_data_size0() const { return at<1>().valid(); } + uint32_t data_size0() const { return at<1>().as_uint32(); } + bool has_data_size1() const { return at<2>().valid(); } + uint32_t data_size1() const { return at<2>().as_uint32(); } + bool has_data_size2() const { return at<3>().valid(); } + uint32_t data_size2() const { return at<3>().as_uint32(); } + bool has_data_size3() const { return at<4>().valid(); } + uint32_t data_size3() const { return at<4>().as_uint32(); } + bool has_queue_type() const { return at<5>().valid(); } + uint32_t queue_type() const { return at<5>().as_uint32(); } + bool has_resource_id() const { return at<6>().valid(); } + int32_t resource_id() const { return at<6>().as_int32(); } + bool has_stream_id() const { return at<7>().valid(); } + int32_t stream_id() const { return at<7>().as_int32(); } + bool has_timestamp() const { return at<8>().valid(); } + uint64_t timestamp() const { return at<8>().as_uint64(); } +}; + +class VirtioVideoResourceQueueFtraceEvent : public ::protozero::Message { + public: + using Decoder = VirtioVideoResourceQueueFtraceEvent_Decoder; + enum : int32_t { + kDataSize0FieldNumber = 1, + kDataSize1FieldNumber = 2, + kDataSize2FieldNumber = 3, + kDataSize3FieldNumber = 4, + kQueueTypeFieldNumber = 5, + kResourceIdFieldNumber = 6, + kStreamIdFieldNumber = 7, + kTimestampFieldNumber = 8, + }; + static constexpr const char* GetName() { return ".perfetto.protos.VirtioVideoResourceQueueFtraceEvent"; } + + + using FieldMetadata_DataSize0 = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + VirtioVideoResourceQueueFtraceEvent>; + + static constexpr FieldMetadata_DataSize0 kDataSize0{}; + void set_data_size0(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_DataSize0::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DataSize1 = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + VirtioVideoResourceQueueFtraceEvent>; + + static constexpr FieldMetadata_DataSize1 kDataSize1{}; + void set_data_size1(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_DataSize1::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DataSize2 = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + VirtioVideoResourceQueueFtraceEvent>; + + static constexpr FieldMetadata_DataSize2 kDataSize2{}; + void set_data_size2(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_DataSize2::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DataSize3 = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + VirtioVideoResourceQueueFtraceEvent>; + + static constexpr FieldMetadata_DataSize3 kDataSize3{}; + void set_data_size3(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_DataSize3::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_QueueType = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + VirtioVideoResourceQueueFtraceEvent>; + + static constexpr FieldMetadata_QueueType kQueueType{}; + void set_queue_type(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_QueueType::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ResourceId = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + VirtioVideoResourceQueueFtraceEvent>; + + static constexpr FieldMetadata_ResourceId kResourceId{}; + void set_resource_id(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ResourceId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_StreamId = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + VirtioVideoResourceQueueFtraceEvent>; + + static constexpr FieldMetadata_StreamId kStreamId{}; + void set_stream_id(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_StreamId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Timestamp = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + VirtioVideoResourceQueueFtraceEvent>; + + static constexpr FieldMetadata_Timestamp kTimestamp{}; + void set_timestamp(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Timestamp::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class VirtioVideoCmdDoneFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + VirtioVideoCmdDoneFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit VirtioVideoCmdDoneFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit VirtioVideoCmdDoneFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_stream_id() const { return at<1>().valid(); } + uint32_t stream_id() const { return at<1>().as_uint32(); } + bool has_type() const { return at<2>().valid(); } + uint32_t type() const { return at<2>().as_uint32(); } +}; + +class VirtioVideoCmdDoneFtraceEvent : public ::protozero::Message { + public: + using Decoder = VirtioVideoCmdDoneFtraceEvent_Decoder; + enum : int32_t { + kStreamIdFieldNumber = 1, + kTypeFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.VirtioVideoCmdDoneFtraceEvent"; } + + + using FieldMetadata_StreamId = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + VirtioVideoCmdDoneFtraceEvent>; + + static constexpr FieldMetadata_StreamId kStreamId{}; + void set_stream_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_StreamId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Type = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + VirtioVideoCmdDoneFtraceEvent>; + + static constexpr FieldMetadata_Type kType{}; + void set_type(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class VirtioVideoCmdFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + VirtioVideoCmdFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit VirtioVideoCmdFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit VirtioVideoCmdFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_stream_id() const { return at<1>().valid(); } + uint32_t stream_id() const { return at<1>().as_uint32(); } + bool has_type() const { return at<2>().valid(); } + uint32_t type() const { return at<2>().as_uint32(); } +}; + +class VirtioVideoCmdFtraceEvent : public ::protozero::Message { + public: + using Decoder = VirtioVideoCmdFtraceEvent_Decoder; + enum : int32_t { + kStreamIdFieldNumber = 1, + kTypeFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.VirtioVideoCmdFtraceEvent"; } + + + using FieldMetadata_StreamId = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + VirtioVideoCmdFtraceEvent>; + + static constexpr FieldMetadata_StreamId kStreamId{}; + void set_stream_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_StreamId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Type = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + VirtioVideoCmdFtraceEvent>; + + static constexpr FieldMetadata_Type kType{}; + void set_type(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class VirtioGpuCmdResponseFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + VirtioGpuCmdResponseFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit VirtioGpuCmdResponseFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit VirtioGpuCmdResponseFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_ctx_id() const { return at<1>().valid(); } + uint32_t ctx_id() const { return at<1>().as_uint32(); } + bool has_dev() const { return at<2>().valid(); } + int32_t dev() const { return at<2>().as_int32(); } + bool has_fence_id() const { return at<3>().valid(); } + uint64_t fence_id() const { return at<3>().as_uint64(); } + bool has_flags() const { return at<4>().valid(); } + uint32_t flags() const { return at<4>().as_uint32(); } + bool has_name() const { return at<5>().valid(); } + ::protozero::ConstChars name() const { return at<5>().as_string(); } + bool has_num_free() const { return at<6>().valid(); } + uint32_t num_free() const { return at<6>().as_uint32(); } + bool has_seqno() const { return at<7>().valid(); } + uint32_t seqno() const { return at<7>().as_uint32(); } + bool has_type() const { return at<8>().valid(); } + uint32_t type() const { return at<8>().as_uint32(); } + bool has_vq() const { return at<9>().valid(); } + uint32_t vq() const { return at<9>().as_uint32(); } +}; + +class VirtioGpuCmdResponseFtraceEvent : public ::protozero::Message { + public: + using Decoder = VirtioGpuCmdResponseFtraceEvent_Decoder; + enum : int32_t { + kCtxIdFieldNumber = 1, + kDevFieldNumber = 2, + kFenceIdFieldNumber = 3, + kFlagsFieldNumber = 4, + kNameFieldNumber = 5, + kNumFreeFieldNumber = 6, + kSeqnoFieldNumber = 7, + kTypeFieldNumber = 8, + kVqFieldNumber = 9, + }; + static constexpr const char* GetName() { return ".perfetto.protos.VirtioGpuCmdResponseFtraceEvent"; } + + + using FieldMetadata_CtxId = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + VirtioGpuCmdResponseFtraceEvent>; + + static constexpr FieldMetadata_CtxId kCtxId{}; + void set_ctx_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_CtxId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + VirtioGpuCmdResponseFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FenceId = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + VirtioGpuCmdResponseFtraceEvent>; + + static constexpr FieldMetadata_FenceId kFenceId{}; + void set_fence_id(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_FenceId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Flags = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + VirtioGpuCmdResponseFtraceEvent>; + + static constexpr FieldMetadata_Flags kFlags{}; + void set_flags(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + VirtioGpuCmdResponseFtraceEvent>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NumFree = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + VirtioGpuCmdResponseFtraceEvent>; + + static constexpr FieldMetadata_NumFree kNumFree{}; + void set_num_free(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_NumFree::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Seqno = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + VirtioGpuCmdResponseFtraceEvent>; + + static constexpr FieldMetadata_Seqno kSeqno{}; + void set_seqno(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Seqno::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Type = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + VirtioGpuCmdResponseFtraceEvent>; + + static constexpr FieldMetadata_Type kType{}; + void set_type(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Vq = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + VirtioGpuCmdResponseFtraceEvent>; + + static constexpr FieldMetadata_Vq kVq{}; + void set_vq(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Vq::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class VirtioGpuCmdQueueFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + VirtioGpuCmdQueueFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit VirtioGpuCmdQueueFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit VirtioGpuCmdQueueFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_ctx_id() const { return at<1>().valid(); } + uint32_t ctx_id() const { return at<1>().as_uint32(); } + bool has_dev() const { return at<2>().valid(); } + int32_t dev() const { return at<2>().as_int32(); } + bool has_fence_id() const { return at<3>().valid(); } + uint64_t fence_id() const { return at<3>().as_uint64(); } + bool has_flags() const { return at<4>().valid(); } + uint32_t flags() const { return at<4>().as_uint32(); } + bool has_name() const { return at<5>().valid(); } + ::protozero::ConstChars name() const { return at<5>().as_string(); } + bool has_num_free() const { return at<6>().valid(); } + uint32_t num_free() const { return at<6>().as_uint32(); } + bool has_seqno() const { return at<7>().valid(); } + uint32_t seqno() const { return at<7>().as_uint32(); } + bool has_type() const { return at<8>().valid(); } + uint32_t type() const { return at<8>().as_uint32(); } + bool has_vq() const { return at<9>().valid(); } + uint32_t vq() const { return at<9>().as_uint32(); } +}; + +class VirtioGpuCmdQueueFtraceEvent : public ::protozero::Message { + public: + using Decoder = VirtioGpuCmdQueueFtraceEvent_Decoder; + enum : int32_t { + kCtxIdFieldNumber = 1, + kDevFieldNumber = 2, + kFenceIdFieldNumber = 3, + kFlagsFieldNumber = 4, + kNameFieldNumber = 5, + kNumFreeFieldNumber = 6, + kSeqnoFieldNumber = 7, + kTypeFieldNumber = 8, + kVqFieldNumber = 9, + }; + static constexpr const char* GetName() { return ".perfetto.protos.VirtioGpuCmdQueueFtraceEvent"; } + + + using FieldMetadata_CtxId = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + VirtioGpuCmdQueueFtraceEvent>; + + static constexpr FieldMetadata_CtxId kCtxId{}; + void set_ctx_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_CtxId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + VirtioGpuCmdQueueFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FenceId = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + VirtioGpuCmdQueueFtraceEvent>; + + static constexpr FieldMetadata_FenceId kFenceId{}; + void set_fence_id(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_FenceId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Flags = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + VirtioGpuCmdQueueFtraceEvent>; + + static constexpr FieldMetadata_Flags kFlags{}; + void set_flags(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + VirtioGpuCmdQueueFtraceEvent>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NumFree = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + VirtioGpuCmdQueueFtraceEvent>; + + static constexpr FieldMetadata_NumFree kNumFree{}; + void set_num_free(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_NumFree::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Seqno = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + VirtioGpuCmdQueueFtraceEvent>; + + static constexpr FieldMetadata_Seqno kSeqno{}; + void set_seqno(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Seqno::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Type = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + VirtioGpuCmdQueueFtraceEvent>; + + static constexpr FieldMetadata_Type kType{}; + void set_type(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Vq = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + VirtioGpuCmdQueueFtraceEvent>; + + static constexpr FieldMetadata_Vq kVq{}; + void set_vq(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Vq::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class Vb2V4l2DqbufFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Vb2V4l2DqbufFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Vb2V4l2DqbufFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Vb2V4l2DqbufFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_field() const { return at<1>().valid(); } + uint32_t field() const { return at<1>().as_uint32(); } + bool has_flags() const { return at<2>().valid(); } + uint32_t flags() const { return at<2>().as_uint32(); } + bool has_minor() const { return at<3>().valid(); } + int32_t minor() const { return at<3>().as_int32(); } + bool has_sequence() const { return at<4>().valid(); } + uint32_t sequence() const { return at<4>().as_uint32(); } + bool has_timecode_flags() const { return at<5>().valid(); } + uint32_t timecode_flags() const { return at<5>().as_uint32(); } + bool has_timecode_frames() const { return at<6>().valid(); } + uint32_t timecode_frames() const { return at<6>().as_uint32(); } + bool has_timecode_hours() const { return at<7>().valid(); } + uint32_t timecode_hours() const { return at<7>().as_uint32(); } + bool has_timecode_minutes() const { return at<8>().valid(); } + uint32_t timecode_minutes() const { return at<8>().as_uint32(); } + bool has_timecode_seconds() const { return at<9>().valid(); } + uint32_t timecode_seconds() const { return at<9>().as_uint32(); } + bool has_timecode_type() const { return at<10>().valid(); } + uint32_t timecode_type() const { return at<10>().as_uint32(); } + bool has_timecode_userbits0() const { return at<11>().valid(); } + uint32_t timecode_userbits0() const { return at<11>().as_uint32(); } + bool has_timecode_userbits1() const { return at<12>().valid(); } + uint32_t timecode_userbits1() const { return at<12>().as_uint32(); } + bool has_timecode_userbits2() const { return at<13>().valid(); } + uint32_t timecode_userbits2() const { return at<13>().as_uint32(); } + bool has_timecode_userbits3() const { return at<14>().valid(); } + uint32_t timecode_userbits3() const { return at<14>().as_uint32(); } + bool has_timestamp() const { return at<15>().valid(); } + int64_t timestamp() const { return at<15>().as_int64(); } +}; + +class Vb2V4l2DqbufFtraceEvent : public ::protozero::Message { + public: + using Decoder = Vb2V4l2DqbufFtraceEvent_Decoder; + enum : int32_t { + kFieldFieldNumber = 1, + kFlagsFieldNumber = 2, + kMinorFieldNumber = 3, + kSequenceFieldNumber = 4, + kTimecodeFlagsFieldNumber = 5, + kTimecodeFramesFieldNumber = 6, + kTimecodeHoursFieldNumber = 7, + kTimecodeMinutesFieldNumber = 8, + kTimecodeSecondsFieldNumber = 9, + kTimecodeTypeFieldNumber = 10, + kTimecodeUserbits0FieldNumber = 11, + kTimecodeUserbits1FieldNumber = 12, + kTimecodeUserbits2FieldNumber = 13, + kTimecodeUserbits3FieldNumber = 14, + kTimestampFieldNumber = 15, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Vb2V4l2DqbufFtraceEvent"; } + + + using FieldMetadata_Field = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Vb2V4l2DqbufFtraceEvent>; + + static constexpr FieldMetadata_Field kField{}; + void set_field(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Field::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Flags = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Vb2V4l2DqbufFtraceEvent>; + + static constexpr FieldMetadata_Flags kFlags{}; + void set_flags(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Minor = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Vb2V4l2DqbufFtraceEvent>; + + static constexpr FieldMetadata_Minor kMinor{}; + void set_minor(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Minor::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Sequence = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Vb2V4l2DqbufFtraceEvent>; + + static constexpr FieldMetadata_Sequence kSequence{}; + void set_sequence(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Sequence::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TimecodeFlags = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Vb2V4l2DqbufFtraceEvent>; + + static constexpr FieldMetadata_TimecodeFlags kTimecodeFlags{}; + void set_timecode_flags(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TimecodeFlags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TimecodeFrames = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Vb2V4l2DqbufFtraceEvent>; + + static constexpr FieldMetadata_TimecodeFrames kTimecodeFrames{}; + void set_timecode_frames(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TimecodeFrames::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TimecodeHours = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Vb2V4l2DqbufFtraceEvent>; + + static constexpr FieldMetadata_TimecodeHours kTimecodeHours{}; + void set_timecode_hours(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TimecodeHours::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TimecodeMinutes = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Vb2V4l2DqbufFtraceEvent>; + + static constexpr FieldMetadata_TimecodeMinutes kTimecodeMinutes{}; + void set_timecode_minutes(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TimecodeMinutes::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TimecodeSeconds = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Vb2V4l2DqbufFtraceEvent>; + + static constexpr FieldMetadata_TimecodeSeconds kTimecodeSeconds{}; + void set_timecode_seconds(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TimecodeSeconds::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TimecodeType = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Vb2V4l2DqbufFtraceEvent>; + + static constexpr FieldMetadata_TimecodeType kTimecodeType{}; + void set_timecode_type(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TimecodeType::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TimecodeUserbits0 = + ::protozero::proto_utils::FieldMetadata< + 11, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Vb2V4l2DqbufFtraceEvent>; + + static constexpr FieldMetadata_TimecodeUserbits0 kTimecodeUserbits0{}; + void set_timecode_userbits0(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TimecodeUserbits0::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TimecodeUserbits1 = + ::protozero::proto_utils::FieldMetadata< + 12, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Vb2V4l2DqbufFtraceEvent>; + + static constexpr FieldMetadata_TimecodeUserbits1 kTimecodeUserbits1{}; + void set_timecode_userbits1(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TimecodeUserbits1::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TimecodeUserbits2 = + ::protozero::proto_utils::FieldMetadata< + 13, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Vb2V4l2DqbufFtraceEvent>; + + static constexpr FieldMetadata_TimecodeUserbits2 kTimecodeUserbits2{}; + void set_timecode_userbits2(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TimecodeUserbits2::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TimecodeUserbits3 = + ::protozero::proto_utils::FieldMetadata< + 14, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Vb2V4l2DqbufFtraceEvent>; + + static constexpr FieldMetadata_TimecodeUserbits3 kTimecodeUserbits3{}; + void set_timecode_userbits3(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TimecodeUserbits3::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Timestamp = + ::protozero::proto_utils::FieldMetadata< + 15, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + Vb2V4l2DqbufFtraceEvent>; + + static constexpr FieldMetadata_Timestamp kTimestamp{}; + void set_timestamp(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Timestamp::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } +}; + +class Vb2V4l2QbufFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Vb2V4l2QbufFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Vb2V4l2QbufFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Vb2V4l2QbufFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_field() const { return at<1>().valid(); } + uint32_t field() const { return at<1>().as_uint32(); } + bool has_flags() const { return at<2>().valid(); } + uint32_t flags() const { return at<2>().as_uint32(); } + bool has_minor() const { return at<3>().valid(); } + int32_t minor() const { return at<3>().as_int32(); } + bool has_sequence() const { return at<4>().valid(); } + uint32_t sequence() const { return at<4>().as_uint32(); } + bool has_timecode_flags() const { return at<5>().valid(); } + uint32_t timecode_flags() const { return at<5>().as_uint32(); } + bool has_timecode_frames() const { return at<6>().valid(); } + uint32_t timecode_frames() const { return at<6>().as_uint32(); } + bool has_timecode_hours() const { return at<7>().valid(); } + uint32_t timecode_hours() const { return at<7>().as_uint32(); } + bool has_timecode_minutes() const { return at<8>().valid(); } + uint32_t timecode_minutes() const { return at<8>().as_uint32(); } + bool has_timecode_seconds() const { return at<9>().valid(); } + uint32_t timecode_seconds() const { return at<9>().as_uint32(); } + bool has_timecode_type() const { return at<10>().valid(); } + uint32_t timecode_type() const { return at<10>().as_uint32(); } + bool has_timecode_userbits0() const { return at<11>().valid(); } + uint32_t timecode_userbits0() const { return at<11>().as_uint32(); } + bool has_timecode_userbits1() const { return at<12>().valid(); } + uint32_t timecode_userbits1() const { return at<12>().as_uint32(); } + bool has_timecode_userbits2() const { return at<13>().valid(); } + uint32_t timecode_userbits2() const { return at<13>().as_uint32(); } + bool has_timecode_userbits3() const { return at<14>().valid(); } + uint32_t timecode_userbits3() const { return at<14>().as_uint32(); } + bool has_timestamp() const { return at<15>().valid(); } + int64_t timestamp() const { return at<15>().as_int64(); } +}; + +class Vb2V4l2QbufFtraceEvent : public ::protozero::Message { + public: + using Decoder = Vb2V4l2QbufFtraceEvent_Decoder; + enum : int32_t { + kFieldFieldNumber = 1, + kFlagsFieldNumber = 2, + kMinorFieldNumber = 3, + kSequenceFieldNumber = 4, + kTimecodeFlagsFieldNumber = 5, + kTimecodeFramesFieldNumber = 6, + kTimecodeHoursFieldNumber = 7, + kTimecodeMinutesFieldNumber = 8, + kTimecodeSecondsFieldNumber = 9, + kTimecodeTypeFieldNumber = 10, + kTimecodeUserbits0FieldNumber = 11, + kTimecodeUserbits1FieldNumber = 12, + kTimecodeUserbits2FieldNumber = 13, + kTimecodeUserbits3FieldNumber = 14, + kTimestampFieldNumber = 15, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Vb2V4l2QbufFtraceEvent"; } + + + using FieldMetadata_Field = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Vb2V4l2QbufFtraceEvent>; + + static constexpr FieldMetadata_Field kField{}; + void set_field(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Field::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Flags = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Vb2V4l2QbufFtraceEvent>; + + static constexpr FieldMetadata_Flags kFlags{}; + void set_flags(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Minor = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Vb2V4l2QbufFtraceEvent>; + + static constexpr FieldMetadata_Minor kMinor{}; + void set_minor(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Minor::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Sequence = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Vb2V4l2QbufFtraceEvent>; + + static constexpr FieldMetadata_Sequence kSequence{}; + void set_sequence(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Sequence::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TimecodeFlags = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Vb2V4l2QbufFtraceEvent>; + + static constexpr FieldMetadata_TimecodeFlags kTimecodeFlags{}; + void set_timecode_flags(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TimecodeFlags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TimecodeFrames = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Vb2V4l2QbufFtraceEvent>; + + static constexpr FieldMetadata_TimecodeFrames kTimecodeFrames{}; + void set_timecode_frames(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TimecodeFrames::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TimecodeHours = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Vb2V4l2QbufFtraceEvent>; + + static constexpr FieldMetadata_TimecodeHours kTimecodeHours{}; + void set_timecode_hours(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TimecodeHours::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TimecodeMinutes = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Vb2V4l2QbufFtraceEvent>; + + static constexpr FieldMetadata_TimecodeMinutes kTimecodeMinutes{}; + void set_timecode_minutes(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TimecodeMinutes::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TimecodeSeconds = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Vb2V4l2QbufFtraceEvent>; + + static constexpr FieldMetadata_TimecodeSeconds kTimecodeSeconds{}; + void set_timecode_seconds(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TimecodeSeconds::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TimecodeType = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Vb2V4l2QbufFtraceEvent>; + + static constexpr FieldMetadata_TimecodeType kTimecodeType{}; + void set_timecode_type(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TimecodeType::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TimecodeUserbits0 = + ::protozero::proto_utils::FieldMetadata< + 11, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Vb2V4l2QbufFtraceEvent>; + + static constexpr FieldMetadata_TimecodeUserbits0 kTimecodeUserbits0{}; + void set_timecode_userbits0(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TimecodeUserbits0::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TimecodeUserbits1 = + ::protozero::proto_utils::FieldMetadata< + 12, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Vb2V4l2QbufFtraceEvent>; + + static constexpr FieldMetadata_TimecodeUserbits1 kTimecodeUserbits1{}; + void set_timecode_userbits1(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TimecodeUserbits1::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TimecodeUserbits2 = + ::protozero::proto_utils::FieldMetadata< + 13, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Vb2V4l2QbufFtraceEvent>; + + static constexpr FieldMetadata_TimecodeUserbits2 kTimecodeUserbits2{}; + void set_timecode_userbits2(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TimecodeUserbits2::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TimecodeUserbits3 = + ::protozero::proto_utils::FieldMetadata< + 14, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Vb2V4l2QbufFtraceEvent>; + + static constexpr FieldMetadata_TimecodeUserbits3 kTimecodeUserbits3{}; + void set_timecode_userbits3(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TimecodeUserbits3::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Timestamp = + ::protozero::proto_utils::FieldMetadata< + 15, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + Vb2V4l2QbufFtraceEvent>; + + static constexpr FieldMetadata_Timestamp kTimestamp{}; + void set_timestamp(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Timestamp::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } +}; + +class Vb2V4l2BufDoneFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Vb2V4l2BufDoneFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Vb2V4l2BufDoneFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Vb2V4l2BufDoneFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_field() const { return at<1>().valid(); } + uint32_t field() const { return at<1>().as_uint32(); } + bool has_flags() const { return at<2>().valid(); } + uint32_t flags() const { return at<2>().as_uint32(); } + bool has_minor() const { return at<3>().valid(); } + int32_t minor() const { return at<3>().as_int32(); } + bool has_sequence() const { return at<4>().valid(); } + uint32_t sequence() const { return at<4>().as_uint32(); } + bool has_timecode_flags() const { return at<5>().valid(); } + uint32_t timecode_flags() const { return at<5>().as_uint32(); } + bool has_timecode_frames() const { return at<6>().valid(); } + uint32_t timecode_frames() const { return at<6>().as_uint32(); } + bool has_timecode_hours() const { return at<7>().valid(); } + uint32_t timecode_hours() const { return at<7>().as_uint32(); } + bool has_timecode_minutes() const { return at<8>().valid(); } + uint32_t timecode_minutes() const { return at<8>().as_uint32(); } + bool has_timecode_seconds() const { return at<9>().valid(); } + uint32_t timecode_seconds() const { return at<9>().as_uint32(); } + bool has_timecode_type() const { return at<10>().valid(); } + uint32_t timecode_type() const { return at<10>().as_uint32(); } + bool has_timecode_userbits0() const { return at<11>().valid(); } + uint32_t timecode_userbits0() const { return at<11>().as_uint32(); } + bool has_timecode_userbits1() const { return at<12>().valid(); } + uint32_t timecode_userbits1() const { return at<12>().as_uint32(); } + bool has_timecode_userbits2() const { return at<13>().valid(); } + uint32_t timecode_userbits2() const { return at<13>().as_uint32(); } + bool has_timecode_userbits3() const { return at<14>().valid(); } + uint32_t timecode_userbits3() const { return at<14>().as_uint32(); } + bool has_timestamp() const { return at<15>().valid(); } + int64_t timestamp() const { return at<15>().as_int64(); } +}; + +class Vb2V4l2BufDoneFtraceEvent : public ::protozero::Message { + public: + using Decoder = Vb2V4l2BufDoneFtraceEvent_Decoder; + enum : int32_t { + kFieldFieldNumber = 1, + kFlagsFieldNumber = 2, + kMinorFieldNumber = 3, + kSequenceFieldNumber = 4, + kTimecodeFlagsFieldNumber = 5, + kTimecodeFramesFieldNumber = 6, + kTimecodeHoursFieldNumber = 7, + kTimecodeMinutesFieldNumber = 8, + kTimecodeSecondsFieldNumber = 9, + kTimecodeTypeFieldNumber = 10, + kTimecodeUserbits0FieldNumber = 11, + kTimecodeUserbits1FieldNumber = 12, + kTimecodeUserbits2FieldNumber = 13, + kTimecodeUserbits3FieldNumber = 14, + kTimestampFieldNumber = 15, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Vb2V4l2BufDoneFtraceEvent"; } + + + using FieldMetadata_Field = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Vb2V4l2BufDoneFtraceEvent>; + + static constexpr FieldMetadata_Field kField{}; + void set_field(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Field::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Flags = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Vb2V4l2BufDoneFtraceEvent>; + + static constexpr FieldMetadata_Flags kFlags{}; + void set_flags(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Minor = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Vb2V4l2BufDoneFtraceEvent>; + + static constexpr FieldMetadata_Minor kMinor{}; + void set_minor(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Minor::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Sequence = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Vb2V4l2BufDoneFtraceEvent>; + + static constexpr FieldMetadata_Sequence kSequence{}; + void set_sequence(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Sequence::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TimecodeFlags = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Vb2V4l2BufDoneFtraceEvent>; + + static constexpr FieldMetadata_TimecodeFlags kTimecodeFlags{}; + void set_timecode_flags(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TimecodeFlags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TimecodeFrames = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Vb2V4l2BufDoneFtraceEvent>; + + static constexpr FieldMetadata_TimecodeFrames kTimecodeFrames{}; + void set_timecode_frames(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TimecodeFrames::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TimecodeHours = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Vb2V4l2BufDoneFtraceEvent>; + + static constexpr FieldMetadata_TimecodeHours kTimecodeHours{}; + void set_timecode_hours(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TimecodeHours::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TimecodeMinutes = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Vb2V4l2BufDoneFtraceEvent>; + + static constexpr FieldMetadata_TimecodeMinutes kTimecodeMinutes{}; + void set_timecode_minutes(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TimecodeMinutes::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TimecodeSeconds = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Vb2V4l2BufDoneFtraceEvent>; + + static constexpr FieldMetadata_TimecodeSeconds kTimecodeSeconds{}; + void set_timecode_seconds(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TimecodeSeconds::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TimecodeType = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Vb2V4l2BufDoneFtraceEvent>; + + static constexpr FieldMetadata_TimecodeType kTimecodeType{}; + void set_timecode_type(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TimecodeType::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TimecodeUserbits0 = + ::protozero::proto_utils::FieldMetadata< + 11, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Vb2V4l2BufDoneFtraceEvent>; + + static constexpr FieldMetadata_TimecodeUserbits0 kTimecodeUserbits0{}; + void set_timecode_userbits0(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TimecodeUserbits0::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TimecodeUserbits1 = + ::protozero::proto_utils::FieldMetadata< + 12, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Vb2V4l2BufDoneFtraceEvent>; + + static constexpr FieldMetadata_TimecodeUserbits1 kTimecodeUserbits1{}; + void set_timecode_userbits1(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TimecodeUserbits1::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TimecodeUserbits2 = + ::protozero::proto_utils::FieldMetadata< + 13, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Vb2V4l2BufDoneFtraceEvent>; + + static constexpr FieldMetadata_TimecodeUserbits2 kTimecodeUserbits2{}; + void set_timecode_userbits2(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TimecodeUserbits2::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TimecodeUserbits3 = + ::protozero::proto_utils::FieldMetadata< + 14, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Vb2V4l2BufDoneFtraceEvent>; + + static constexpr FieldMetadata_TimecodeUserbits3 kTimecodeUserbits3{}; + void set_timecode_userbits3(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TimecodeUserbits3::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Timestamp = + ::protozero::proto_utils::FieldMetadata< + 15, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + Vb2V4l2BufDoneFtraceEvent>; + + static constexpr FieldMetadata_Timestamp kTimestamp{}; + void set_timestamp(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Timestamp::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } +}; + +class Vb2V4l2BufQueueFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Vb2V4l2BufQueueFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Vb2V4l2BufQueueFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Vb2V4l2BufQueueFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_field() const { return at<1>().valid(); } + uint32_t field() const { return at<1>().as_uint32(); } + bool has_flags() const { return at<2>().valid(); } + uint32_t flags() const { return at<2>().as_uint32(); } + bool has_minor() const { return at<3>().valid(); } + int32_t minor() const { return at<3>().as_int32(); } + bool has_sequence() const { return at<4>().valid(); } + uint32_t sequence() const { return at<4>().as_uint32(); } + bool has_timecode_flags() const { return at<5>().valid(); } + uint32_t timecode_flags() const { return at<5>().as_uint32(); } + bool has_timecode_frames() const { return at<6>().valid(); } + uint32_t timecode_frames() const { return at<6>().as_uint32(); } + bool has_timecode_hours() const { return at<7>().valid(); } + uint32_t timecode_hours() const { return at<7>().as_uint32(); } + bool has_timecode_minutes() const { return at<8>().valid(); } + uint32_t timecode_minutes() const { return at<8>().as_uint32(); } + bool has_timecode_seconds() const { return at<9>().valid(); } + uint32_t timecode_seconds() const { return at<9>().as_uint32(); } + bool has_timecode_type() const { return at<10>().valid(); } + uint32_t timecode_type() const { return at<10>().as_uint32(); } + bool has_timecode_userbits0() const { return at<11>().valid(); } + uint32_t timecode_userbits0() const { return at<11>().as_uint32(); } + bool has_timecode_userbits1() const { return at<12>().valid(); } + uint32_t timecode_userbits1() const { return at<12>().as_uint32(); } + bool has_timecode_userbits2() const { return at<13>().valid(); } + uint32_t timecode_userbits2() const { return at<13>().as_uint32(); } + bool has_timecode_userbits3() const { return at<14>().valid(); } + uint32_t timecode_userbits3() const { return at<14>().as_uint32(); } + bool has_timestamp() const { return at<15>().valid(); } + int64_t timestamp() const { return at<15>().as_int64(); } +}; + +class Vb2V4l2BufQueueFtraceEvent : public ::protozero::Message { + public: + using Decoder = Vb2V4l2BufQueueFtraceEvent_Decoder; + enum : int32_t { + kFieldFieldNumber = 1, + kFlagsFieldNumber = 2, + kMinorFieldNumber = 3, + kSequenceFieldNumber = 4, + kTimecodeFlagsFieldNumber = 5, + kTimecodeFramesFieldNumber = 6, + kTimecodeHoursFieldNumber = 7, + kTimecodeMinutesFieldNumber = 8, + kTimecodeSecondsFieldNumber = 9, + kTimecodeTypeFieldNumber = 10, + kTimecodeUserbits0FieldNumber = 11, + kTimecodeUserbits1FieldNumber = 12, + kTimecodeUserbits2FieldNumber = 13, + kTimecodeUserbits3FieldNumber = 14, + kTimestampFieldNumber = 15, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Vb2V4l2BufQueueFtraceEvent"; } + + + using FieldMetadata_Field = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Vb2V4l2BufQueueFtraceEvent>; + + static constexpr FieldMetadata_Field kField{}; + void set_field(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Field::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Flags = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Vb2V4l2BufQueueFtraceEvent>; + + static constexpr FieldMetadata_Flags kFlags{}; + void set_flags(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Minor = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Vb2V4l2BufQueueFtraceEvent>; + + static constexpr FieldMetadata_Minor kMinor{}; + void set_minor(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Minor::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Sequence = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Vb2V4l2BufQueueFtraceEvent>; + + static constexpr FieldMetadata_Sequence kSequence{}; + void set_sequence(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Sequence::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TimecodeFlags = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Vb2V4l2BufQueueFtraceEvent>; + + static constexpr FieldMetadata_TimecodeFlags kTimecodeFlags{}; + void set_timecode_flags(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TimecodeFlags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TimecodeFrames = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Vb2V4l2BufQueueFtraceEvent>; + + static constexpr FieldMetadata_TimecodeFrames kTimecodeFrames{}; + void set_timecode_frames(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TimecodeFrames::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TimecodeHours = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Vb2V4l2BufQueueFtraceEvent>; + + static constexpr FieldMetadata_TimecodeHours kTimecodeHours{}; + void set_timecode_hours(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TimecodeHours::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TimecodeMinutes = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Vb2V4l2BufQueueFtraceEvent>; + + static constexpr FieldMetadata_TimecodeMinutes kTimecodeMinutes{}; + void set_timecode_minutes(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TimecodeMinutes::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TimecodeSeconds = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Vb2V4l2BufQueueFtraceEvent>; + + static constexpr FieldMetadata_TimecodeSeconds kTimecodeSeconds{}; + void set_timecode_seconds(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TimecodeSeconds::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TimecodeType = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Vb2V4l2BufQueueFtraceEvent>; + + static constexpr FieldMetadata_TimecodeType kTimecodeType{}; + void set_timecode_type(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TimecodeType::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TimecodeUserbits0 = + ::protozero::proto_utils::FieldMetadata< + 11, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Vb2V4l2BufQueueFtraceEvent>; + + static constexpr FieldMetadata_TimecodeUserbits0 kTimecodeUserbits0{}; + void set_timecode_userbits0(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TimecodeUserbits0::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TimecodeUserbits1 = + ::protozero::proto_utils::FieldMetadata< + 12, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Vb2V4l2BufQueueFtraceEvent>; + + static constexpr FieldMetadata_TimecodeUserbits1 kTimecodeUserbits1{}; + void set_timecode_userbits1(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TimecodeUserbits1::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TimecodeUserbits2 = + ::protozero::proto_utils::FieldMetadata< + 13, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Vb2V4l2BufQueueFtraceEvent>; + + static constexpr FieldMetadata_TimecodeUserbits2 kTimecodeUserbits2{}; + void set_timecode_userbits2(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TimecodeUserbits2::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TimecodeUserbits3 = + ::protozero::proto_utils::FieldMetadata< + 14, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Vb2V4l2BufQueueFtraceEvent>; + + static constexpr FieldMetadata_TimecodeUserbits3 kTimecodeUserbits3{}; + void set_timecode_userbits3(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TimecodeUserbits3::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Timestamp = + ::protozero::proto_utils::FieldMetadata< + 15, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + Vb2V4l2BufQueueFtraceEvent>; + + static constexpr FieldMetadata_Timestamp kTimestamp{}; + void set_timestamp(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Timestamp::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } +}; + +class V4l2DqbufFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + V4l2DqbufFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit V4l2DqbufFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit V4l2DqbufFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_bytesused() const { return at<1>().valid(); } + uint32_t bytesused() const { return at<1>().as_uint32(); } + bool has_field() const { return at<2>().valid(); } + uint32_t field() const { return at<2>().as_uint32(); } + bool has_flags() const { return at<3>().valid(); } + uint32_t flags() const { return at<3>().as_uint32(); } + bool has_index() const { return at<4>().valid(); } + uint32_t index() const { return at<4>().as_uint32(); } + bool has_minor() const { return at<5>().valid(); } + int32_t minor() const { return at<5>().as_int32(); } + bool has_sequence() const { return at<6>().valid(); } + uint32_t sequence() const { return at<6>().as_uint32(); } + bool has_timecode_flags() const { return at<7>().valid(); } + uint32_t timecode_flags() const { return at<7>().as_uint32(); } + bool has_timecode_frames() const { return at<8>().valid(); } + uint32_t timecode_frames() const { return at<8>().as_uint32(); } + bool has_timecode_hours() const { return at<9>().valid(); } + uint32_t timecode_hours() const { return at<9>().as_uint32(); } + bool has_timecode_minutes() const { return at<10>().valid(); } + uint32_t timecode_minutes() const { return at<10>().as_uint32(); } + bool has_timecode_seconds() const { return at<11>().valid(); } + uint32_t timecode_seconds() const { return at<11>().as_uint32(); } + bool has_timecode_type() const { return at<12>().valid(); } + uint32_t timecode_type() const { return at<12>().as_uint32(); } + bool has_timecode_userbits0() const { return at<13>().valid(); } + uint32_t timecode_userbits0() const { return at<13>().as_uint32(); } + bool has_timecode_userbits1() const { return at<14>().valid(); } + uint32_t timecode_userbits1() const { return at<14>().as_uint32(); } + bool has_timecode_userbits2() const { return at<15>().valid(); } + uint32_t timecode_userbits2() const { return at<15>().as_uint32(); } + bool has_timecode_userbits3() const { return at<16>().valid(); } + uint32_t timecode_userbits3() const { return at<16>().as_uint32(); } + bool has_timestamp() const { return at<17>().valid(); } + int64_t timestamp() const { return at<17>().as_int64(); } + bool has_type() const { return at<18>().valid(); } + uint32_t type() const { return at<18>().as_uint32(); } +}; + +class V4l2DqbufFtraceEvent : public ::protozero::Message { + public: + using Decoder = V4l2DqbufFtraceEvent_Decoder; + enum : int32_t { + kBytesusedFieldNumber = 1, + kFieldFieldNumber = 2, + kFlagsFieldNumber = 3, + kIndexFieldNumber = 4, + kMinorFieldNumber = 5, + kSequenceFieldNumber = 6, + kTimecodeFlagsFieldNumber = 7, + kTimecodeFramesFieldNumber = 8, + kTimecodeHoursFieldNumber = 9, + kTimecodeMinutesFieldNumber = 10, + kTimecodeSecondsFieldNumber = 11, + kTimecodeTypeFieldNumber = 12, + kTimecodeUserbits0FieldNumber = 13, + kTimecodeUserbits1FieldNumber = 14, + kTimecodeUserbits2FieldNumber = 15, + kTimecodeUserbits3FieldNumber = 16, + kTimestampFieldNumber = 17, + kTypeFieldNumber = 18, + }; + static constexpr const char* GetName() { return ".perfetto.protos.V4l2DqbufFtraceEvent"; } + + + using FieldMetadata_Bytesused = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + V4l2DqbufFtraceEvent>; + + static constexpr FieldMetadata_Bytesused kBytesused{}; + void set_bytesused(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Bytesused::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Field = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + V4l2DqbufFtraceEvent>; + + static constexpr FieldMetadata_Field kField{}; + void set_field(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Field::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Flags = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + V4l2DqbufFtraceEvent>; + + static constexpr FieldMetadata_Flags kFlags{}; + void set_flags(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Index = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + V4l2DqbufFtraceEvent>; + + static constexpr FieldMetadata_Index kIndex{}; + void set_index(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Index::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Minor = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + V4l2DqbufFtraceEvent>; + + static constexpr FieldMetadata_Minor kMinor{}; + void set_minor(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Minor::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Sequence = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + V4l2DqbufFtraceEvent>; + + static constexpr FieldMetadata_Sequence kSequence{}; + void set_sequence(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Sequence::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TimecodeFlags = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + V4l2DqbufFtraceEvent>; + + static constexpr FieldMetadata_TimecodeFlags kTimecodeFlags{}; + void set_timecode_flags(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TimecodeFlags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TimecodeFrames = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + V4l2DqbufFtraceEvent>; + + static constexpr FieldMetadata_TimecodeFrames kTimecodeFrames{}; + void set_timecode_frames(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TimecodeFrames::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TimecodeHours = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + V4l2DqbufFtraceEvent>; + + static constexpr FieldMetadata_TimecodeHours kTimecodeHours{}; + void set_timecode_hours(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TimecodeHours::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TimecodeMinutes = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + V4l2DqbufFtraceEvent>; + + static constexpr FieldMetadata_TimecodeMinutes kTimecodeMinutes{}; + void set_timecode_minutes(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TimecodeMinutes::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TimecodeSeconds = + ::protozero::proto_utils::FieldMetadata< + 11, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + V4l2DqbufFtraceEvent>; + + static constexpr FieldMetadata_TimecodeSeconds kTimecodeSeconds{}; + void set_timecode_seconds(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TimecodeSeconds::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TimecodeType = + ::protozero::proto_utils::FieldMetadata< + 12, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + V4l2DqbufFtraceEvent>; + + static constexpr FieldMetadata_TimecodeType kTimecodeType{}; + void set_timecode_type(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TimecodeType::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TimecodeUserbits0 = + ::protozero::proto_utils::FieldMetadata< + 13, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + V4l2DqbufFtraceEvent>; + + static constexpr FieldMetadata_TimecodeUserbits0 kTimecodeUserbits0{}; + void set_timecode_userbits0(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TimecodeUserbits0::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TimecodeUserbits1 = + ::protozero::proto_utils::FieldMetadata< + 14, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + V4l2DqbufFtraceEvent>; + + static constexpr FieldMetadata_TimecodeUserbits1 kTimecodeUserbits1{}; + void set_timecode_userbits1(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TimecodeUserbits1::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TimecodeUserbits2 = + ::protozero::proto_utils::FieldMetadata< + 15, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + V4l2DqbufFtraceEvent>; + + static constexpr FieldMetadata_TimecodeUserbits2 kTimecodeUserbits2{}; + void set_timecode_userbits2(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TimecodeUserbits2::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TimecodeUserbits3 = + ::protozero::proto_utils::FieldMetadata< + 16, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + V4l2DqbufFtraceEvent>; + + static constexpr FieldMetadata_TimecodeUserbits3 kTimecodeUserbits3{}; + void set_timecode_userbits3(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TimecodeUserbits3::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Timestamp = + ::protozero::proto_utils::FieldMetadata< + 17, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + V4l2DqbufFtraceEvent>; + + static constexpr FieldMetadata_Timestamp kTimestamp{}; + void set_timestamp(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Timestamp::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Type = + ::protozero::proto_utils::FieldMetadata< + 18, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + V4l2DqbufFtraceEvent>; + + static constexpr FieldMetadata_Type kType{}; + void set_type(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class V4l2QbufFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + V4l2QbufFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit V4l2QbufFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit V4l2QbufFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_bytesused() const { return at<1>().valid(); } + uint32_t bytesused() const { return at<1>().as_uint32(); } + bool has_field() const { return at<2>().valid(); } + uint32_t field() const { return at<2>().as_uint32(); } + bool has_flags() const { return at<3>().valid(); } + uint32_t flags() const { return at<3>().as_uint32(); } + bool has_index() const { return at<4>().valid(); } + uint32_t index() const { return at<4>().as_uint32(); } + bool has_minor() const { return at<5>().valid(); } + int32_t minor() const { return at<5>().as_int32(); } + bool has_sequence() const { return at<6>().valid(); } + uint32_t sequence() const { return at<6>().as_uint32(); } + bool has_timecode_flags() const { return at<7>().valid(); } + uint32_t timecode_flags() const { return at<7>().as_uint32(); } + bool has_timecode_frames() const { return at<8>().valid(); } + uint32_t timecode_frames() const { return at<8>().as_uint32(); } + bool has_timecode_hours() const { return at<9>().valid(); } + uint32_t timecode_hours() const { return at<9>().as_uint32(); } + bool has_timecode_minutes() const { return at<10>().valid(); } + uint32_t timecode_minutes() const { return at<10>().as_uint32(); } + bool has_timecode_seconds() const { return at<11>().valid(); } + uint32_t timecode_seconds() const { return at<11>().as_uint32(); } + bool has_timecode_type() const { return at<12>().valid(); } + uint32_t timecode_type() const { return at<12>().as_uint32(); } + bool has_timecode_userbits0() const { return at<13>().valid(); } + uint32_t timecode_userbits0() const { return at<13>().as_uint32(); } + bool has_timecode_userbits1() const { return at<14>().valid(); } + uint32_t timecode_userbits1() const { return at<14>().as_uint32(); } + bool has_timecode_userbits2() const { return at<15>().valid(); } + uint32_t timecode_userbits2() const { return at<15>().as_uint32(); } + bool has_timecode_userbits3() const { return at<16>().valid(); } + uint32_t timecode_userbits3() const { return at<16>().as_uint32(); } + bool has_timestamp() const { return at<17>().valid(); } + int64_t timestamp() const { return at<17>().as_int64(); } + bool has_type() const { return at<18>().valid(); } + uint32_t type() const { return at<18>().as_uint32(); } +}; + +class V4l2QbufFtraceEvent : public ::protozero::Message { + public: + using Decoder = V4l2QbufFtraceEvent_Decoder; + enum : int32_t { + kBytesusedFieldNumber = 1, + kFieldFieldNumber = 2, + kFlagsFieldNumber = 3, + kIndexFieldNumber = 4, + kMinorFieldNumber = 5, + kSequenceFieldNumber = 6, + kTimecodeFlagsFieldNumber = 7, + kTimecodeFramesFieldNumber = 8, + kTimecodeHoursFieldNumber = 9, + kTimecodeMinutesFieldNumber = 10, + kTimecodeSecondsFieldNumber = 11, + kTimecodeTypeFieldNumber = 12, + kTimecodeUserbits0FieldNumber = 13, + kTimecodeUserbits1FieldNumber = 14, + kTimecodeUserbits2FieldNumber = 15, + kTimecodeUserbits3FieldNumber = 16, + kTimestampFieldNumber = 17, + kTypeFieldNumber = 18, + }; + static constexpr const char* GetName() { return ".perfetto.protos.V4l2QbufFtraceEvent"; } + + + using FieldMetadata_Bytesused = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + V4l2QbufFtraceEvent>; + + static constexpr FieldMetadata_Bytesused kBytesused{}; + void set_bytesused(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Bytesused::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Field = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + V4l2QbufFtraceEvent>; + + static constexpr FieldMetadata_Field kField{}; + void set_field(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Field::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Flags = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + V4l2QbufFtraceEvent>; + + static constexpr FieldMetadata_Flags kFlags{}; + void set_flags(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Index = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + V4l2QbufFtraceEvent>; + + static constexpr FieldMetadata_Index kIndex{}; + void set_index(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Index::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Minor = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + V4l2QbufFtraceEvent>; + + static constexpr FieldMetadata_Minor kMinor{}; + void set_minor(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Minor::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Sequence = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + V4l2QbufFtraceEvent>; + + static constexpr FieldMetadata_Sequence kSequence{}; + void set_sequence(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Sequence::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TimecodeFlags = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + V4l2QbufFtraceEvent>; + + static constexpr FieldMetadata_TimecodeFlags kTimecodeFlags{}; + void set_timecode_flags(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TimecodeFlags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TimecodeFrames = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + V4l2QbufFtraceEvent>; + + static constexpr FieldMetadata_TimecodeFrames kTimecodeFrames{}; + void set_timecode_frames(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TimecodeFrames::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TimecodeHours = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + V4l2QbufFtraceEvent>; + + static constexpr FieldMetadata_TimecodeHours kTimecodeHours{}; + void set_timecode_hours(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TimecodeHours::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TimecodeMinutes = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + V4l2QbufFtraceEvent>; + + static constexpr FieldMetadata_TimecodeMinutes kTimecodeMinutes{}; + void set_timecode_minutes(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TimecodeMinutes::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TimecodeSeconds = + ::protozero::proto_utils::FieldMetadata< + 11, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + V4l2QbufFtraceEvent>; + + static constexpr FieldMetadata_TimecodeSeconds kTimecodeSeconds{}; + void set_timecode_seconds(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TimecodeSeconds::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TimecodeType = + ::protozero::proto_utils::FieldMetadata< + 12, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + V4l2QbufFtraceEvent>; + + static constexpr FieldMetadata_TimecodeType kTimecodeType{}; + void set_timecode_type(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TimecodeType::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TimecodeUserbits0 = + ::protozero::proto_utils::FieldMetadata< + 13, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + V4l2QbufFtraceEvent>; + + static constexpr FieldMetadata_TimecodeUserbits0 kTimecodeUserbits0{}; + void set_timecode_userbits0(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TimecodeUserbits0::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TimecodeUserbits1 = + ::protozero::proto_utils::FieldMetadata< + 14, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + V4l2QbufFtraceEvent>; + + static constexpr FieldMetadata_TimecodeUserbits1 kTimecodeUserbits1{}; + void set_timecode_userbits1(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TimecodeUserbits1::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TimecodeUserbits2 = + ::protozero::proto_utils::FieldMetadata< + 15, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + V4l2QbufFtraceEvent>; + + static constexpr FieldMetadata_TimecodeUserbits2 kTimecodeUserbits2{}; + void set_timecode_userbits2(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TimecodeUserbits2::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TimecodeUserbits3 = + ::protozero::proto_utils::FieldMetadata< + 16, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + V4l2QbufFtraceEvent>; + + static constexpr FieldMetadata_TimecodeUserbits3 kTimecodeUserbits3{}; + void set_timecode_userbits3(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TimecodeUserbits3::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Timestamp = + ::protozero::proto_utils::FieldMetadata< + 17, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + V4l2QbufFtraceEvent>; + + static constexpr FieldMetadata_Timestamp kTimestamp{}; + void set_timestamp(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Timestamp::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Type = + ::protozero::proto_utils::FieldMetadata< + 18, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + V4l2QbufFtraceEvent>; + + static constexpr FieldMetadata_Type kType{}; + void set_type(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class UfshcdClkGatingFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + UfshcdClkGatingFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit UfshcdClkGatingFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit UfshcdClkGatingFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev_name() const { return at<1>().valid(); } + ::protozero::ConstChars dev_name() const { return at<1>().as_string(); } + bool has_state() const { return at<2>().valid(); } + int32_t state() const { return at<2>().as_int32(); } +}; + +class UfshcdClkGatingFtraceEvent : public ::protozero::Message { + public: + using Decoder = UfshcdClkGatingFtraceEvent_Decoder; + enum : int32_t { + kDevNameFieldNumber = 1, + kStateFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.UfshcdClkGatingFtraceEvent"; } + + + using FieldMetadata_DevName = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + UfshcdClkGatingFtraceEvent>; + + static constexpr FieldMetadata_DevName kDevName{}; + void set_dev_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_DevName::kFieldId, data, size); + } + void set_dev_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_DevName::kFieldId, chars.data, chars.size); + } + void set_dev_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_DevName::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_State = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + UfshcdClkGatingFtraceEvent>; + + static constexpr FieldMetadata_State kState{}; + void set_state(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_State::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class UfshcdCommandFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + UfshcdCommandFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit UfshcdCommandFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit UfshcdCommandFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev_name() const { return at<1>().valid(); } + ::protozero::ConstChars dev_name() const { return at<1>().as_string(); } + bool has_doorbell() const { return at<2>().valid(); } + uint32_t doorbell() const { return at<2>().as_uint32(); } + bool has_intr() const { return at<3>().valid(); } + uint32_t intr() const { return at<3>().as_uint32(); } + bool has_lba() const { return at<4>().valid(); } + uint64_t lba() const { return at<4>().as_uint64(); } + bool has_opcode() const { return at<5>().valid(); } + uint32_t opcode() const { return at<5>().as_uint32(); } + bool has_str() const { return at<6>().valid(); } + ::protozero::ConstChars str() const { return at<6>().as_string(); } + bool has_tag() const { return at<7>().valid(); } + uint32_t tag() const { return at<7>().as_uint32(); } + bool has_transfer_len() const { return at<8>().valid(); } + int32_t transfer_len() const { return at<8>().as_int32(); } + bool has_group_id() const { return at<9>().valid(); } + uint32_t group_id() const { return at<9>().as_uint32(); } + bool has_str_t() const { return at<10>().valid(); } + uint32_t str_t() const { return at<10>().as_uint32(); } +}; + +class UfshcdCommandFtraceEvent : public ::protozero::Message { + public: + using Decoder = UfshcdCommandFtraceEvent_Decoder; + enum : int32_t { + kDevNameFieldNumber = 1, + kDoorbellFieldNumber = 2, + kIntrFieldNumber = 3, + kLbaFieldNumber = 4, + kOpcodeFieldNumber = 5, + kStrFieldNumber = 6, + kTagFieldNumber = 7, + kTransferLenFieldNumber = 8, + kGroupIdFieldNumber = 9, + kStrTFieldNumber = 10, + }; + static constexpr const char* GetName() { return ".perfetto.protos.UfshcdCommandFtraceEvent"; } + + + using FieldMetadata_DevName = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + UfshcdCommandFtraceEvent>; + + static constexpr FieldMetadata_DevName kDevName{}; + void set_dev_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_DevName::kFieldId, data, size); + } + void set_dev_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_DevName::kFieldId, chars.data, chars.size); + } + void set_dev_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_DevName::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Doorbell = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + UfshcdCommandFtraceEvent>; + + static constexpr FieldMetadata_Doorbell kDoorbell{}; + void set_doorbell(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Doorbell::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Intr = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + UfshcdCommandFtraceEvent>; + + static constexpr FieldMetadata_Intr kIntr{}; + void set_intr(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Intr::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Lba = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + UfshcdCommandFtraceEvent>; + + static constexpr FieldMetadata_Lba kLba{}; + void set_lba(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Lba::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Opcode = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + UfshcdCommandFtraceEvent>; + + static constexpr FieldMetadata_Opcode kOpcode{}; + void set_opcode(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Opcode::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Str = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + UfshcdCommandFtraceEvent>; + + static constexpr FieldMetadata_Str kStr{}; + void set_str(const char* data, size_t size) { + AppendBytes(FieldMetadata_Str::kFieldId, data, size); + } + void set_str(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Str::kFieldId, chars.data, chars.size); + } + void set_str(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Str::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Tag = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + UfshcdCommandFtraceEvent>; + + static constexpr FieldMetadata_Tag kTag{}; + void set_tag(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Tag::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TransferLen = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + UfshcdCommandFtraceEvent>; + + static constexpr FieldMetadata_TransferLen kTransferLen{}; + void set_transfer_len(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TransferLen::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_GroupId = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + UfshcdCommandFtraceEvent>; + + static constexpr FieldMetadata_GroupId kGroupId{}; + void set_group_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_GroupId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_StrT = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + UfshcdCommandFtraceEvent>; + + static constexpr FieldMetadata_StrT kStrT{}; + void set_str_t(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_StrT::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class TrustyEnqueueNopFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + TrustyEnqueueNopFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TrustyEnqueueNopFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TrustyEnqueueNopFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_arg1() const { return at<1>().valid(); } + uint32_t arg1() const { return at<1>().as_uint32(); } + bool has_arg2() const { return at<2>().valid(); } + uint32_t arg2() const { return at<2>().as_uint32(); } + bool has_arg3() const { return at<3>().valid(); } + uint32_t arg3() const { return at<3>().as_uint32(); } +}; + +class TrustyEnqueueNopFtraceEvent : public ::protozero::Message { + public: + using Decoder = TrustyEnqueueNopFtraceEvent_Decoder; + enum : int32_t { + kArg1FieldNumber = 1, + kArg2FieldNumber = 2, + kArg3FieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.TrustyEnqueueNopFtraceEvent"; } + + + using FieldMetadata_Arg1 = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + TrustyEnqueueNopFtraceEvent>; + + static constexpr FieldMetadata_Arg1 kArg1{}; + void set_arg1(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Arg1::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Arg2 = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + TrustyEnqueueNopFtraceEvent>; + + static constexpr FieldMetadata_Arg2 kArg2{}; + void set_arg2(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Arg2::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Arg3 = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + TrustyEnqueueNopFtraceEvent>; + + static constexpr FieldMetadata_Arg3 kArg3{}; + void set_arg3(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Arg3::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class TrustyIpcRxFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + TrustyIpcRxFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TrustyIpcRxFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TrustyIpcRxFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_buf_id() const { return at<1>().valid(); } + uint64_t buf_id() const { return at<1>().as_uint64(); } + bool has_chan() const { return at<2>().valid(); } + uint32_t chan() const { return at<2>().as_uint32(); } + bool has_srv_name() const { return at<3>().valid(); } + ::protozero::ConstChars srv_name() const { return at<3>().as_string(); } +}; + +class TrustyIpcRxFtraceEvent : public ::protozero::Message { + public: + using Decoder = TrustyIpcRxFtraceEvent_Decoder; + enum : int32_t { + kBufIdFieldNumber = 1, + kChanFieldNumber = 2, + kSrvNameFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.TrustyIpcRxFtraceEvent"; } + + + using FieldMetadata_BufId = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TrustyIpcRxFtraceEvent>; + + static constexpr FieldMetadata_BufId kBufId{}; + void set_buf_id(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_BufId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Chan = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + TrustyIpcRxFtraceEvent>; + + static constexpr FieldMetadata_Chan kChan{}; + void set_chan(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Chan::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SrvName = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + TrustyIpcRxFtraceEvent>; + + static constexpr FieldMetadata_SrvName kSrvName{}; + void set_srv_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_SrvName::kFieldId, data, size); + } + void set_srv_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_SrvName::kFieldId, chars.data, chars.size); + } + void set_srv_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_SrvName::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class TrustyIpcReadEndFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + TrustyIpcReadEndFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TrustyIpcReadEndFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TrustyIpcReadEndFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_buf_id() const { return at<1>().valid(); } + uint64_t buf_id() const { return at<1>().as_uint64(); } + bool has_chan() const { return at<2>().valid(); } + uint32_t chan() const { return at<2>().as_uint32(); } + bool has_len_or_err() const { return at<3>().valid(); } + int32_t len_or_err() const { return at<3>().as_int32(); } + bool has_shm_cnt() const { return at<4>().valid(); } + uint64_t shm_cnt() const { return at<4>().as_uint64(); } + bool has_srv_name() const { return at<5>().valid(); } + ::protozero::ConstChars srv_name() const { return at<5>().as_string(); } +}; + +class TrustyIpcReadEndFtraceEvent : public ::protozero::Message { + public: + using Decoder = TrustyIpcReadEndFtraceEvent_Decoder; + enum : int32_t { + kBufIdFieldNumber = 1, + kChanFieldNumber = 2, + kLenOrErrFieldNumber = 3, + kShmCntFieldNumber = 4, + kSrvNameFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.TrustyIpcReadEndFtraceEvent"; } + + + using FieldMetadata_BufId = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TrustyIpcReadEndFtraceEvent>; + + static constexpr FieldMetadata_BufId kBufId{}; + void set_buf_id(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_BufId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Chan = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + TrustyIpcReadEndFtraceEvent>; + + static constexpr FieldMetadata_Chan kChan{}; + void set_chan(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Chan::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_LenOrErr = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + TrustyIpcReadEndFtraceEvent>; + + static constexpr FieldMetadata_LenOrErr kLenOrErr{}; + void set_len_or_err(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_LenOrErr::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ShmCnt = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TrustyIpcReadEndFtraceEvent>; + + static constexpr FieldMetadata_ShmCnt kShmCnt{}; + void set_shm_cnt(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_ShmCnt::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SrvName = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + TrustyIpcReadEndFtraceEvent>; + + static constexpr FieldMetadata_SrvName kSrvName{}; + void set_srv_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_SrvName::kFieldId, data, size); + } + void set_srv_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_SrvName::kFieldId, chars.data, chars.size); + } + void set_srv_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_SrvName::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class TrustyIpcReadFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + TrustyIpcReadFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TrustyIpcReadFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TrustyIpcReadFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_chan() const { return at<1>().valid(); } + uint32_t chan() const { return at<1>().as_uint32(); } + bool has_srv_name() const { return at<2>().valid(); } + ::protozero::ConstChars srv_name() const { return at<2>().as_string(); } +}; + +class TrustyIpcReadFtraceEvent : public ::protozero::Message { + public: + using Decoder = TrustyIpcReadFtraceEvent_Decoder; + enum : int32_t { + kChanFieldNumber = 1, + kSrvNameFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.TrustyIpcReadFtraceEvent"; } + + + using FieldMetadata_Chan = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + TrustyIpcReadFtraceEvent>; + + static constexpr FieldMetadata_Chan kChan{}; + void set_chan(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Chan::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SrvName = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + TrustyIpcReadFtraceEvent>; + + static constexpr FieldMetadata_SrvName kSrvName{}; + void set_srv_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_SrvName::kFieldId, data, size); + } + void set_srv_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_SrvName::kFieldId, chars.data, chars.size); + } + void set_srv_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_SrvName::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class TrustyIpcPollFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + TrustyIpcPollFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TrustyIpcPollFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TrustyIpcPollFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_chan() const { return at<1>().valid(); } + uint32_t chan() const { return at<1>().as_uint32(); } + bool has_poll_mask() const { return at<2>().valid(); } + uint32_t poll_mask() const { return at<2>().as_uint32(); } + bool has_srv_name() const { return at<3>().valid(); } + ::protozero::ConstChars srv_name() const { return at<3>().as_string(); } +}; + +class TrustyIpcPollFtraceEvent : public ::protozero::Message { + public: + using Decoder = TrustyIpcPollFtraceEvent_Decoder; + enum : int32_t { + kChanFieldNumber = 1, + kPollMaskFieldNumber = 2, + kSrvNameFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.TrustyIpcPollFtraceEvent"; } + + + using FieldMetadata_Chan = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + TrustyIpcPollFtraceEvent>; + + static constexpr FieldMetadata_Chan kChan{}; + void set_chan(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Chan::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PollMask = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + TrustyIpcPollFtraceEvent>; + + static constexpr FieldMetadata_PollMask kPollMask{}; + void set_poll_mask(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_PollMask::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SrvName = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + TrustyIpcPollFtraceEvent>; + + static constexpr FieldMetadata_SrvName kSrvName{}; + void set_srv_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_SrvName::kFieldId, data, size); + } + void set_srv_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_SrvName::kFieldId, chars.data, chars.size); + } + void set_srv_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_SrvName::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class TrustyIpcWriteFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + TrustyIpcWriteFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TrustyIpcWriteFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TrustyIpcWriteFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_buf_id() const { return at<1>().valid(); } + uint64_t buf_id() const { return at<1>().as_uint64(); } + bool has_chan() const { return at<2>().valid(); } + uint32_t chan() const { return at<2>().as_uint32(); } + bool has_kind_shm() const { return at<3>().valid(); } + int32_t kind_shm() const { return at<3>().as_int32(); } + bool has_len_or_err() const { return at<4>().valid(); } + int32_t len_or_err() const { return at<4>().as_int32(); } + bool has_shm_cnt() const { return at<5>().valid(); } + uint64_t shm_cnt() const { return at<5>().as_uint64(); } + bool has_srv_name() const { return at<6>().valid(); } + ::protozero::ConstChars srv_name() const { return at<6>().as_string(); } +}; + +class TrustyIpcWriteFtraceEvent : public ::protozero::Message { + public: + using Decoder = TrustyIpcWriteFtraceEvent_Decoder; + enum : int32_t { + kBufIdFieldNumber = 1, + kChanFieldNumber = 2, + kKindShmFieldNumber = 3, + kLenOrErrFieldNumber = 4, + kShmCntFieldNumber = 5, + kSrvNameFieldNumber = 6, + }; + static constexpr const char* GetName() { return ".perfetto.protos.TrustyIpcWriteFtraceEvent"; } + + + using FieldMetadata_BufId = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TrustyIpcWriteFtraceEvent>; + + static constexpr FieldMetadata_BufId kBufId{}; + void set_buf_id(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_BufId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Chan = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + TrustyIpcWriteFtraceEvent>; + + static constexpr FieldMetadata_Chan kChan{}; + void set_chan(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Chan::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_KindShm = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + TrustyIpcWriteFtraceEvent>; + + static constexpr FieldMetadata_KindShm kKindShm{}; + void set_kind_shm(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_KindShm::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_LenOrErr = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + TrustyIpcWriteFtraceEvent>; + + static constexpr FieldMetadata_LenOrErr kLenOrErr{}; + void set_len_or_err(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_LenOrErr::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ShmCnt = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TrustyIpcWriteFtraceEvent>; + + static constexpr FieldMetadata_ShmCnt kShmCnt{}; + void set_shm_cnt(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_ShmCnt::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SrvName = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + TrustyIpcWriteFtraceEvent>; + + static constexpr FieldMetadata_SrvName kSrvName{}; + void set_srv_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_SrvName::kFieldId, data, size); + } + void set_srv_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_SrvName::kFieldId, chars.data, chars.size); + } + void set_srv_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_SrvName::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class TrustyIpcConnectEndFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + TrustyIpcConnectEndFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TrustyIpcConnectEndFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TrustyIpcConnectEndFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_chan() const { return at<1>().valid(); } + uint32_t chan() const { return at<1>().as_uint32(); } + bool has_err() const { return at<2>().valid(); } + int32_t err() const { return at<2>().as_int32(); } + bool has_state() const { return at<3>().valid(); } + int32_t state() const { return at<3>().as_int32(); } +}; + +class TrustyIpcConnectEndFtraceEvent : public ::protozero::Message { + public: + using Decoder = TrustyIpcConnectEndFtraceEvent_Decoder; + enum : int32_t { + kChanFieldNumber = 1, + kErrFieldNumber = 2, + kStateFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.TrustyIpcConnectEndFtraceEvent"; } + + + using FieldMetadata_Chan = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + TrustyIpcConnectEndFtraceEvent>; + + static constexpr FieldMetadata_Chan kChan{}; + void set_chan(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Chan::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Err = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + TrustyIpcConnectEndFtraceEvent>; + + static constexpr FieldMetadata_Err kErr{}; + void set_err(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Err::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_State = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + TrustyIpcConnectEndFtraceEvent>; + + static constexpr FieldMetadata_State kState{}; + void set_state(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_State::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class TrustyIpcConnectFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + TrustyIpcConnectFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TrustyIpcConnectFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TrustyIpcConnectFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_chan() const { return at<1>().valid(); } + uint32_t chan() const { return at<1>().as_uint32(); } + bool has_port() const { return at<2>().valid(); } + ::protozero::ConstChars port() const { return at<2>().as_string(); } + bool has_state() const { return at<3>().valid(); } + int32_t state() const { return at<3>().as_int32(); } +}; + +class TrustyIpcConnectFtraceEvent : public ::protozero::Message { + public: + using Decoder = TrustyIpcConnectFtraceEvent_Decoder; + enum : int32_t { + kChanFieldNumber = 1, + kPortFieldNumber = 2, + kStateFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.TrustyIpcConnectFtraceEvent"; } + + + using FieldMetadata_Chan = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + TrustyIpcConnectFtraceEvent>; + + static constexpr FieldMetadata_Chan kChan{}; + void set_chan(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Chan::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Port = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + TrustyIpcConnectFtraceEvent>; + + static constexpr FieldMetadata_Port kPort{}; + void set_port(const char* data, size_t size) { + AppendBytes(FieldMetadata_Port::kFieldId, data, size); + } + void set_port(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Port::kFieldId, chars.data, chars.size); + } + void set_port(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Port::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_State = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + TrustyIpcConnectFtraceEvent>; + + static constexpr FieldMetadata_State kState{}; + void set_state(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_State::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class TrustyIpcHandleEventFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + TrustyIpcHandleEventFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TrustyIpcHandleEventFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TrustyIpcHandleEventFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_chan() const { return at<1>().valid(); } + uint32_t chan() const { return at<1>().as_uint32(); } + bool has_event_id() const { return at<2>().valid(); } + uint32_t event_id() const { return at<2>().as_uint32(); } + bool has_srv_name() const { return at<3>().valid(); } + ::protozero::ConstChars srv_name() const { return at<3>().as_string(); } +}; + +class TrustyIpcHandleEventFtraceEvent : public ::protozero::Message { + public: + using Decoder = TrustyIpcHandleEventFtraceEvent_Decoder; + enum : int32_t { + kChanFieldNumber = 1, + kEventIdFieldNumber = 2, + kSrvNameFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.TrustyIpcHandleEventFtraceEvent"; } + + + using FieldMetadata_Chan = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + TrustyIpcHandleEventFtraceEvent>; + + static constexpr FieldMetadata_Chan kChan{}; + void set_chan(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Chan::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_EventId = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + TrustyIpcHandleEventFtraceEvent>; + + static constexpr FieldMetadata_EventId kEventId{}; + void set_event_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_EventId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SrvName = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + TrustyIpcHandleEventFtraceEvent>; + + static constexpr FieldMetadata_SrvName kSrvName{}; + void set_srv_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_SrvName::kFieldId, data, size); + } + void set_srv_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_SrvName::kFieldId, chars.data, chars.size); + } + void set_srv_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_SrvName::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class TrustyIrqFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + TrustyIrqFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TrustyIrqFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TrustyIrqFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_irq() const { return at<1>().valid(); } + int32_t irq() const { return at<1>().as_int32(); } +}; + +class TrustyIrqFtraceEvent : public ::protozero::Message { + public: + using Decoder = TrustyIrqFtraceEvent_Decoder; + enum : int32_t { + kIrqFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.TrustyIrqFtraceEvent"; } + + + using FieldMetadata_Irq = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + TrustyIrqFtraceEvent>; + + static constexpr FieldMetadata_Irq kIrq{}; + void set_irq(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Irq::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class TrustyReclaimMemoryDoneFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + TrustyReclaimMemoryDoneFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TrustyReclaimMemoryDoneFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TrustyReclaimMemoryDoneFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_id() const { return at<1>().valid(); } + uint64_t id() const { return at<1>().as_uint64(); } + bool has_ret() const { return at<2>().valid(); } + int32_t ret() const { return at<2>().as_int32(); } +}; + +class TrustyReclaimMemoryDoneFtraceEvent : public ::protozero::Message { + public: + using Decoder = TrustyReclaimMemoryDoneFtraceEvent_Decoder; + enum : int32_t { + kIdFieldNumber = 1, + kRetFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.TrustyReclaimMemoryDoneFtraceEvent"; } + + + using FieldMetadata_Id = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TrustyReclaimMemoryDoneFtraceEvent>; + + static constexpr FieldMetadata_Id kId{}; + void set_id(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ret = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + TrustyReclaimMemoryDoneFtraceEvent>; + + static constexpr FieldMetadata_Ret kRet{}; + void set_ret(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class TrustyReclaimMemoryFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + TrustyReclaimMemoryFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TrustyReclaimMemoryFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TrustyReclaimMemoryFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_id() const { return at<1>().valid(); } + uint64_t id() const { return at<1>().as_uint64(); } +}; + +class TrustyReclaimMemoryFtraceEvent : public ::protozero::Message { + public: + using Decoder = TrustyReclaimMemoryFtraceEvent_Decoder; + enum : int32_t { + kIdFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.TrustyReclaimMemoryFtraceEvent"; } + + + using FieldMetadata_Id = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TrustyReclaimMemoryFtraceEvent>; + + static constexpr FieldMetadata_Id kId{}; + void set_id(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class TrustyShareMemoryDoneFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + TrustyShareMemoryDoneFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TrustyShareMemoryDoneFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TrustyShareMemoryDoneFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_handle() const { return at<1>().valid(); } + uint64_t handle() const { return at<1>().as_uint64(); } + bool has_len() const { return at<2>().valid(); } + uint64_t len() const { return at<2>().as_uint64(); } + bool has_lend() const { return at<3>().valid(); } + uint32_t lend() const { return at<3>().as_uint32(); } + bool has_nents() const { return at<4>().valid(); } + uint32_t nents() const { return at<4>().as_uint32(); } + bool has_ret() const { return at<5>().valid(); } + int32_t ret() const { return at<5>().as_int32(); } +}; + +class TrustyShareMemoryDoneFtraceEvent : public ::protozero::Message { + public: + using Decoder = TrustyShareMemoryDoneFtraceEvent_Decoder; + enum : int32_t { + kHandleFieldNumber = 1, + kLenFieldNumber = 2, + kLendFieldNumber = 3, + kNentsFieldNumber = 4, + kRetFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.TrustyShareMemoryDoneFtraceEvent"; } + + + using FieldMetadata_Handle = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TrustyShareMemoryDoneFtraceEvent>; + + static constexpr FieldMetadata_Handle kHandle{}; + void set_handle(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Handle::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Len = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TrustyShareMemoryDoneFtraceEvent>; + + static constexpr FieldMetadata_Len kLen{}; + void set_len(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Lend = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + TrustyShareMemoryDoneFtraceEvent>; + + static constexpr FieldMetadata_Lend kLend{}; + void set_lend(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Lend::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Nents = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + TrustyShareMemoryDoneFtraceEvent>; + + static constexpr FieldMetadata_Nents kNents{}; + void set_nents(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Nents::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ret = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + TrustyShareMemoryDoneFtraceEvent>; + + static constexpr FieldMetadata_Ret kRet{}; + void set_ret(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class TrustyShareMemoryFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + TrustyShareMemoryFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TrustyShareMemoryFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TrustyShareMemoryFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_len() const { return at<1>().valid(); } + uint64_t len() const { return at<1>().as_uint64(); } + bool has_lend() const { return at<2>().valid(); } + uint32_t lend() const { return at<2>().as_uint32(); } + bool has_nents() const { return at<3>().valid(); } + uint32_t nents() const { return at<3>().as_uint32(); } +}; + +class TrustyShareMemoryFtraceEvent : public ::protozero::Message { + public: + using Decoder = TrustyShareMemoryFtraceEvent_Decoder; + enum : int32_t { + kLenFieldNumber = 1, + kLendFieldNumber = 2, + kNentsFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.TrustyShareMemoryFtraceEvent"; } + + + using FieldMetadata_Len = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TrustyShareMemoryFtraceEvent>; + + static constexpr FieldMetadata_Len kLen{}; + void set_len(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Lend = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + TrustyShareMemoryFtraceEvent>; + + static constexpr FieldMetadata_Lend kLend{}; + void set_lend(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Lend::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Nents = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + TrustyShareMemoryFtraceEvent>; + + static constexpr FieldMetadata_Nents kNents{}; + void set_nents(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Nents::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class TrustyStdCall32DoneFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + TrustyStdCall32DoneFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TrustyStdCall32DoneFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TrustyStdCall32DoneFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_ret() const { return at<1>().valid(); } + int64_t ret() const { return at<1>().as_int64(); } +}; + +class TrustyStdCall32DoneFtraceEvent : public ::protozero::Message { + public: + using Decoder = TrustyStdCall32DoneFtraceEvent_Decoder; + enum : int32_t { + kRetFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.TrustyStdCall32DoneFtraceEvent"; } + + + using FieldMetadata_Ret = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + TrustyStdCall32DoneFtraceEvent>; + + static constexpr FieldMetadata_Ret kRet{}; + void set_ret(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } +}; + +class TrustyStdCall32FtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + TrustyStdCall32FtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TrustyStdCall32FtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TrustyStdCall32FtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_r0() const { return at<1>().valid(); } + uint64_t r0() const { return at<1>().as_uint64(); } + bool has_r1() const { return at<2>().valid(); } + uint64_t r1() const { return at<2>().as_uint64(); } + bool has_r2() const { return at<3>().valid(); } + uint64_t r2() const { return at<3>().as_uint64(); } + bool has_r3() const { return at<4>().valid(); } + uint64_t r3() const { return at<4>().as_uint64(); } +}; + +class TrustyStdCall32FtraceEvent : public ::protozero::Message { + public: + using Decoder = TrustyStdCall32FtraceEvent_Decoder; + enum : int32_t { + kR0FieldNumber = 1, + kR1FieldNumber = 2, + kR2FieldNumber = 3, + kR3FieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.TrustyStdCall32FtraceEvent"; } + + + using FieldMetadata_R0 = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TrustyStdCall32FtraceEvent>; + + static constexpr FieldMetadata_R0 kR0{}; + void set_r0(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_R0::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_R1 = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TrustyStdCall32FtraceEvent>; + + static constexpr FieldMetadata_R1 kR1{}; + void set_r1(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_R1::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_R2 = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TrustyStdCall32FtraceEvent>; + + static constexpr FieldMetadata_R2 kR2{}; + void set_r2(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_R2::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_R3 = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TrustyStdCall32FtraceEvent>; + + static constexpr FieldMetadata_R3 kR3{}; + void set_r3(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_R3::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class TrustySmcDoneFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + TrustySmcDoneFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TrustySmcDoneFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TrustySmcDoneFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_ret() const { return at<1>().valid(); } + uint64_t ret() const { return at<1>().as_uint64(); } +}; + +class TrustySmcDoneFtraceEvent : public ::protozero::Message { + public: + using Decoder = TrustySmcDoneFtraceEvent_Decoder; + enum : int32_t { + kRetFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.TrustySmcDoneFtraceEvent"; } + + + using FieldMetadata_Ret = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TrustySmcDoneFtraceEvent>; + + static constexpr FieldMetadata_Ret kRet{}; + void set_ret(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class TrustySmcFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + TrustySmcFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TrustySmcFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TrustySmcFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_r0() const { return at<1>().valid(); } + uint64_t r0() const { return at<1>().as_uint64(); } + bool has_r1() const { return at<2>().valid(); } + uint64_t r1() const { return at<2>().as_uint64(); } + bool has_r2() const { return at<3>().valid(); } + uint64_t r2() const { return at<3>().as_uint64(); } + bool has_r3() const { return at<4>().valid(); } + uint64_t r3() const { return at<4>().as_uint64(); } +}; + +class TrustySmcFtraceEvent : public ::protozero::Message { + public: + using Decoder = TrustySmcFtraceEvent_Decoder; + enum : int32_t { + kR0FieldNumber = 1, + kR1FieldNumber = 2, + kR2FieldNumber = 3, + kR3FieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.TrustySmcFtraceEvent"; } + + + using FieldMetadata_R0 = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TrustySmcFtraceEvent>; + + static constexpr FieldMetadata_R0 kR0{}; + void set_r0(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_R0::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_R1 = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TrustySmcFtraceEvent>; + + static constexpr FieldMetadata_R1 kR1{}; + void set_r1(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_R1::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_R2 = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TrustySmcFtraceEvent>; + + static constexpr FieldMetadata_R2 kR2{}; + void set_r2(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_R2::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_R3 = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TrustySmcFtraceEvent>; + + static constexpr FieldMetadata_R3 kR3{}; + void set_r3(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_R3::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class CdevUpdateFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + CdevUpdateFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit CdevUpdateFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit CdevUpdateFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_target() const { return at<1>().valid(); } + uint64_t target() const { return at<1>().as_uint64(); } + bool has_type() const { return at<2>().valid(); } + ::protozero::ConstChars type() const { return at<2>().as_string(); } +}; + +class CdevUpdateFtraceEvent : public ::protozero::Message { + public: + using Decoder = CdevUpdateFtraceEvent_Decoder; + enum : int32_t { + kTargetFieldNumber = 1, + kTypeFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.CdevUpdateFtraceEvent"; } + + + using FieldMetadata_Target = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + CdevUpdateFtraceEvent>; + + static constexpr FieldMetadata_Target kTarget{}; + void set_target(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Target::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Type = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + CdevUpdateFtraceEvent>; + + static constexpr FieldMetadata_Type kType{}; + void set_type(const char* data, size_t size) { + AppendBytes(FieldMetadata_Type::kFieldId, data, size); + } + void set_type(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Type::kFieldId, chars.data, chars.size); + } + void set_type(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class ThermalTemperatureFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + ThermalTemperatureFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ThermalTemperatureFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ThermalTemperatureFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_id() const { return at<1>().valid(); } + int32_t id() const { return at<1>().as_int32(); } + bool has_temp() const { return at<2>().valid(); } + int32_t temp() const { return at<2>().as_int32(); } + bool has_temp_prev() const { return at<3>().valid(); } + int32_t temp_prev() const { return at<3>().as_int32(); } + bool has_thermal_zone() const { return at<4>().valid(); } + ::protozero::ConstChars thermal_zone() const { return at<4>().as_string(); } +}; + +class ThermalTemperatureFtraceEvent : public ::protozero::Message { + public: + using Decoder = ThermalTemperatureFtraceEvent_Decoder; + enum : int32_t { + kIdFieldNumber = 1, + kTempFieldNumber = 2, + kTempPrevFieldNumber = 3, + kThermalZoneFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ThermalTemperatureFtraceEvent"; } + + + using FieldMetadata_Id = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + ThermalTemperatureFtraceEvent>; + + static constexpr FieldMetadata_Id kId{}; + void set_id(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Temp = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + ThermalTemperatureFtraceEvent>; + + static constexpr FieldMetadata_Temp kTemp{}; + void set_temp(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Temp::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TempPrev = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + ThermalTemperatureFtraceEvent>; + + static constexpr FieldMetadata_TempPrev kTempPrev{}; + void set_temp_prev(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TempPrev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ThermalZone = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + ThermalTemperatureFtraceEvent>; + + static constexpr FieldMetadata_ThermalZone kThermalZone{}; + void set_thermal_zone(const char* data, size_t size) { + AppendBytes(FieldMetadata_ThermalZone::kFieldId, data, size); + } + void set_thermal_zone(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_ThermalZone::kFieldId, chars.data, chars.size); + } + void set_thermal_zone(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_ThermalZone::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class TcpRetransmitSkbFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + TcpRetransmitSkbFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TcpRetransmitSkbFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TcpRetransmitSkbFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_daddr() const { return at<1>().valid(); } + uint32_t daddr() const { return at<1>().as_uint32(); } + bool has_dport() const { return at<2>().valid(); } + uint32_t dport() const { return at<2>().as_uint32(); } + bool has_saddr() const { return at<3>().valid(); } + uint32_t saddr() const { return at<3>().as_uint32(); } + bool has_skaddr() const { return at<4>().valid(); } + uint64_t skaddr() const { return at<4>().as_uint64(); } + bool has_skbaddr() const { return at<5>().valid(); } + uint64_t skbaddr() const { return at<5>().as_uint64(); } + bool has_sport() const { return at<6>().valid(); } + uint32_t sport() const { return at<6>().as_uint32(); } + bool has_state() const { return at<7>().valid(); } + int32_t state() const { return at<7>().as_int32(); } +}; + +class TcpRetransmitSkbFtraceEvent : public ::protozero::Message { + public: + using Decoder = TcpRetransmitSkbFtraceEvent_Decoder; + enum : int32_t { + kDaddrFieldNumber = 1, + kDportFieldNumber = 2, + kSaddrFieldNumber = 3, + kSkaddrFieldNumber = 4, + kSkbaddrFieldNumber = 5, + kSportFieldNumber = 6, + kStateFieldNumber = 7, + }; + static constexpr const char* GetName() { return ".perfetto.protos.TcpRetransmitSkbFtraceEvent"; } + + + using FieldMetadata_Daddr = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + TcpRetransmitSkbFtraceEvent>; + + static constexpr FieldMetadata_Daddr kDaddr{}; + void set_daddr(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Daddr::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Dport = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + TcpRetransmitSkbFtraceEvent>; + + static constexpr FieldMetadata_Dport kDport{}; + void set_dport(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dport::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Saddr = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + TcpRetransmitSkbFtraceEvent>; + + static constexpr FieldMetadata_Saddr kSaddr{}; + void set_saddr(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Saddr::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Skaddr = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TcpRetransmitSkbFtraceEvent>; + + static constexpr FieldMetadata_Skaddr kSkaddr{}; + void set_skaddr(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Skaddr::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Skbaddr = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TcpRetransmitSkbFtraceEvent>; + + static constexpr FieldMetadata_Skbaddr kSkbaddr{}; + void set_skbaddr(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Skbaddr::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Sport = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + TcpRetransmitSkbFtraceEvent>; + + static constexpr FieldMetadata_Sport kSport{}; + void set_sport(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Sport::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_State = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + TcpRetransmitSkbFtraceEvent>; + + static constexpr FieldMetadata_State kState{}; + void set_state(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_State::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class TaskRenameFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + TaskRenameFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TaskRenameFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TaskRenameFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_pid() const { return at<1>().valid(); } + int32_t pid() const { return at<1>().as_int32(); } + bool has_oldcomm() const { return at<2>().valid(); } + ::protozero::ConstChars oldcomm() const { return at<2>().as_string(); } + bool has_newcomm() const { return at<3>().valid(); } + ::protozero::ConstChars newcomm() const { return at<3>().as_string(); } + bool has_oom_score_adj() const { return at<4>().valid(); } + int32_t oom_score_adj() const { return at<4>().as_int32(); } +}; + +class TaskRenameFtraceEvent : public ::protozero::Message { + public: + using Decoder = TaskRenameFtraceEvent_Decoder; + enum : int32_t { + kPidFieldNumber = 1, + kOldcommFieldNumber = 2, + kNewcommFieldNumber = 3, + kOomScoreAdjFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.TaskRenameFtraceEvent"; } + + + using FieldMetadata_Pid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + TaskRenameFtraceEvent>; + + static constexpr FieldMetadata_Pid kPid{}; + void set_pid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Oldcomm = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + TaskRenameFtraceEvent>; + + static constexpr FieldMetadata_Oldcomm kOldcomm{}; + void set_oldcomm(const char* data, size_t size) { + AppendBytes(FieldMetadata_Oldcomm::kFieldId, data, size); + } + void set_oldcomm(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Oldcomm::kFieldId, chars.data, chars.size); + } + void set_oldcomm(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Oldcomm::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Newcomm = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + TaskRenameFtraceEvent>; + + static constexpr FieldMetadata_Newcomm kNewcomm{}; + void set_newcomm(const char* data, size_t size) { + AppendBytes(FieldMetadata_Newcomm::kFieldId, data, size); + } + void set_newcomm(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Newcomm::kFieldId, chars.data, chars.size); + } + void set_newcomm(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Newcomm::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_OomScoreAdj = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + TaskRenameFtraceEvent>; + + static constexpr FieldMetadata_OomScoreAdj kOomScoreAdj{}; + void set_oom_score_adj(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_OomScoreAdj::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class TaskNewtaskFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + TaskNewtaskFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TaskNewtaskFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TaskNewtaskFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_pid() const { return at<1>().valid(); } + int32_t pid() const { return at<1>().as_int32(); } + bool has_comm() const { return at<2>().valid(); } + ::protozero::ConstChars comm() const { return at<2>().as_string(); } + bool has_clone_flags() const { return at<3>().valid(); } + uint64_t clone_flags() const { return at<3>().as_uint64(); } + bool has_oom_score_adj() const { return at<4>().valid(); } + int32_t oom_score_adj() const { return at<4>().as_int32(); } +}; + +class TaskNewtaskFtraceEvent : public ::protozero::Message { + public: + using Decoder = TaskNewtaskFtraceEvent_Decoder; + enum : int32_t { + kPidFieldNumber = 1, + kCommFieldNumber = 2, + kCloneFlagsFieldNumber = 3, + kOomScoreAdjFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.TaskNewtaskFtraceEvent"; } + + + using FieldMetadata_Pid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + TaskNewtaskFtraceEvent>; + + static constexpr FieldMetadata_Pid kPid{}; + void set_pid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Comm = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + TaskNewtaskFtraceEvent>; + + static constexpr FieldMetadata_Comm kComm{}; + void set_comm(const char* data, size_t size) { + AppendBytes(FieldMetadata_Comm::kFieldId, data, size); + } + void set_comm(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Comm::kFieldId, chars.data, chars.size); + } + void set_comm(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Comm::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CloneFlags = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TaskNewtaskFtraceEvent>; + + static constexpr FieldMetadata_CloneFlags kCloneFlags{}; + void set_clone_flags(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_CloneFlags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_OomScoreAdj = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + TaskNewtaskFtraceEvent>; + + static constexpr FieldMetadata_OomScoreAdj kOomScoreAdj{}; + void set_oom_score_adj(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_OomScoreAdj::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class ZeroFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + ZeroFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ZeroFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ZeroFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_flag() const { return at<1>().valid(); } + int32_t flag() const { return at<1>().as_int32(); } + bool has_name() const { return at<2>().valid(); } + ::protozero::ConstChars name() const { return at<2>().as_string(); } + bool has_pid() const { return at<3>().valid(); } + int32_t pid() const { return at<3>().as_int32(); } + bool has_value() const { return at<4>().valid(); } + int64_t value() const { return at<4>().as_int64(); } +}; + +class ZeroFtraceEvent : public ::protozero::Message { + public: + using Decoder = ZeroFtraceEvent_Decoder; + enum : int32_t { + kFlagFieldNumber = 1, + kNameFieldNumber = 2, + kPidFieldNumber = 3, + kValueFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ZeroFtraceEvent"; } + + + using FieldMetadata_Flag = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + ZeroFtraceEvent>; + + static constexpr FieldMetadata_Flag kFlag{}; + void set_flag(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Flag::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + ZeroFtraceEvent>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pid = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + ZeroFtraceEvent>; + + static constexpr FieldMetadata_Pid kPid{}; + void set_pid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Value = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + ZeroFtraceEvent>; + + static constexpr FieldMetadata_Value kValue{}; + void set_value(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } +}; + +class SuspendResumeMinimalFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + SuspendResumeMinimalFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit SuspendResumeMinimalFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit SuspendResumeMinimalFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_start() const { return at<1>().valid(); } + uint32_t start() const { return at<1>().as_uint32(); } +}; + +class SuspendResumeMinimalFtraceEvent : public ::protozero::Message { + public: + using Decoder = SuspendResumeMinimalFtraceEvent_Decoder; + enum : int32_t { + kStartFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.SuspendResumeMinimalFtraceEvent"; } + + + using FieldMetadata_Start = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SuspendResumeMinimalFtraceEvent>; + + static constexpr FieldMetadata_Start kStart{}; + void set_start(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Start::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class RssStatThrottledFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + RssStatThrottledFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit RssStatThrottledFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit RssStatThrottledFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_curr() const { return at<1>().valid(); } + uint32_t curr() const { return at<1>().as_uint32(); } + bool has_member() const { return at<2>().valid(); } + int32_t member() const { return at<2>().as_int32(); } + bool has_mm_id() const { return at<3>().valid(); } + uint32_t mm_id() const { return at<3>().as_uint32(); } + bool has_size() const { return at<4>().valid(); } + int64_t size() const { return at<4>().as_int64(); } +}; + +class RssStatThrottledFtraceEvent : public ::protozero::Message { + public: + using Decoder = RssStatThrottledFtraceEvent_Decoder; + enum : int32_t { + kCurrFieldNumber = 1, + kMemberFieldNumber = 2, + kMmIdFieldNumber = 3, + kSizeFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.RssStatThrottledFtraceEvent"; } + + + using FieldMetadata_Curr = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + RssStatThrottledFtraceEvent>; + + static constexpr FieldMetadata_Curr kCurr{}; + void set_curr(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Curr::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Member = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + RssStatThrottledFtraceEvent>; + + static constexpr FieldMetadata_Member kMember{}; + void set_member(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Member::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_MmId = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + RssStatThrottledFtraceEvent>; + + static constexpr FieldMetadata_MmId kMmId{}; + void set_mm_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_MmId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Size = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + RssStatThrottledFtraceEvent>; + + static constexpr FieldMetadata_Size kSize{}; + void set_size(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Size::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } +}; + +class SyncWaitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + SyncWaitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit SyncWaitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit SyncWaitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_name() const { return at<1>().valid(); } + ::protozero::ConstChars name() const { return at<1>().as_string(); } + bool has_status() const { return at<2>().valid(); } + int32_t status() const { return at<2>().as_int32(); } + bool has_begin() const { return at<3>().valid(); } + uint32_t begin() const { return at<3>().as_uint32(); } +}; + +class SyncWaitFtraceEvent : public ::protozero::Message { + public: + using Decoder = SyncWaitFtraceEvent_Decoder; + enum : int32_t { + kNameFieldNumber = 1, + kStatusFieldNumber = 2, + kBeginFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.SyncWaitFtraceEvent"; } + + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + SyncWaitFtraceEvent>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Status = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + SyncWaitFtraceEvent>; + + static constexpr FieldMetadata_Status kStatus{}; + void set_status(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Status::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Begin = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SyncWaitFtraceEvent>; + + static constexpr FieldMetadata_Begin kBegin{}; + void set_begin(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Begin::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class SyncTimelineFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + SyncTimelineFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit SyncTimelineFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit SyncTimelineFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_name() const { return at<1>().valid(); } + ::protozero::ConstChars name() const { return at<1>().as_string(); } + bool has_value() const { return at<2>().valid(); } + ::protozero::ConstChars value() const { return at<2>().as_string(); } +}; + +class SyncTimelineFtraceEvent : public ::protozero::Message { + public: + using Decoder = SyncTimelineFtraceEvent_Decoder; + enum : int32_t { + kNameFieldNumber = 1, + kValueFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.SyncTimelineFtraceEvent"; } + + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + SyncTimelineFtraceEvent>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Value = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + SyncTimelineFtraceEvent>; + + static constexpr FieldMetadata_Value kValue{}; + void set_value(const char* data, size_t size) { + AppendBytes(FieldMetadata_Value::kFieldId, data, size); + } + void set_value(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Value::kFieldId, chars.data, chars.size); + } + void set_value(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class SyncPtFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + SyncPtFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit SyncPtFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit SyncPtFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_timeline() const { return at<1>().valid(); } + ::protozero::ConstChars timeline() const { return at<1>().as_string(); } + bool has_value() const { return at<2>().valid(); } + ::protozero::ConstChars value() const { return at<2>().as_string(); } +}; + +class SyncPtFtraceEvent : public ::protozero::Message { + public: + using Decoder = SyncPtFtraceEvent_Decoder; + enum : int32_t { + kTimelineFieldNumber = 1, + kValueFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.SyncPtFtraceEvent"; } + + + using FieldMetadata_Timeline = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + SyncPtFtraceEvent>; + + static constexpr FieldMetadata_Timeline kTimeline{}; + void set_timeline(const char* data, size_t size) { + AppendBytes(FieldMetadata_Timeline::kFieldId, data, size); + } + void set_timeline(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Timeline::kFieldId, chars.data, chars.size); + } + void set_timeline(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Timeline::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Value = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + SyncPtFtraceEvent>; + + static constexpr FieldMetadata_Value kValue{}; + void set_value(const char* data, size_t size) { + AppendBytes(FieldMetadata_Value::kFieldId, data, size); + } + void set_value(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Value::kFieldId, chars.data, chars.size); + } + void set_value(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class InetSockSetStateFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + InetSockSetStateFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit InetSockSetStateFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit InetSockSetStateFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_daddr() const { return at<1>().valid(); } + uint32_t daddr() const { return at<1>().as_uint32(); } + bool has_dport() const { return at<2>().valid(); } + uint32_t dport() const { return at<2>().as_uint32(); } + bool has_family() const { return at<3>().valid(); } + uint32_t family() const { return at<3>().as_uint32(); } + bool has_newstate() const { return at<4>().valid(); } + int32_t newstate() const { return at<4>().as_int32(); } + bool has_oldstate() const { return at<5>().valid(); } + int32_t oldstate() const { return at<5>().as_int32(); } + bool has_protocol() const { return at<6>().valid(); } + uint32_t protocol() const { return at<6>().as_uint32(); } + bool has_saddr() const { return at<7>().valid(); } + uint32_t saddr() const { return at<7>().as_uint32(); } + bool has_skaddr() const { return at<8>().valid(); } + uint64_t skaddr() const { return at<8>().as_uint64(); } + bool has_sport() const { return at<9>().valid(); } + uint32_t sport() const { return at<9>().as_uint32(); } +}; + +class InetSockSetStateFtraceEvent : public ::protozero::Message { + public: + using Decoder = InetSockSetStateFtraceEvent_Decoder; + enum : int32_t { + kDaddrFieldNumber = 1, + kDportFieldNumber = 2, + kFamilyFieldNumber = 3, + kNewstateFieldNumber = 4, + kOldstateFieldNumber = 5, + kProtocolFieldNumber = 6, + kSaddrFieldNumber = 7, + kSkaddrFieldNumber = 8, + kSportFieldNumber = 9, + }; + static constexpr const char* GetName() { return ".perfetto.protos.InetSockSetStateFtraceEvent"; } + + + using FieldMetadata_Daddr = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + InetSockSetStateFtraceEvent>; + + static constexpr FieldMetadata_Daddr kDaddr{}; + void set_daddr(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Daddr::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Dport = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + InetSockSetStateFtraceEvent>; + + static constexpr FieldMetadata_Dport kDport{}; + void set_dport(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dport::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Family = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + InetSockSetStateFtraceEvent>; + + static constexpr FieldMetadata_Family kFamily{}; + void set_family(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Family::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Newstate = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + InetSockSetStateFtraceEvent>; + + static constexpr FieldMetadata_Newstate kNewstate{}; + void set_newstate(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Newstate::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Oldstate = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + InetSockSetStateFtraceEvent>; + + static constexpr FieldMetadata_Oldstate kOldstate{}; + void set_oldstate(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Oldstate::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Protocol = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + InetSockSetStateFtraceEvent>; + + static constexpr FieldMetadata_Protocol kProtocol{}; + void set_protocol(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Protocol::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Saddr = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + InetSockSetStateFtraceEvent>; + + static constexpr FieldMetadata_Saddr kSaddr{}; + void set_saddr(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Saddr::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Skaddr = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + InetSockSetStateFtraceEvent>; + + static constexpr FieldMetadata_Skaddr kSkaddr{}; + void set_skaddr(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Skaddr::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Sport = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + InetSockSetStateFtraceEvent>; + + static constexpr FieldMetadata_Sport kSport{}; + void set_sport(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Sport::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class KfreeSkbFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + KfreeSkbFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit KfreeSkbFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit KfreeSkbFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_location() const { return at<1>().valid(); } + uint64_t location() const { return at<1>().as_uint64(); } + bool has_protocol() const { return at<2>().valid(); } + uint32_t protocol() const { return at<2>().as_uint32(); } + bool has_skbaddr() const { return at<3>().valid(); } + uint64_t skbaddr() const { return at<3>().as_uint64(); } +}; + +class KfreeSkbFtraceEvent : public ::protozero::Message { + public: + using Decoder = KfreeSkbFtraceEvent_Decoder; + enum : int32_t { + kLocationFieldNumber = 1, + kProtocolFieldNumber = 2, + kSkbaddrFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.KfreeSkbFtraceEvent"; } + + + using FieldMetadata_Location = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + KfreeSkbFtraceEvent>; + + static constexpr FieldMetadata_Location kLocation{}; + void set_location(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Location::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Protocol = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + KfreeSkbFtraceEvent>; + + static constexpr FieldMetadata_Protocol kProtocol{}; + void set_protocol(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Protocol::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Skbaddr = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + KfreeSkbFtraceEvent>; + + static constexpr FieldMetadata_Skbaddr kSkbaddr{}; + void set_skbaddr(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Skbaddr::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class SignalGenerateFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + SignalGenerateFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit SignalGenerateFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit SignalGenerateFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_code() const { return at<1>().valid(); } + int32_t code() const { return at<1>().as_int32(); } + bool has_comm() const { return at<2>().valid(); } + ::protozero::ConstChars comm() const { return at<2>().as_string(); } + bool has_group() const { return at<3>().valid(); } + int32_t group() const { return at<3>().as_int32(); } + bool has_pid() const { return at<4>().valid(); } + int32_t pid() const { return at<4>().as_int32(); } + bool has_result() const { return at<5>().valid(); } + int32_t result() const { return at<5>().as_int32(); } + bool has_sig() const { return at<6>().valid(); } + int32_t sig() const { return at<6>().as_int32(); } +}; + +class SignalGenerateFtraceEvent : public ::protozero::Message { + public: + using Decoder = SignalGenerateFtraceEvent_Decoder; + enum : int32_t { + kCodeFieldNumber = 1, + kCommFieldNumber = 2, + kGroupFieldNumber = 3, + kPidFieldNumber = 4, + kResultFieldNumber = 5, + kSigFieldNumber = 6, + }; + static constexpr const char* GetName() { return ".perfetto.protos.SignalGenerateFtraceEvent"; } + + + using FieldMetadata_Code = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + SignalGenerateFtraceEvent>; + + static constexpr FieldMetadata_Code kCode{}; + void set_code(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Code::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Comm = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + SignalGenerateFtraceEvent>; + + static constexpr FieldMetadata_Comm kComm{}; + void set_comm(const char* data, size_t size) { + AppendBytes(FieldMetadata_Comm::kFieldId, data, size); + } + void set_comm(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Comm::kFieldId, chars.data, chars.size); + } + void set_comm(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Comm::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Group = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + SignalGenerateFtraceEvent>; + + static constexpr FieldMetadata_Group kGroup{}; + void set_group(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Group::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pid = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + SignalGenerateFtraceEvent>; + + static constexpr FieldMetadata_Pid kPid{}; + void set_pid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Result = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + SignalGenerateFtraceEvent>; + + static constexpr FieldMetadata_Result kResult{}; + void set_result(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Result::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Sig = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + SignalGenerateFtraceEvent>; + + static constexpr FieldMetadata_Sig kSig{}; + void set_sig(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Sig::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class SignalDeliverFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + SignalDeliverFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit SignalDeliverFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit SignalDeliverFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_code() const { return at<1>().valid(); } + int32_t code() const { return at<1>().as_int32(); } + bool has_sa_flags() const { return at<2>().valid(); } + uint64_t sa_flags() const { return at<2>().as_uint64(); } + bool has_sig() const { return at<3>().valid(); } + int32_t sig() const { return at<3>().as_int32(); } +}; + +class SignalDeliverFtraceEvent : public ::protozero::Message { + public: + using Decoder = SignalDeliverFtraceEvent_Decoder; + enum : int32_t { + kCodeFieldNumber = 1, + kSaFlagsFieldNumber = 2, + kSigFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.SignalDeliverFtraceEvent"; } + + + using FieldMetadata_Code = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + SignalDeliverFtraceEvent>; + + static constexpr FieldMetadata_Code kCode{}; + void set_code(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Code::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SaFlags = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + SignalDeliverFtraceEvent>; + + static constexpr FieldMetadata_SaFlags kSaFlags{}; + void set_sa_flags(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_SaFlags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Sig = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + SignalDeliverFtraceEvent>; + + static constexpr FieldMetadata_Sig kSig{}; + void set_sig(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Sig::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class SdeSdePerfUpdateBusFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + SdeSdePerfUpdateBusFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit SdeSdePerfUpdateBusFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit SdeSdePerfUpdateBusFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_ab_quota() const { return at<1>().valid(); } + uint64_t ab_quota() const { return at<1>().as_uint64(); } + bool has_bus_id() const { return at<2>().valid(); } + uint32_t bus_id() const { return at<2>().as_uint32(); } + bool has_client() const { return at<3>().valid(); } + int32_t client() const { return at<3>().as_int32(); } + bool has_ib_quota() const { return at<4>().valid(); } + uint64_t ib_quota() const { return at<4>().as_uint64(); } +}; + +class SdeSdePerfUpdateBusFtraceEvent : public ::protozero::Message { + public: + using Decoder = SdeSdePerfUpdateBusFtraceEvent_Decoder; + enum : int32_t { + kAbQuotaFieldNumber = 1, + kBusIdFieldNumber = 2, + kClientFieldNumber = 3, + kIbQuotaFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.SdeSdePerfUpdateBusFtraceEvent"; } + + + using FieldMetadata_AbQuota = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + SdeSdePerfUpdateBusFtraceEvent>; + + static constexpr FieldMetadata_AbQuota kAbQuota{}; + void set_ab_quota(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_AbQuota::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_BusId = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SdeSdePerfUpdateBusFtraceEvent>; + + static constexpr FieldMetadata_BusId kBusId{}; + void set_bus_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_BusId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Client = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + SdeSdePerfUpdateBusFtraceEvent>; + + static constexpr FieldMetadata_Client kClient{}; + void set_client(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Client::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_IbQuota = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + SdeSdePerfUpdateBusFtraceEvent>; + + static constexpr FieldMetadata_IbQuota kIbQuota{}; + void set_ib_quota(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_IbQuota::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class SdeSdePerfSetQosLutsFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + SdeSdePerfSetQosLutsFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit SdeSdePerfSetQosLutsFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit SdeSdePerfSetQosLutsFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_fl() const { return at<1>().valid(); } + uint32_t fl() const { return at<1>().as_uint32(); } + bool has_fmt() const { return at<2>().valid(); } + uint32_t fmt() const { return at<2>().as_uint32(); } + bool has_lut() const { return at<3>().valid(); } + uint64_t lut() const { return at<3>().as_uint64(); } + bool has_lut_usage() const { return at<4>().valid(); } + uint32_t lut_usage() const { return at<4>().as_uint32(); } + bool has_pnum() const { return at<5>().valid(); } + uint32_t pnum() const { return at<5>().as_uint32(); } + bool has_rt() const { return at<6>().valid(); } + uint32_t rt() const { return at<6>().as_uint32(); } +}; + +class SdeSdePerfSetQosLutsFtraceEvent : public ::protozero::Message { + public: + using Decoder = SdeSdePerfSetQosLutsFtraceEvent_Decoder; + enum : int32_t { + kFlFieldNumber = 1, + kFmtFieldNumber = 2, + kLutFieldNumber = 3, + kLutUsageFieldNumber = 4, + kPnumFieldNumber = 5, + kRtFieldNumber = 6, + }; + static constexpr const char* GetName() { return ".perfetto.protos.SdeSdePerfSetQosLutsFtraceEvent"; } + + + using FieldMetadata_Fl = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SdeSdePerfSetQosLutsFtraceEvent>; + + static constexpr FieldMetadata_Fl kFl{}; + void set_fl(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Fl::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Fmt = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SdeSdePerfSetQosLutsFtraceEvent>; + + static constexpr FieldMetadata_Fmt kFmt{}; + void set_fmt(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Fmt::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Lut = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + SdeSdePerfSetQosLutsFtraceEvent>; + + static constexpr FieldMetadata_Lut kLut{}; + void set_lut(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Lut::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_LutUsage = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SdeSdePerfSetQosLutsFtraceEvent>; + + static constexpr FieldMetadata_LutUsage kLutUsage{}; + void set_lut_usage(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_LutUsage::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pnum = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SdeSdePerfSetQosLutsFtraceEvent>; + + static constexpr FieldMetadata_Pnum kPnum{}; + void set_pnum(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pnum::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Rt = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SdeSdePerfSetQosLutsFtraceEvent>; + + static constexpr FieldMetadata_Rt kRt{}; + void set_rt(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Rt::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class SdeSdePerfCrtcUpdateFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + SdeSdePerfCrtcUpdateFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit SdeSdePerfCrtcUpdateFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit SdeSdePerfCrtcUpdateFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_bw_ctl_ebi() const { return at<1>().valid(); } + uint64_t bw_ctl_ebi() const { return at<1>().as_uint64(); } + bool has_bw_ctl_llcc() const { return at<2>().valid(); } + uint64_t bw_ctl_llcc() const { return at<2>().as_uint64(); } + bool has_bw_ctl_mnoc() const { return at<3>().valid(); } + uint64_t bw_ctl_mnoc() const { return at<3>().as_uint64(); } + bool has_core_clk_rate() const { return at<4>().valid(); } + uint32_t core_clk_rate() const { return at<4>().as_uint32(); } + bool has_crtc() const { return at<5>().valid(); } + uint32_t crtc() const { return at<5>().as_uint32(); } + bool has_params() const { return at<6>().valid(); } + int32_t params() const { return at<6>().as_int32(); } + bool has_per_pipe_ib_ebi() const { return at<7>().valid(); } + uint64_t per_pipe_ib_ebi() const { return at<7>().as_uint64(); } + bool has_per_pipe_ib_llcc() const { return at<8>().valid(); } + uint64_t per_pipe_ib_llcc() const { return at<8>().as_uint64(); } + bool has_per_pipe_ib_mnoc() const { return at<9>().valid(); } + uint64_t per_pipe_ib_mnoc() const { return at<9>().as_uint64(); } + bool has_stop_req() const { return at<10>().valid(); } + uint32_t stop_req() const { return at<10>().as_uint32(); } + bool has_update_bus() const { return at<11>().valid(); } + uint32_t update_bus() const { return at<11>().as_uint32(); } + bool has_update_clk() const { return at<12>().valid(); } + uint32_t update_clk() const { return at<12>().as_uint32(); } +}; + +class SdeSdePerfCrtcUpdateFtraceEvent : public ::protozero::Message { + public: + using Decoder = SdeSdePerfCrtcUpdateFtraceEvent_Decoder; + enum : int32_t { + kBwCtlEbiFieldNumber = 1, + kBwCtlLlccFieldNumber = 2, + kBwCtlMnocFieldNumber = 3, + kCoreClkRateFieldNumber = 4, + kCrtcFieldNumber = 5, + kParamsFieldNumber = 6, + kPerPipeIbEbiFieldNumber = 7, + kPerPipeIbLlccFieldNumber = 8, + kPerPipeIbMnocFieldNumber = 9, + kStopReqFieldNumber = 10, + kUpdateBusFieldNumber = 11, + kUpdateClkFieldNumber = 12, + }; + static constexpr const char* GetName() { return ".perfetto.protos.SdeSdePerfCrtcUpdateFtraceEvent"; } + + + using FieldMetadata_BwCtlEbi = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + SdeSdePerfCrtcUpdateFtraceEvent>; + + static constexpr FieldMetadata_BwCtlEbi kBwCtlEbi{}; + void set_bw_ctl_ebi(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_BwCtlEbi::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_BwCtlLlcc = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + SdeSdePerfCrtcUpdateFtraceEvent>; + + static constexpr FieldMetadata_BwCtlLlcc kBwCtlLlcc{}; + void set_bw_ctl_llcc(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_BwCtlLlcc::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_BwCtlMnoc = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + SdeSdePerfCrtcUpdateFtraceEvent>; + + static constexpr FieldMetadata_BwCtlMnoc kBwCtlMnoc{}; + void set_bw_ctl_mnoc(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_BwCtlMnoc::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CoreClkRate = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SdeSdePerfCrtcUpdateFtraceEvent>; + + static constexpr FieldMetadata_CoreClkRate kCoreClkRate{}; + void set_core_clk_rate(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_CoreClkRate::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Crtc = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SdeSdePerfCrtcUpdateFtraceEvent>; + + static constexpr FieldMetadata_Crtc kCrtc{}; + void set_crtc(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Crtc::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Params = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + SdeSdePerfCrtcUpdateFtraceEvent>; + + static constexpr FieldMetadata_Params kParams{}; + void set_params(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Params::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PerPipeIbEbi = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + SdeSdePerfCrtcUpdateFtraceEvent>; + + static constexpr FieldMetadata_PerPipeIbEbi kPerPipeIbEbi{}; + void set_per_pipe_ib_ebi(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_PerPipeIbEbi::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PerPipeIbLlcc = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + SdeSdePerfCrtcUpdateFtraceEvent>; + + static constexpr FieldMetadata_PerPipeIbLlcc kPerPipeIbLlcc{}; + void set_per_pipe_ib_llcc(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_PerPipeIbLlcc::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PerPipeIbMnoc = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + SdeSdePerfCrtcUpdateFtraceEvent>; + + static constexpr FieldMetadata_PerPipeIbMnoc kPerPipeIbMnoc{}; + void set_per_pipe_ib_mnoc(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_PerPipeIbMnoc::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_StopReq = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SdeSdePerfCrtcUpdateFtraceEvent>; + + static constexpr FieldMetadata_StopReq kStopReq{}; + void set_stop_req(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_StopReq::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_UpdateBus = + ::protozero::proto_utils::FieldMetadata< + 11, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SdeSdePerfCrtcUpdateFtraceEvent>; + + static constexpr FieldMetadata_UpdateBus kUpdateBus{}; + void set_update_bus(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_UpdateBus::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_UpdateClk = + ::protozero::proto_utils::FieldMetadata< + 12, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SdeSdePerfCrtcUpdateFtraceEvent>; + + static constexpr FieldMetadata_UpdateClk kUpdateClk{}; + void set_update_clk(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_UpdateClk::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class SdeSdePerfCalcCrtcFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + SdeSdePerfCalcCrtcFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit SdeSdePerfCalcCrtcFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit SdeSdePerfCalcCrtcFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_bw_ctl_ebi() const { return at<1>().valid(); } + uint64_t bw_ctl_ebi() const { return at<1>().as_uint64(); } + bool has_bw_ctl_llcc() const { return at<2>().valid(); } + uint64_t bw_ctl_llcc() const { return at<2>().as_uint64(); } + bool has_bw_ctl_mnoc() const { return at<3>().valid(); } + uint64_t bw_ctl_mnoc() const { return at<3>().as_uint64(); } + bool has_core_clk_rate() const { return at<4>().valid(); } + uint32_t core_clk_rate() const { return at<4>().as_uint32(); } + bool has_crtc() const { return at<5>().valid(); } + uint32_t crtc() const { return at<5>().as_uint32(); } + bool has_ib_ebi() const { return at<6>().valid(); } + uint64_t ib_ebi() const { return at<6>().as_uint64(); } + bool has_ib_llcc() const { return at<7>().valid(); } + uint64_t ib_llcc() const { return at<7>().as_uint64(); } + bool has_ib_mnoc() const { return at<8>().valid(); } + uint64_t ib_mnoc() const { return at<8>().as_uint64(); } +}; + +class SdeSdePerfCalcCrtcFtraceEvent : public ::protozero::Message { + public: + using Decoder = SdeSdePerfCalcCrtcFtraceEvent_Decoder; + enum : int32_t { + kBwCtlEbiFieldNumber = 1, + kBwCtlLlccFieldNumber = 2, + kBwCtlMnocFieldNumber = 3, + kCoreClkRateFieldNumber = 4, + kCrtcFieldNumber = 5, + kIbEbiFieldNumber = 6, + kIbLlccFieldNumber = 7, + kIbMnocFieldNumber = 8, + }; + static constexpr const char* GetName() { return ".perfetto.protos.SdeSdePerfCalcCrtcFtraceEvent"; } + + + using FieldMetadata_BwCtlEbi = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + SdeSdePerfCalcCrtcFtraceEvent>; + + static constexpr FieldMetadata_BwCtlEbi kBwCtlEbi{}; + void set_bw_ctl_ebi(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_BwCtlEbi::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_BwCtlLlcc = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + SdeSdePerfCalcCrtcFtraceEvent>; + + static constexpr FieldMetadata_BwCtlLlcc kBwCtlLlcc{}; + void set_bw_ctl_llcc(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_BwCtlLlcc::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_BwCtlMnoc = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + SdeSdePerfCalcCrtcFtraceEvent>; + + static constexpr FieldMetadata_BwCtlMnoc kBwCtlMnoc{}; + void set_bw_ctl_mnoc(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_BwCtlMnoc::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CoreClkRate = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SdeSdePerfCalcCrtcFtraceEvent>; + + static constexpr FieldMetadata_CoreClkRate kCoreClkRate{}; + void set_core_clk_rate(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_CoreClkRate::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Crtc = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SdeSdePerfCalcCrtcFtraceEvent>; + + static constexpr FieldMetadata_Crtc kCrtc{}; + void set_crtc(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Crtc::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_IbEbi = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + SdeSdePerfCalcCrtcFtraceEvent>; + + static constexpr FieldMetadata_IbEbi kIbEbi{}; + void set_ib_ebi(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_IbEbi::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_IbLlcc = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + SdeSdePerfCalcCrtcFtraceEvent>; + + static constexpr FieldMetadata_IbLlcc kIbLlcc{}; + void set_ib_llcc(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_IbLlcc::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_IbMnoc = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + SdeSdePerfCalcCrtcFtraceEvent>; + + static constexpr FieldMetadata_IbMnoc kIbMnoc{}; + void set_ib_mnoc(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_IbMnoc::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class SdeSdeEvtlogFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + SdeSdeEvtlogFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit SdeSdeEvtlogFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit SdeSdeEvtlogFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_evtlog_tag() const { return at<1>().valid(); } + ::protozero::ConstChars evtlog_tag() const { return at<1>().as_string(); } + bool has_pid() const { return at<2>().valid(); } + int32_t pid() const { return at<2>().as_int32(); } + bool has_tag_id() const { return at<3>().valid(); } + uint32_t tag_id() const { return at<3>().as_uint32(); } +}; + +class SdeSdeEvtlogFtraceEvent : public ::protozero::Message { + public: + using Decoder = SdeSdeEvtlogFtraceEvent_Decoder; + enum : int32_t { + kEvtlogTagFieldNumber = 1, + kPidFieldNumber = 2, + kTagIdFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.SdeSdeEvtlogFtraceEvent"; } + + + using FieldMetadata_EvtlogTag = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + SdeSdeEvtlogFtraceEvent>; + + static constexpr FieldMetadata_EvtlogTag kEvtlogTag{}; + void set_evtlog_tag(const char* data, size_t size) { + AppendBytes(FieldMetadata_EvtlogTag::kFieldId, data, size); + } + void set_evtlog_tag(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_EvtlogTag::kFieldId, chars.data, chars.size); + } + void set_evtlog_tag(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_EvtlogTag::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pid = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + SdeSdeEvtlogFtraceEvent>; + + static constexpr FieldMetadata_Pid kPid{}; + void set_pid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TagId = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SdeSdeEvtlogFtraceEvent>; + + static constexpr FieldMetadata_TagId kTagId{}; + void set_tag_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TagId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class SdeTracingMarkWriteFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + SdeTracingMarkWriteFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit SdeTracingMarkWriteFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit SdeTracingMarkWriteFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_pid() const { return at<1>().valid(); } + int32_t pid() const { return at<1>().as_int32(); } + bool has_trace_name() const { return at<2>().valid(); } + ::protozero::ConstChars trace_name() const { return at<2>().as_string(); } + bool has_trace_type() const { return at<3>().valid(); } + uint32_t trace_type() const { return at<3>().as_uint32(); } + bool has_value() const { return at<4>().valid(); } + int32_t value() const { return at<4>().as_int32(); } + bool has_trace_begin() const { return at<5>().valid(); } + uint32_t trace_begin() const { return at<5>().as_uint32(); } +}; + +class SdeTracingMarkWriteFtraceEvent : public ::protozero::Message { + public: + using Decoder = SdeTracingMarkWriteFtraceEvent_Decoder; + enum : int32_t { + kPidFieldNumber = 1, + kTraceNameFieldNumber = 2, + kTraceTypeFieldNumber = 3, + kValueFieldNumber = 4, + kTraceBeginFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.SdeTracingMarkWriteFtraceEvent"; } + + + using FieldMetadata_Pid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + SdeTracingMarkWriteFtraceEvent>; + + static constexpr FieldMetadata_Pid kPid{}; + void set_pid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TraceName = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + SdeTracingMarkWriteFtraceEvent>; + + static constexpr FieldMetadata_TraceName kTraceName{}; + void set_trace_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_TraceName::kFieldId, data, size); + } + void set_trace_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_TraceName::kFieldId, chars.data, chars.size); + } + void set_trace_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_TraceName::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TraceType = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SdeTracingMarkWriteFtraceEvent>; + + static constexpr FieldMetadata_TraceType kTraceType{}; + void set_trace_type(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TraceType::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Value = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + SdeTracingMarkWriteFtraceEvent>; + + static constexpr FieldMetadata_Value kValue{}; + void set_value(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TraceBegin = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SdeTracingMarkWriteFtraceEvent>; + + static constexpr FieldMetadata_TraceBegin kTraceBegin{}; + void set_trace_begin(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TraceBegin::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class ScmCallEndFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + ScmCallEndFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ScmCallEndFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ScmCallEndFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} +}; + +class ScmCallEndFtraceEvent : public ::protozero::Message { + public: + using Decoder = ScmCallEndFtraceEvent_Decoder; + static constexpr const char* GetName() { return ".perfetto.protos.ScmCallEndFtraceEvent"; } + +}; + +class ScmCallStartFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + ScmCallStartFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ScmCallStartFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ScmCallStartFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_arginfo() const { return at<1>().valid(); } + uint32_t arginfo() const { return at<1>().as_uint32(); } + bool has_x0() const { return at<2>().valid(); } + uint64_t x0() const { return at<2>().as_uint64(); } + bool has_x5() const { return at<3>().valid(); } + uint64_t x5() const { return at<3>().as_uint64(); } +}; + +class ScmCallStartFtraceEvent : public ::protozero::Message { + public: + using Decoder = ScmCallStartFtraceEvent_Decoder; + enum : int32_t { + kArginfoFieldNumber = 1, + kX0FieldNumber = 2, + kX5FieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ScmCallStartFtraceEvent"; } + + + using FieldMetadata_Arginfo = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + ScmCallStartFtraceEvent>; + + static constexpr FieldMetadata_Arginfo kArginfo{}; + void set_arginfo(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Arginfo::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_X0 = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + ScmCallStartFtraceEvent>; + + static constexpr FieldMetadata_X0 kX0{}; + void set_x0(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_X0::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_X5 = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + ScmCallStartFtraceEvent>; + + static constexpr FieldMetadata_X5 kX5{}; + void set_x5(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_X5::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class SchedMigrateTaskFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + SchedMigrateTaskFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit SchedMigrateTaskFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit SchedMigrateTaskFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_comm() const { return at<1>().valid(); } + ::protozero::ConstChars comm() const { return at<1>().as_string(); } + bool has_pid() const { return at<2>().valid(); } + int32_t pid() const { return at<2>().as_int32(); } + bool has_prio() const { return at<3>().valid(); } + int32_t prio() const { return at<3>().as_int32(); } + bool has_orig_cpu() const { return at<4>().valid(); } + int32_t orig_cpu() const { return at<4>().as_int32(); } + bool has_dest_cpu() const { return at<5>().valid(); } + int32_t dest_cpu() const { return at<5>().as_int32(); } + bool has_running() const { return at<6>().valid(); } + int32_t running() const { return at<6>().as_int32(); } + bool has_load() const { return at<7>().valid(); } + uint32_t load() const { return at<7>().as_uint32(); } +}; + +class SchedMigrateTaskFtraceEvent : public ::protozero::Message { + public: + using Decoder = SchedMigrateTaskFtraceEvent_Decoder; + enum : int32_t { + kCommFieldNumber = 1, + kPidFieldNumber = 2, + kPrioFieldNumber = 3, + kOrigCpuFieldNumber = 4, + kDestCpuFieldNumber = 5, + kRunningFieldNumber = 6, + kLoadFieldNumber = 7, + }; + static constexpr const char* GetName() { return ".perfetto.protos.SchedMigrateTaskFtraceEvent"; } + + + using FieldMetadata_Comm = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + SchedMigrateTaskFtraceEvent>; + + static constexpr FieldMetadata_Comm kComm{}; + void set_comm(const char* data, size_t size) { + AppendBytes(FieldMetadata_Comm::kFieldId, data, size); + } + void set_comm(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Comm::kFieldId, chars.data, chars.size); + } + void set_comm(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Comm::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pid = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + SchedMigrateTaskFtraceEvent>; + + static constexpr FieldMetadata_Pid kPid{}; + void set_pid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Prio = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + SchedMigrateTaskFtraceEvent>; + + static constexpr FieldMetadata_Prio kPrio{}; + void set_prio(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Prio::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_OrigCpu = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + SchedMigrateTaskFtraceEvent>; + + static constexpr FieldMetadata_OrigCpu kOrigCpu{}; + void set_orig_cpu(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_OrigCpu::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DestCpu = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + SchedMigrateTaskFtraceEvent>; + + static constexpr FieldMetadata_DestCpu kDestCpu{}; + void set_dest_cpu(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_DestCpu::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Running = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + SchedMigrateTaskFtraceEvent>; + + static constexpr FieldMetadata_Running kRunning{}; + void set_running(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Running::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Load = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SchedMigrateTaskFtraceEvent>; + + static constexpr FieldMetadata_Load kLoad{}; + void set_load(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Load::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class SchedCpuUtilCfsFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + SchedCpuUtilCfsFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit SchedCpuUtilCfsFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit SchedCpuUtilCfsFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_active() const { return at<1>().valid(); } + int32_t active() const { return at<1>().as_int32(); } + bool has_capacity() const { return at<2>().valid(); } + uint64_t capacity() const { return at<2>().as_uint64(); } + bool has_capacity_orig() const { return at<3>().valid(); } + uint64_t capacity_orig() const { return at<3>().as_uint64(); } + bool has_cpu() const { return at<4>().valid(); } + uint32_t cpu() const { return at<4>().as_uint32(); } + bool has_cpu_importance() const { return at<5>().valid(); } + uint64_t cpu_importance() const { return at<5>().as_uint64(); } + bool has_cpu_util() const { return at<6>().valid(); } + uint64_t cpu_util() const { return at<6>().as_uint64(); } + bool has_exit_lat() const { return at<7>().valid(); } + uint32_t exit_lat() const { return at<7>().as_uint32(); } + bool has_group_capacity() const { return at<8>().valid(); } + uint64_t group_capacity() const { return at<8>().as_uint64(); } + bool has_grp_overutilized() const { return at<9>().valid(); } + uint32_t grp_overutilized() const { return at<9>().as_uint32(); } + bool has_idle_cpu() const { return at<10>().valid(); } + uint32_t idle_cpu() const { return at<10>().as_uint32(); } + bool has_nr_running() const { return at<11>().valid(); } + uint32_t nr_running() const { return at<11>().as_uint32(); } + bool has_spare_cap() const { return at<12>().valid(); } + int64_t spare_cap() const { return at<12>().as_int64(); } + bool has_task_fits() const { return at<13>().valid(); } + uint32_t task_fits() const { return at<13>().as_uint32(); } + bool has_wake_group_util() const { return at<14>().valid(); } + uint64_t wake_group_util() const { return at<14>().as_uint64(); } + bool has_wake_util() const { return at<15>().valid(); } + uint64_t wake_util() const { return at<15>().as_uint64(); } +}; + +class SchedCpuUtilCfsFtraceEvent : public ::protozero::Message { + public: + using Decoder = SchedCpuUtilCfsFtraceEvent_Decoder; + enum : int32_t { + kActiveFieldNumber = 1, + kCapacityFieldNumber = 2, + kCapacityOrigFieldNumber = 3, + kCpuFieldNumber = 4, + kCpuImportanceFieldNumber = 5, + kCpuUtilFieldNumber = 6, + kExitLatFieldNumber = 7, + kGroupCapacityFieldNumber = 8, + kGrpOverutilizedFieldNumber = 9, + kIdleCpuFieldNumber = 10, + kNrRunningFieldNumber = 11, + kSpareCapFieldNumber = 12, + kTaskFitsFieldNumber = 13, + kWakeGroupUtilFieldNumber = 14, + kWakeUtilFieldNumber = 15, + }; + static constexpr const char* GetName() { return ".perfetto.protos.SchedCpuUtilCfsFtraceEvent"; } + + + using FieldMetadata_Active = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + SchedCpuUtilCfsFtraceEvent>; + + static constexpr FieldMetadata_Active kActive{}; + void set_active(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Active::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Capacity = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + SchedCpuUtilCfsFtraceEvent>; + + static constexpr FieldMetadata_Capacity kCapacity{}; + void set_capacity(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Capacity::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CapacityOrig = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + SchedCpuUtilCfsFtraceEvent>; + + static constexpr FieldMetadata_CapacityOrig kCapacityOrig{}; + void set_capacity_orig(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_CapacityOrig::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Cpu = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SchedCpuUtilCfsFtraceEvent>; + + static constexpr FieldMetadata_Cpu kCpu{}; + void set_cpu(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Cpu::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CpuImportance = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + SchedCpuUtilCfsFtraceEvent>; + + static constexpr FieldMetadata_CpuImportance kCpuImportance{}; + void set_cpu_importance(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_CpuImportance::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CpuUtil = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + SchedCpuUtilCfsFtraceEvent>; + + static constexpr FieldMetadata_CpuUtil kCpuUtil{}; + void set_cpu_util(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_CpuUtil::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ExitLat = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SchedCpuUtilCfsFtraceEvent>; + + static constexpr FieldMetadata_ExitLat kExitLat{}; + void set_exit_lat(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ExitLat::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_GroupCapacity = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + SchedCpuUtilCfsFtraceEvent>; + + static constexpr FieldMetadata_GroupCapacity kGroupCapacity{}; + void set_group_capacity(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_GroupCapacity::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_GrpOverutilized = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SchedCpuUtilCfsFtraceEvent>; + + static constexpr FieldMetadata_GrpOverutilized kGrpOverutilized{}; + void set_grp_overutilized(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_GrpOverutilized::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_IdleCpu = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SchedCpuUtilCfsFtraceEvent>; + + static constexpr FieldMetadata_IdleCpu kIdleCpu{}; + void set_idle_cpu(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_IdleCpu::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NrRunning = + ::protozero::proto_utils::FieldMetadata< + 11, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SchedCpuUtilCfsFtraceEvent>; + + static constexpr FieldMetadata_NrRunning kNrRunning{}; + void set_nr_running(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_NrRunning::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SpareCap = + ::protozero::proto_utils::FieldMetadata< + 12, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + SchedCpuUtilCfsFtraceEvent>; + + static constexpr FieldMetadata_SpareCap kSpareCap{}; + void set_spare_cap(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_SpareCap::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TaskFits = + ::protozero::proto_utils::FieldMetadata< + 13, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SchedCpuUtilCfsFtraceEvent>; + + static constexpr FieldMetadata_TaskFits kTaskFits{}; + void set_task_fits(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TaskFits::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_WakeGroupUtil = + ::protozero::proto_utils::FieldMetadata< + 14, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + SchedCpuUtilCfsFtraceEvent>; + + static constexpr FieldMetadata_WakeGroupUtil kWakeGroupUtil{}; + void set_wake_group_util(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_WakeGroupUtil::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_WakeUtil = + ::protozero::proto_utils::FieldMetadata< + 15, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + SchedCpuUtilCfsFtraceEvent>; + + static constexpr FieldMetadata_WakeUtil kWakeUtil{}; + void set_wake_util(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_WakeUtil::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class SchedPiSetprioFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + SchedPiSetprioFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit SchedPiSetprioFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit SchedPiSetprioFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_comm() const { return at<1>().valid(); } + ::protozero::ConstChars comm() const { return at<1>().as_string(); } + bool has_newprio() const { return at<2>().valid(); } + int32_t newprio() const { return at<2>().as_int32(); } + bool has_oldprio() const { return at<3>().valid(); } + int32_t oldprio() const { return at<3>().as_int32(); } + bool has_pid() const { return at<4>().valid(); } + int32_t pid() const { return at<4>().as_int32(); } +}; + +class SchedPiSetprioFtraceEvent : public ::protozero::Message { + public: + using Decoder = SchedPiSetprioFtraceEvent_Decoder; + enum : int32_t { + kCommFieldNumber = 1, + kNewprioFieldNumber = 2, + kOldprioFieldNumber = 3, + kPidFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.SchedPiSetprioFtraceEvent"; } + + + using FieldMetadata_Comm = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + SchedPiSetprioFtraceEvent>; + + static constexpr FieldMetadata_Comm kComm{}; + void set_comm(const char* data, size_t size) { + AppendBytes(FieldMetadata_Comm::kFieldId, data, size); + } + void set_comm(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Comm::kFieldId, chars.data, chars.size); + } + void set_comm(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Comm::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Newprio = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + SchedPiSetprioFtraceEvent>; + + static constexpr FieldMetadata_Newprio kNewprio{}; + void set_newprio(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Newprio::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Oldprio = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + SchedPiSetprioFtraceEvent>; + + static constexpr FieldMetadata_Oldprio kOldprio{}; + void set_oldprio(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Oldprio::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pid = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + SchedPiSetprioFtraceEvent>; + + static constexpr FieldMetadata_Pid kPid{}; + void set_pid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class SchedProcessWaitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + SchedProcessWaitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit SchedProcessWaitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit SchedProcessWaitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_comm() const { return at<1>().valid(); } + ::protozero::ConstChars comm() const { return at<1>().as_string(); } + bool has_pid() const { return at<2>().valid(); } + int32_t pid() const { return at<2>().as_int32(); } + bool has_prio() const { return at<3>().valid(); } + int32_t prio() const { return at<3>().as_int32(); } +}; + +class SchedProcessWaitFtraceEvent : public ::protozero::Message { + public: + using Decoder = SchedProcessWaitFtraceEvent_Decoder; + enum : int32_t { + kCommFieldNumber = 1, + kPidFieldNumber = 2, + kPrioFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.SchedProcessWaitFtraceEvent"; } + + + using FieldMetadata_Comm = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + SchedProcessWaitFtraceEvent>; + + static constexpr FieldMetadata_Comm kComm{}; + void set_comm(const char* data, size_t size) { + AppendBytes(FieldMetadata_Comm::kFieldId, data, size); + } + void set_comm(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Comm::kFieldId, chars.data, chars.size); + } + void set_comm(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Comm::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pid = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + SchedProcessWaitFtraceEvent>; + + static constexpr FieldMetadata_Pid kPid{}; + void set_pid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Prio = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + SchedProcessWaitFtraceEvent>; + + static constexpr FieldMetadata_Prio kPrio{}; + void set_prio(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Prio::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class SchedProcessHangFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + SchedProcessHangFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit SchedProcessHangFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit SchedProcessHangFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_comm() const { return at<1>().valid(); } + ::protozero::ConstChars comm() const { return at<1>().as_string(); } + bool has_pid() const { return at<2>().valid(); } + int32_t pid() const { return at<2>().as_int32(); } +}; + +class SchedProcessHangFtraceEvent : public ::protozero::Message { + public: + using Decoder = SchedProcessHangFtraceEvent_Decoder; + enum : int32_t { + kCommFieldNumber = 1, + kPidFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.SchedProcessHangFtraceEvent"; } + + + using FieldMetadata_Comm = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + SchedProcessHangFtraceEvent>; + + static constexpr FieldMetadata_Comm kComm{}; + void set_comm(const char* data, size_t size) { + AppendBytes(FieldMetadata_Comm::kFieldId, data, size); + } + void set_comm(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Comm::kFieldId, chars.data, chars.size); + } + void set_comm(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Comm::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pid = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + SchedProcessHangFtraceEvent>; + + static constexpr FieldMetadata_Pid kPid{}; + void set_pid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class SchedProcessFreeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + SchedProcessFreeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit SchedProcessFreeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit SchedProcessFreeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_comm() const { return at<1>().valid(); } + ::protozero::ConstChars comm() const { return at<1>().as_string(); } + bool has_pid() const { return at<2>().valid(); } + int32_t pid() const { return at<2>().as_int32(); } + bool has_prio() const { return at<3>().valid(); } + int32_t prio() const { return at<3>().as_int32(); } +}; + +class SchedProcessFreeFtraceEvent : public ::protozero::Message { + public: + using Decoder = SchedProcessFreeFtraceEvent_Decoder; + enum : int32_t { + kCommFieldNumber = 1, + kPidFieldNumber = 2, + kPrioFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.SchedProcessFreeFtraceEvent"; } + + + using FieldMetadata_Comm = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + SchedProcessFreeFtraceEvent>; + + static constexpr FieldMetadata_Comm kComm{}; + void set_comm(const char* data, size_t size) { + AppendBytes(FieldMetadata_Comm::kFieldId, data, size); + } + void set_comm(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Comm::kFieldId, chars.data, chars.size); + } + void set_comm(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Comm::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pid = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + SchedProcessFreeFtraceEvent>; + + static constexpr FieldMetadata_Pid kPid{}; + void set_pid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Prio = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + SchedProcessFreeFtraceEvent>; + + static constexpr FieldMetadata_Prio kPrio{}; + void set_prio(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Prio::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class SchedProcessForkFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + SchedProcessForkFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit SchedProcessForkFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit SchedProcessForkFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_parent_comm() const { return at<1>().valid(); } + ::protozero::ConstChars parent_comm() const { return at<1>().as_string(); } + bool has_parent_pid() const { return at<2>().valid(); } + int32_t parent_pid() const { return at<2>().as_int32(); } + bool has_child_comm() const { return at<3>().valid(); } + ::protozero::ConstChars child_comm() const { return at<3>().as_string(); } + bool has_child_pid() const { return at<4>().valid(); } + int32_t child_pid() const { return at<4>().as_int32(); } +}; + +class SchedProcessForkFtraceEvent : public ::protozero::Message { + public: + using Decoder = SchedProcessForkFtraceEvent_Decoder; + enum : int32_t { + kParentCommFieldNumber = 1, + kParentPidFieldNumber = 2, + kChildCommFieldNumber = 3, + kChildPidFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.SchedProcessForkFtraceEvent"; } + + + using FieldMetadata_ParentComm = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + SchedProcessForkFtraceEvent>; + + static constexpr FieldMetadata_ParentComm kParentComm{}; + void set_parent_comm(const char* data, size_t size) { + AppendBytes(FieldMetadata_ParentComm::kFieldId, data, size); + } + void set_parent_comm(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_ParentComm::kFieldId, chars.data, chars.size); + } + void set_parent_comm(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_ParentComm::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ParentPid = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + SchedProcessForkFtraceEvent>; + + static constexpr FieldMetadata_ParentPid kParentPid{}; + void set_parent_pid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ParentPid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ChildComm = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + SchedProcessForkFtraceEvent>; + + static constexpr FieldMetadata_ChildComm kChildComm{}; + void set_child_comm(const char* data, size_t size) { + AppendBytes(FieldMetadata_ChildComm::kFieldId, data, size); + } + void set_child_comm(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_ChildComm::kFieldId, chars.data, chars.size); + } + void set_child_comm(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_ChildComm::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ChildPid = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + SchedProcessForkFtraceEvent>; + + static constexpr FieldMetadata_ChildPid kChildPid{}; + void set_child_pid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ChildPid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class SchedProcessExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + SchedProcessExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit SchedProcessExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit SchedProcessExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_comm() const { return at<1>().valid(); } + ::protozero::ConstChars comm() const { return at<1>().as_string(); } + bool has_pid() const { return at<2>().valid(); } + int32_t pid() const { return at<2>().as_int32(); } + bool has_tgid() const { return at<3>().valid(); } + int32_t tgid() const { return at<3>().as_int32(); } + bool has_prio() const { return at<4>().valid(); } + int32_t prio() const { return at<4>().as_int32(); } +}; + +class SchedProcessExitFtraceEvent : public ::protozero::Message { + public: + using Decoder = SchedProcessExitFtraceEvent_Decoder; + enum : int32_t { + kCommFieldNumber = 1, + kPidFieldNumber = 2, + kTgidFieldNumber = 3, + kPrioFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.SchedProcessExitFtraceEvent"; } + + + using FieldMetadata_Comm = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + SchedProcessExitFtraceEvent>; + + static constexpr FieldMetadata_Comm kComm{}; + void set_comm(const char* data, size_t size) { + AppendBytes(FieldMetadata_Comm::kFieldId, data, size); + } + void set_comm(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Comm::kFieldId, chars.data, chars.size); + } + void set_comm(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Comm::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pid = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + SchedProcessExitFtraceEvent>; + + static constexpr FieldMetadata_Pid kPid{}; + void set_pid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Tgid = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + SchedProcessExitFtraceEvent>; + + static constexpr FieldMetadata_Tgid kTgid{}; + void set_tgid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Tgid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Prio = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + SchedProcessExitFtraceEvent>; + + static constexpr FieldMetadata_Prio kPrio{}; + void set_prio(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Prio::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class SchedProcessExecFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + SchedProcessExecFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit SchedProcessExecFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit SchedProcessExecFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_filename() const { return at<1>().valid(); } + ::protozero::ConstChars filename() const { return at<1>().as_string(); } + bool has_pid() const { return at<2>().valid(); } + int32_t pid() const { return at<2>().as_int32(); } + bool has_old_pid() const { return at<3>().valid(); } + int32_t old_pid() const { return at<3>().as_int32(); } +}; + +class SchedProcessExecFtraceEvent : public ::protozero::Message { + public: + using Decoder = SchedProcessExecFtraceEvent_Decoder; + enum : int32_t { + kFilenameFieldNumber = 1, + kPidFieldNumber = 2, + kOldPidFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.SchedProcessExecFtraceEvent"; } + + + using FieldMetadata_Filename = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + SchedProcessExecFtraceEvent>; + + static constexpr FieldMetadata_Filename kFilename{}; + void set_filename(const char* data, size_t size) { + AppendBytes(FieldMetadata_Filename::kFieldId, data, size); + } + void set_filename(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Filename::kFieldId, chars.data, chars.size); + } + void set_filename(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Filename::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pid = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + SchedProcessExecFtraceEvent>; + + static constexpr FieldMetadata_Pid kPid{}; + void set_pid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_OldPid = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + SchedProcessExecFtraceEvent>; + + static constexpr FieldMetadata_OldPid kOldPid{}; + void set_old_pid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_OldPid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class SchedWakeupNewFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + SchedWakeupNewFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit SchedWakeupNewFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit SchedWakeupNewFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_comm() const { return at<1>().valid(); } + ::protozero::ConstChars comm() const { return at<1>().as_string(); } + bool has_pid() const { return at<2>().valid(); } + int32_t pid() const { return at<2>().as_int32(); } + bool has_prio() const { return at<3>().valid(); } + int32_t prio() const { return at<3>().as_int32(); } + bool has_success() const { return at<4>().valid(); } + int32_t success() const { return at<4>().as_int32(); } + bool has_target_cpu() const { return at<5>().valid(); } + int32_t target_cpu() const { return at<5>().as_int32(); } +}; + +class SchedWakeupNewFtraceEvent : public ::protozero::Message { + public: + using Decoder = SchedWakeupNewFtraceEvent_Decoder; + enum : int32_t { + kCommFieldNumber = 1, + kPidFieldNumber = 2, + kPrioFieldNumber = 3, + kSuccessFieldNumber = 4, + kTargetCpuFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.SchedWakeupNewFtraceEvent"; } + + + using FieldMetadata_Comm = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + SchedWakeupNewFtraceEvent>; + + static constexpr FieldMetadata_Comm kComm{}; + void set_comm(const char* data, size_t size) { + AppendBytes(FieldMetadata_Comm::kFieldId, data, size); + } + void set_comm(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Comm::kFieldId, chars.data, chars.size); + } + void set_comm(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Comm::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pid = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + SchedWakeupNewFtraceEvent>; + + static constexpr FieldMetadata_Pid kPid{}; + void set_pid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Prio = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + SchedWakeupNewFtraceEvent>; + + static constexpr FieldMetadata_Prio kPrio{}; + void set_prio(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Prio::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Success = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + SchedWakeupNewFtraceEvent>; + + static constexpr FieldMetadata_Success kSuccess{}; + void set_success(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Success::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TargetCpu = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + SchedWakeupNewFtraceEvent>; + + static constexpr FieldMetadata_TargetCpu kTargetCpu{}; + void set_target_cpu(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TargetCpu::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class SchedWakingFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + SchedWakingFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit SchedWakingFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit SchedWakingFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_comm() const { return at<1>().valid(); } + ::protozero::ConstChars comm() const { return at<1>().as_string(); } + bool has_pid() const { return at<2>().valid(); } + int32_t pid() const { return at<2>().as_int32(); } + bool has_prio() const { return at<3>().valid(); } + int32_t prio() const { return at<3>().as_int32(); } + bool has_success() const { return at<4>().valid(); } + int32_t success() const { return at<4>().as_int32(); } + bool has_target_cpu() const { return at<5>().valid(); } + int32_t target_cpu() const { return at<5>().as_int32(); } +}; + +class SchedWakingFtraceEvent : public ::protozero::Message { + public: + using Decoder = SchedWakingFtraceEvent_Decoder; + enum : int32_t { + kCommFieldNumber = 1, + kPidFieldNumber = 2, + kPrioFieldNumber = 3, + kSuccessFieldNumber = 4, + kTargetCpuFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.SchedWakingFtraceEvent"; } + + + using FieldMetadata_Comm = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + SchedWakingFtraceEvent>; + + static constexpr FieldMetadata_Comm kComm{}; + void set_comm(const char* data, size_t size) { + AppendBytes(FieldMetadata_Comm::kFieldId, data, size); + } + void set_comm(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Comm::kFieldId, chars.data, chars.size); + } + void set_comm(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Comm::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pid = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + SchedWakingFtraceEvent>; + + static constexpr FieldMetadata_Pid kPid{}; + void set_pid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Prio = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + SchedWakingFtraceEvent>; + + static constexpr FieldMetadata_Prio kPrio{}; + void set_prio(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Prio::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Success = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + SchedWakingFtraceEvent>; + + static constexpr FieldMetadata_Success kSuccess{}; + void set_success(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Success::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TargetCpu = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + SchedWakingFtraceEvent>; + + static constexpr FieldMetadata_TargetCpu kTargetCpu{}; + void set_target_cpu(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TargetCpu::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class SchedCpuHotplugFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + SchedCpuHotplugFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit SchedCpuHotplugFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit SchedCpuHotplugFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_affected_cpu() const { return at<1>().valid(); } + int32_t affected_cpu() const { return at<1>().as_int32(); } + bool has_error() const { return at<2>().valid(); } + int32_t error() const { return at<2>().as_int32(); } + bool has_status() const { return at<3>().valid(); } + int32_t status() const { return at<3>().as_int32(); } +}; + +class SchedCpuHotplugFtraceEvent : public ::protozero::Message { + public: + using Decoder = SchedCpuHotplugFtraceEvent_Decoder; + enum : int32_t { + kAffectedCpuFieldNumber = 1, + kErrorFieldNumber = 2, + kStatusFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.SchedCpuHotplugFtraceEvent"; } + + + using FieldMetadata_AffectedCpu = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + SchedCpuHotplugFtraceEvent>; + + static constexpr FieldMetadata_AffectedCpu kAffectedCpu{}; + void set_affected_cpu(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_AffectedCpu::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Error = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + SchedCpuHotplugFtraceEvent>; + + static constexpr FieldMetadata_Error kError{}; + void set_error(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Error::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Status = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + SchedCpuHotplugFtraceEvent>; + + static constexpr FieldMetadata_Status kStatus{}; + void set_status(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Status::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class SchedBlockedReasonFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + SchedBlockedReasonFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit SchedBlockedReasonFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit SchedBlockedReasonFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_pid() const { return at<1>().valid(); } + int32_t pid() const { return at<1>().as_int32(); } + bool has_caller() const { return at<2>().valid(); } + uint64_t caller() const { return at<2>().as_uint64(); } + bool has_io_wait() const { return at<3>().valid(); } + uint32_t io_wait() const { return at<3>().as_uint32(); } +}; + +class SchedBlockedReasonFtraceEvent : public ::protozero::Message { + public: + using Decoder = SchedBlockedReasonFtraceEvent_Decoder; + enum : int32_t { + kPidFieldNumber = 1, + kCallerFieldNumber = 2, + kIoWaitFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.SchedBlockedReasonFtraceEvent"; } + + + using FieldMetadata_Pid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + SchedBlockedReasonFtraceEvent>; + + static constexpr FieldMetadata_Pid kPid{}; + void set_pid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Caller = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + SchedBlockedReasonFtraceEvent>; + + static constexpr FieldMetadata_Caller kCaller{}; + void set_caller(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Caller::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_IoWait = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SchedBlockedReasonFtraceEvent>; + + static constexpr FieldMetadata_IoWait kIoWait{}; + void set_io_wait(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_IoWait::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class SchedWakeupFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + SchedWakeupFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit SchedWakeupFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit SchedWakeupFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_comm() const { return at<1>().valid(); } + ::protozero::ConstChars comm() const { return at<1>().as_string(); } + bool has_pid() const { return at<2>().valid(); } + int32_t pid() const { return at<2>().as_int32(); } + bool has_prio() const { return at<3>().valid(); } + int32_t prio() const { return at<3>().as_int32(); } + bool has_success() const { return at<4>().valid(); } + int32_t success() const { return at<4>().as_int32(); } + bool has_target_cpu() const { return at<5>().valid(); } + int32_t target_cpu() const { return at<5>().as_int32(); } +}; + +class SchedWakeupFtraceEvent : public ::protozero::Message { + public: + using Decoder = SchedWakeupFtraceEvent_Decoder; + enum : int32_t { + kCommFieldNumber = 1, + kPidFieldNumber = 2, + kPrioFieldNumber = 3, + kSuccessFieldNumber = 4, + kTargetCpuFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.SchedWakeupFtraceEvent"; } + + + using FieldMetadata_Comm = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + SchedWakeupFtraceEvent>; + + static constexpr FieldMetadata_Comm kComm{}; + void set_comm(const char* data, size_t size) { + AppendBytes(FieldMetadata_Comm::kFieldId, data, size); + } + void set_comm(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Comm::kFieldId, chars.data, chars.size); + } + void set_comm(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Comm::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pid = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + SchedWakeupFtraceEvent>; + + static constexpr FieldMetadata_Pid kPid{}; + void set_pid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Prio = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + SchedWakeupFtraceEvent>; + + static constexpr FieldMetadata_Prio kPrio{}; + void set_prio(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Prio::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Success = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + SchedWakeupFtraceEvent>; + + static constexpr FieldMetadata_Success kSuccess{}; + void set_success(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Success::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TargetCpu = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + SchedWakeupFtraceEvent>; + + static constexpr FieldMetadata_TargetCpu kTargetCpu{}; + void set_target_cpu(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TargetCpu::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class SchedSwitchFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + SchedSwitchFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit SchedSwitchFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit SchedSwitchFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_prev_comm() const { return at<1>().valid(); } + ::protozero::ConstChars prev_comm() const { return at<1>().as_string(); } + bool has_prev_pid() const { return at<2>().valid(); } + int32_t prev_pid() const { return at<2>().as_int32(); } + bool has_prev_prio() const { return at<3>().valid(); } + int32_t prev_prio() const { return at<3>().as_int32(); } + bool has_prev_state() const { return at<4>().valid(); } + int64_t prev_state() const { return at<4>().as_int64(); } + bool has_next_comm() const { return at<5>().valid(); } + ::protozero::ConstChars next_comm() const { return at<5>().as_string(); } + bool has_next_pid() const { return at<6>().valid(); } + int32_t next_pid() const { return at<6>().as_int32(); } + bool has_next_prio() const { return at<7>().valid(); } + int32_t next_prio() const { return at<7>().as_int32(); } +}; + +class SchedSwitchFtraceEvent : public ::protozero::Message { + public: + using Decoder = SchedSwitchFtraceEvent_Decoder; + enum : int32_t { + kPrevCommFieldNumber = 1, + kPrevPidFieldNumber = 2, + kPrevPrioFieldNumber = 3, + kPrevStateFieldNumber = 4, + kNextCommFieldNumber = 5, + kNextPidFieldNumber = 6, + kNextPrioFieldNumber = 7, + }; + static constexpr const char* GetName() { return ".perfetto.protos.SchedSwitchFtraceEvent"; } + + + using FieldMetadata_PrevComm = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + SchedSwitchFtraceEvent>; + + static constexpr FieldMetadata_PrevComm kPrevComm{}; + void set_prev_comm(const char* data, size_t size) { + AppendBytes(FieldMetadata_PrevComm::kFieldId, data, size); + } + void set_prev_comm(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_PrevComm::kFieldId, chars.data, chars.size); + } + void set_prev_comm(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_PrevComm::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PrevPid = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + SchedSwitchFtraceEvent>; + + static constexpr FieldMetadata_PrevPid kPrevPid{}; + void set_prev_pid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_PrevPid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PrevPrio = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + SchedSwitchFtraceEvent>; + + static constexpr FieldMetadata_PrevPrio kPrevPrio{}; + void set_prev_prio(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_PrevPrio::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PrevState = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + SchedSwitchFtraceEvent>; + + static constexpr FieldMetadata_PrevState kPrevState{}; + void set_prev_state(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_PrevState::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NextComm = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + SchedSwitchFtraceEvent>; + + static constexpr FieldMetadata_NextComm kNextComm{}; + void set_next_comm(const char* data, size_t size) { + AppendBytes(FieldMetadata_NextComm::kFieldId, data, size); + } + void set_next_comm(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_NextComm::kFieldId, chars.data, chars.size); + } + void set_next_comm(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_NextComm::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NextPid = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + SchedSwitchFtraceEvent>; + + static constexpr FieldMetadata_NextPid kNextPid{}; + void set_next_pid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_NextPid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NextPrio = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + SchedSwitchFtraceEvent>; + + static constexpr FieldMetadata_NextPrio kNextPrio{}; + void set_next_prio(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_NextPrio::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class SamsungTracingMarkWriteFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + SamsungTracingMarkWriteFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit SamsungTracingMarkWriteFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit SamsungTracingMarkWriteFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_pid() const { return at<1>().valid(); } + int32_t pid() const { return at<1>().as_int32(); } + bool has_trace_name() const { return at<2>().valid(); } + ::protozero::ConstChars trace_name() const { return at<2>().as_string(); } + bool has_trace_begin() const { return at<3>().valid(); } + uint32_t trace_begin() const { return at<3>().as_uint32(); } + bool has_trace_type() const { return at<4>().valid(); } + uint32_t trace_type() const { return at<4>().as_uint32(); } + bool has_value() const { return at<5>().valid(); } + int32_t value() const { return at<5>().as_int32(); } +}; + +class SamsungTracingMarkWriteFtraceEvent : public ::protozero::Message { + public: + using Decoder = SamsungTracingMarkWriteFtraceEvent_Decoder; + enum : int32_t { + kPidFieldNumber = 1, + kTraceNameFieldNumber = 2, + kTraceBeginFieldNumber = 3, + kTraceTypeFieldNumber = 4, + kValueFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.SamsungTracingMarkWriteFtraceEvent"; } + + + using FieldMetadata_Pid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + SamsungTracingMarkWriteFtraceEvent>; + + static constexpr FieldMetadata_Pid kPid{}; + void set_pid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TraceName = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + SamsungTracingMarkWriteFtraceEvent>; + + static constexpr FieldMetadata_TraceName kTraceName{}; + void set_trace_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_TraceName::kFieldId, data, size); + } + void set_trace_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_TraceName::kFieldId, chars.data, chars.size); + } + void set_trace_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_TraceName::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TraceBegin = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SamsungTracingMarkWriteFtraceEvent>; + + static constexpr FieldMetadata_TraceBegin kTraceBegin{}; + void set_trace_begin(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TraceBegin::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TraceType = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SamsungTracingMarkWriteFtraceEvent>; + + static constexpr FieldMetadata_TraceType kTraceType{}; + void set_trace_type(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TraceType::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Value = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + SamsungTracingMarkWriteFtraceEvent>; + + static constexpr FieldMetadata_Value kValue{}; + void set_value(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class RpmStatusFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + RpmStatusFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit RpmStatusFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit RpmStatusFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_name() const { return at<1>().valid(); } + ::protozero::ConstChars name() const { return at<1>().as_string(); } + bool has_status() const { return at<2>().valid(); } + int32_t status() const { return at<2>().as_int32(); } +}; + +class RpmStatusFtraceEvent : public ::protozero::Message { + public: + using Decoder = RpmStatusFtraceEvent_Decoder; + enum : int32_t { + kNameFieldNumber = 1, + kStatusFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.RpmStatusFtraceEvent"; } + + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + RpmStatusFtraceEvent>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Status = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + RpmStatusFtraceEvent>; + + static constexpr FieldMetadata_Status kStatus{}; + void set_status(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Status::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class RegulatorSetVoltageCompleteFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + RegulatorSetVoltageCompleteFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit RegulatorSetVoltageCompleteFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit RegulatorSetVoltageCompleteFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_name() const { return at<1>().valid(); } + ::protozero::ConstChars name() const { return at<1>().as_string(); } + bool has_val() const { return at<2>().valid(); } + uint32_t val() const { return at<2>().as_uint32(); } +}; + +class RegulatorSetVoltageCompleteFtraceEvent : public ::protozero::Message { + public: + using Decoder = RegulatorSetVoltageCompleteFtraceEvent_Decoder; + enum : int32_t { + kNameFieldNumber = 1, + kValFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.RegulatorSetVoltageCompleteFtraceEvent"; } + + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + RegulatorSetVoltageCompleteFtraceEvent>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Val = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + RegulatorSetVoltageCompleteFtraceEvent>; + + static constexpr FieldMetadata_Val kVal{}; + void set_val(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Val::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class RegulatorSetVoltageFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + RegulatorSetVoltageFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit RegulatorSetVoltageFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit RegulatorSetVoltageFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_name() const { return at<1>().valid(); } + ::protozero::ConstChars name() const { return at<1>().as_string(); } + bool has_min() const { return at<2>().valid(); } + int32_t min() const { return at<2>().as_int32(); } + bool has_max() const { return at<3>().valid(); } + int32_t max() const { return at<3>().as_int32(); } +}; + +class RegulatorSetVoltageFtraceEvent : public ::protozero::Message { + public: + using Decoder = RegulatorSetVoltageFtraceEvent_Decoder; + enum : int32_t { + kNameFieldNumber = 1, + kMinFieldNumber = 2, + kMaxFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.RegulatorSetVoltageFtraceEvent"; } + + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + RegulatorSetVoltageFtraceEvent>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Min = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + RegulatorSetVoltageFtraceEvent>; + + static constexpr FieldMetadata_Min kMin{}; + void set_min(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Min::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Max = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + RegulatorSetVoltageFtraceEvent>; + + static constexpr FieldMetadata_Max kMax{}; + void set_max(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Max::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class RegulatorEnableDelayFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + RegulatorEnableDelayFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit RegulatorEnableDelayFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit RegulatorEnableDelayFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_name() const { return at<1>().valid(); } + ::protozero::ConstChars name() const { return at<1>().as_string(); } +}; + +class RegulatorEnableDelayFtraceEvent : public ::protozero::Message { + public: + using Decoder = RegulatorEnableDelayFtraceEvent_Decoder; + enum : int32_t { + kNameFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.RegulatorEnableDelayFtraceEvent"; } + + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + RegulatorEnableDelayFtraceEvent>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class RegulatorEnableCompleteFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + RegulatorEnableCompleteFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit RegulatorEnableCompleteFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit RegulatorEnableCompleteFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_name() const { return at<1>().valid(); } + ::protozero::ConstChars name() const { return at<1>().as_string(); } +}; + +class RegulatorEnableCompleteFtraceEvent : public ::protozero::Message { + public: + using Decoder = RegulatorEnableCompleteFtraceEvent_Decoder; + enum : int32_t { + kNameFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.RegulatorEnableCompleteFtraceEvent"; } + + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + RegulatorEnableCompleteFtraceEvent>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class RegulatorEnableFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + RegulatorEnableFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit RegulatorEnableFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit RegulatorEnableFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_name() const { return at<1>().valid(); } + ::protozero::ConstChars name() const { return at<1>().as_string(); } +}; + +class RegulatorEnableFtraceEvent : public ::protozero::Message { + public: + using Decoder = RegulatorEnableFtraceEvent_Decoder; + enum : int32_t { + kNameFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.RegulatorEnableFtraceEvent"; } + + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + RegulatorEnableFtraceEvent>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class RegulatorDisableCompleteFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + RegulatorDisableCompleteFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit RegulatorDisableCompleteFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit RegulatorDisableCompleteFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_name() const { return at<1>().valid(); } + ::protozero::ConstChars name() const { return at<1>().as_string(); } +}; + +class RegulatorDisableCompleteFtraceEvent : public ::protozero::Message { + public: + using Decoder = RegulatorDisableCompleteFtraceEvent_Decoder; + enum : int32_t { + kNameFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.RegulatorDisableCompleteFtraceEvent"; } + + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + RegulatorDisableCompleteFtraceEvent>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class RegulatorDisableFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + RegulatorDisableFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit RegulatorDisableFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit RegulatorDisableFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_name() const { return at<1>().valid(); } + ::protozero::ConstChars name() const { return at<1>().as_string(); } +}; + +class RegulatorDisableFtraceEvent : public ::protozero::Message { + public: + using Decoder = RegulatorDisableFtraceEvent_Decoder; + enum : int32_t { + kNameFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.RegulatorDisableFtraceEvent"; } + + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + RegulatorDisableFtraceEvent>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class SysExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + SysExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit SysExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit SysExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_id() const { return at<1>().valid(); } + int64_t id() const { return at<1>().as_int64(); } + bool has_ret() const { return at<2>().valid(); } + int64_t ret() const { return at<2>().as_int64(); } +}; + +class SysExitFtraceEvent : public ::protozero::Message { + public: + using Decoder = SysExitFtraceEvent_Decoder; + enum : int32_t { + kIdFieldNumber = 1, + kRetFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.SysExitFtraceEvent"; } + + + using FieldMetadata_Id = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + SysExitFtraceEvent>; + + static constexpr FieldMetadata_Id kId{}; + void set_id(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ret = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + SysExitFtraceEvent>; + + static constexpr FieldMetadata_Ret kRet{}; + void set_ret(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } +}; + +class SysEnterFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + SysEnterFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit SysEnterFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit SysEnterFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_id() const { return at<1>().valid(); } + int64_t id() const { return at<1>().as_int64(); } + bool has_args() const { return at<2>().valid(); } + ::protozero::RepeatedFieldIterator args() const { return GetRepeated(2); } +}; + +class SysEnterFtraceEvent : public ::protozero::Message { + public: + using Decoder = SysEnterFtraceEvent_Decoder; + enum : int32_t { + kIdFieldNumber = 1, + kArgsFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.SysEnterFtraceEvent"; } + + + using FieldMetadata_Id = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + SysEnterFtraceEvent>; + + static constexpr FieldMetadata_Id kId{}; + void set_id(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Args = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + SysEnterFtraceEvent>; + + static constexpr FieldMetadata_Args kArgs{}; + void add_args(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Args::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class ConsoleFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + ConsoleFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ConsoleFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ConsoleFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_msg() const { return at<1>().valid(); } + ::protozero::ConstChars msg() const { return at<1>().as_string(); } +}; + +class ConsoleFtraceEvent : public ::protozero::Message { + public: + using Decoder = ConsoleFtraceEvent_Decoder; + enum : int32_t { + kMsgFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ConsoleFtraceEvent"; } + + + using FieldMetadata_Msg = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + ConsoleFtraceEvent>; + + static constexpr FieldMetadata_Msg kMsg{}; + void set_msg(const char* data, size_t size) { + AppendBytes(FieldMetadata_Msg::kFieldId, data, size); + } + void set_msg(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Msg::kFieldId, chars.data, chars.size); + } + void set_msg(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Msg::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class GpuWorkPeriodFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + GpuWorkPeriodFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit GpuWorkPeriodFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit GpuWorkPeriodFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_gpu_id() const { return at<1>().valid(); } + uint32_t gpu_id() const { return at<1>().as_uint32(); } + bool has_uid() const { return at<2>().valid(); } + uint32_t uid() const { return at<2>().as_uint32(); } + bool has_start_time_ns() const { return at<3>().valid(); } + uint64_t start_time_ns() const { return at<3>().as_uint64(); } + bool has_end_time_ns() const { return at<4>().valid(); } + uint64_t end_time_ns() const { return at<4>().as_uint64(); } + bool has_total_active_duration_ns() const { return at<5>().valid(); } + uint64_t total_active_duration_ns() const { return at<5>().as_uint64(); } +}; + +class GpuWorkPeriodFtraceEvent : public ::protozero::Message { + public: + using Decoder = GpuWorkPeriodFtraceEvent_Decoder; + enum : int32_t { + kGpuIdFieldNumber = 1, + kUidFieldNumber = 2, + kStartTimeNsFieldNumber = 3, + kEndTimeNsFieldNumber = 4, + kTotalActiveDurationNsFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.GpuWorkPeriodFtraceEvent"; } + + + using FieldMetadata_GpuId = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + GpuWorkPeriodFtraceEvent>; + + static constexpr FieldMetadata_GpuId kGpuId{}; + void set_gpu_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_GpuId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Uid = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + GpuWorkPeriodFtraceEvent>; + + static constexpr FieldMetadata_Uid kUid{}; + void set_uid(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Uid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_StartTimeNs = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + GpuWorkPeriodFtraceEvent>; + + static constexpr FieldMetadata_StartTimeNs kStartTimeNs{}; + void set_start_time_ns(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_StartTimeNs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_EndTimeNs = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + GpuWorkPeriodFtraceEvent>; + + static constexpr FieldMetadata_EndTimeNs kEndTimeNs{}; + void set_end_time_ns(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_EndTimeNs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TotalActiveDurationNs = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + GpuWorkPeriodFtraceEvent>; + + static constexpr FieldMetadata_TotalActiveDurationNs kTotalActiveDurationNs{}; + void set_total_active_duration_ns(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_TotalActiveDurationNs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class WakeupSourceDeactivateFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + WakeupSourceDeactivateFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit WakeupSourceDeactivateFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit WakeupSourceDeactivateFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_name() const { return at<1>().valid(); } + ::protozero::ConstChars name() const { return at<1>().as_string(); } + bool has_state() const { return at<2>().valid(); } + uint64_t state() const { return at<2>().as_uint64(); } +}; + +class WakeupSourceDeactivateFtraceEvent : public ::protozero::Message { + public: + using Decoder = WakeupSourceDeactivateFtraceEvent_Decoder; + enum : int32_t { + kNameFieldNumber = 1, + kStateFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.WakeupSourceDeactivateFtraceEvent"; } + + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + WakeupSourceDeactivateFtraceEvent>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_State = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + WakeupSourceDeactivateFtraceEvent>; + + static constexpr FieldMetadata_State kState{}; + void set_state(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_State::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class WakeupSourceActivateFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + WakeupSourceActivateFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit WakeupSourceActivateFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit WakeupSourceActivateFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_name() const { return at<1>().valid(); } + ::protozero::ConstChars name() const { return at<1>().as_string(); } + bool has_state() const { return at<2>().valid(); } + uint64_t state() const { return at<2>().as_uint64(); } +}; + +class WakeupSourceActivateFtraceEvent : public ::protozero::Message { + public: + using Decoder = WakeupSourceActivateFtraceEvent_Decoder; + enum : int32_t { + kNameFieldNumber = 1, + kStateFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.WakeupSourceActivateFtraceEvent"; } + + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + WakeupSourceActivateFtraceEvent>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_State = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + WakeupSourceActivateFtraceEvent>; + + static constexpr FieldMetadata_State kState{}; + void set_state(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_State::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class GpuFrequencyFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + GpuFrequencyFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit GpuFrequencyFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit GpuFrequencyFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_gpu_id() const { return at<1>().valid(); } + uint32_t gpu_id() const { return at<1>().as_uint32(); } + bool has_state() const { return at<2>().valid(); } + uint32_t state() const { return at<2>().as_uint32(); } +}; + +class GpuFrequencyFtraceEvent : public ::protozero::Message { + public: + using Decoder = GpuFrequencyFtraceEvent_Decoder; + enum : int32_t { + kGpuIdFieldNumber = 1, + kStateFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.GpuFrequencyFtraceEvent"; } + + + using FieldMetadata_GpuId = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + GpuFrequencyFtraceEvent>; + + static constexpr FieldMetadata_GpuId kGpuId{}; + void set_gpu_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_GpuId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_State = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + GpuFrequencyFtraceEvent>; + + static constexpr FieldMetadata_State kState{}; + void set_state(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_State::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class SuspendResumeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + SuspendResumeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit SuspendResumeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit SuspendResumeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_action() const { return at<1>().valid(); } + ::protozero::ConstChars action() const { return at<1>().as_string(); } + bool has_val() const { return at<2>().valid(); } + int32_t val() const { return at<2>().as_int32(); } + bool has_start() const { return at<3>().valid(); } + uint32_t start() const { return at<3>().as_uint32(); } +}; + +class SuspendResumeFtraceEvent : public ::protozero::Message { + public: + using Decoder = SuspendResumeFtraceEvent_Decoder; + enum : int32_t { + kActionFieldNumber = 1, + kValFieldNumber = 2, + kStartFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.SuspendResumeFtraceEvent"; } + + + using FieldMetadata_Action = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + SuspendResumeFtraceEvent>; + + static constexpr FieldMetadata_Action kAction{}; + void set_action(const char* data, size_t size) { + AppendBytes(FieldMetadata_Action::kFieldId, data, size); + } + void set_action(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Action::kFieldId, chars.data, chars.size); + } + void set_action(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Action::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Val = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + SuspendResumeFtraceEvent>; + + static constexpr FieldMetadata_Val kVal{}; + void set_val(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Val::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Start = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SuspendResumeFtraceEvent>; + + static constexpr FieldMetadata_Start kStart{}; + void set_start(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Start::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class ClockSetRateFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + ClockSetRateFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ClockSetRateFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ClockSetRateFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_name() const { return at<1>().valid(); } + ::protozero::ConstChars name() const { return at<1>().as_string(); } + bool has_state() const { return at<2>().valid(); } + uint64_t state() const { return at<2>().as_uint64(); } + bool has_cpu_id() const { return at<3>().valid(); } + uint64_t cpu_id() const { return at<3>().as_uint64(); } +}; + +class ClockSetRateFtraceEvent : public ::protozero::Message { + public: + using Decoder = ClockSetRateFtraceEvent_Decoder; + enum : int32_t { + kNameFieldNumber = 1, + kStateFieldNumber = 2, + kCpuIdFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ClockSetRateFtraceEvent"; } + + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + ClockSetRateFtraceEvent>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_State = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + ClockSetRateFtraceEvent>; + + static constexpr FieldMetadata_State kState{}; + void set_state(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_State::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CpuId = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + ClockSetRateFtraceEvent>; + + static constexpr FieldMetadata_CpuId kCpuId{}; + void set_cpu_id(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_CpuId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class ClockDisableFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + ClockDisableFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ClockDisableFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ClockDisableFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_name() const { return at<1>().valid(); } + ::protozero::ConstChars name() const { return at<1>().as_string(); } + bool has_state() const { return at<2>().valid(); } + uint64_t state() const { return at<2>().as_uint64(); } + bool has_cpu_id() const { return at<3>().valid(); } + uint64_t cpu_id() const { return at<3>().as_uint64(); } +}; + +class ClockDisableFtraceEvent : public ::protozero::Message { + public: + using Decoder = ClockDisableFtraceEvent_Decoder; + enum : int32_t { + kNameFieldNumber = 1, + kStateFieldNumber = 2, + kCpuIdFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ClockDisableFtraceEvent"; } + + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + ClockDisableFtraceEvent>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_State = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + ClockDisableFtraceEvent>; + + static constexpr FieldMetadata_State kState{}; + void set_state(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_State::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CpuId = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + ClockDisableFtraceEvent>; + + static constexpr FieldMetadata_CpuId kCpuId{}; + void set_cpu_id(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_CpuId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class ClockEnableFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + ClockEnableFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ClockEnableFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ClockEnableFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_name() const { return at<1>().valid(); } + ::protozero::ConstChars name() const { return at<1>().as_string(); } + bool has_state() const { return at<2>().valid(); } + uint64_t state() const { return at<2>().as_uint64(); } + bool has_cpu_id() const { return at<3>().valid(); } + uint64_t cpu_id() const { return at<3>().as_uint64(); } +}; + +class ClockEnableFtraceEvent : public ::protozero::Message { + public: + using Decoder = ClockEnableFtraceEvent_Decoder; + enum : int32_t { + kNameFieldNumber = 1, + kStateFieldNumber = 2, + kCpuIdFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ClockEnableFtraceEvent"; } + + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + ClockEnableFtraceEvent>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_State = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + ClockEnableFtraceEvent>; + + static constexpr FieldMetadata_State kState{}; + void set_state(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_State::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CpuId = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + ClockEnableFtraceEvent>; + + static constexpr FieldMetadata_CpuId kCpuId{}; + void set_cpu_id(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_CpuId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class CpuIdleFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + CpuIdleFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit CpuIdleFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit CpuIdleFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_state() const { return at<1>().valid(); } + uint32_t state() const { return at<1>().as_uint32(); } + bool has_cpu_id() const { return at<2>().valid(); } + uint32_t cpu_id() const { return at<2>().as_uint32(); } +}; + +class CpuIdleFtraceEvent : public ::protozero::Message { + public: + using Decoder = CpuIdleFtraceEvent_Decoder; + enum : int32_t { + kStateFieldNumber = 1, + kCpuIdFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.CpuIdleFtraceEvent"; } + + + using FieldMetadata_State = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + CpuIdleFtraceEvent>; + + static constexpr FieldMetadata_State kState{}; + void set_state(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_State::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CpuId = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + CpuIdleFtraceEvent>; + + static constexpr FieldMetadata_CpuId kCpuId{}; + void set_cpu_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_CpuId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class CpuFrequencyLimitsFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + CpuFrequencyLimitsFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit CpuFrequencyLimitsFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit CpuFrequencyLimitsFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_min_freq() const { return at<1>().valid(); } + uint32_t min_freq() const { return at<1>().as_uint32(); } + bool has_max_freq() const { return at<2>().valid(); } + uint32_t max_freq() const { return at<2>().as_uint32(); } + bool has_cpu_id() const { return at<3>().valid(); } + uint32_t cpu_id() const { return at<3>().as_uint32(); } +}; + +class CpuFrequencyLimitsFtraceEvent : public ::protozero::Message { + public: + using Decoder = CpuFrequencyLimitsFtraceEvent_Decoder; + enum : int32_t { + kMinFreqFieldNumber = 1, + kMaxFreqFieldNumber = 2, + kCpuIdFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.CpuFrequencyLimitsFtraceEvent"; } + + + using FieldMetadata_MinFreq = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + CpuFrequencyLimitsFtraceEvent>; + + static constexpr FieldMetadata_MinFreq kMinFreq{}; + void set_min_freq(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_MinFreq::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_MaxFreq = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + CpuFrequencyLimitsFtraceEvent>; + + static constexpr FieldMetadata_MaxFreq kMaxFreq{}; + void set_max_freq(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_MaxFreq::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CpuId = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + CpuFrequencyLimitsFtraceEvent>; + + static constexpr FieldMetadata_CpuId kCpuId{}; + void set_cpu_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_CpuId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class CpuFrequencyFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + CpuFrequencyFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit CpuFrequencyFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit CpuFrequencyFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_state() const { return at<1>().valid(); } + uint32_t state() const { return at<1>().as_uint32(); } + bool has_cpu_id() const { return at<2>().valid(); } + uint32_t cpu_id() const { return at<2>().as_uint32(); } +}; + +class CpuFrequencyFtraceEvent : public ::protozero::Message { + public: + using Decoder = CpuFrequencyFtraceEvent_Decoder; + enum : int32_t { + kStateFieldNumber = 1, + kCpuIdFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.CpuFrequencyFtraceEvent"; } + + + using FieldMetadata_State = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + CpuFrequencyFtraceEvent>; + + static constexpr FieldMetadata_State kState{}; + void set_state(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_State::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CpuId = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + CpuFrequencyFtraceEvent>; + + static constexpr FieldMetadata_CpuId kCpuId{}; + void set_cpu_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_CpuId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class SchedSwitchWithCtrsFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + SchedSwitchWithCtrsFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit SchedSwitchWithCtrsFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit SchedSwitchWithCtrsFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_old_pid() const { return at<1>().valid(); } + int32_t old_pid() const { return at<1>().as_int32(); } + bool has_new_pid() const { return at<2>().valid(); } + int32_t new_pid() const { return at<2>().as_int32(); } + bool has_cctr() const { return at<3>().valid(); } + uint32_t cctr() const { return at<3>().as_uint32(); } + bool has_ctr0() const { return at<4>().valid(); } + uint32_t ctr0() const { return at<4>().as_uint32(); } + bool has_ctr1() const { return at<5>().valid(); } + uint32_t ctr1() const { return at<5>().as_uint32(); } + bool has_ctr2() const { return at<6>().valid(); } + uint32_t ctr2() const { return at<6>().as_uint32(); } + bool has_ctr3() const { return at<7>().valid(); } + uint32_t ctr3() const { return at<7>().as_uint32(); } + bool has_lctr0() const { return at<8>().valid(); } + uint32_t lctr0() const { return at<8>().as_uint32(); } + bool has_lctr1() const { return at<9>().valid(); } + uint32_t lctr1() const { return at<9>().as_uint32(); } + bool has_ctr4() const { return at<10>().valid(); } + uint32_t ctr4() const { return at<10>().as_uint32(); } + bool has_ctr5() const { return at<11>().valid(); } + uint32_t ctr5() const { return at<11>().as_uint32(); } + bool has_prev_comm() const { return at<12>().valid(); } + ::protozero::ConstChars prev_comm() const { return at<12>().as_string(); } + bool has_prev_pid() const { return at<13>().valid(); } + int32_t prev_pid() const { return at<13>().as_int32(); } + bool has_cyc() const { return at<14>().valid(); } + uint32_t cyc() const { return at<14>().as_uint32(); } + bool has_inst() const { return at<15>().valid(); } + uint32_t inst() const { return at<15>().as_uint32(); } + bool has_stallbm() const { return at<16>().valid(); } + uint32_t stallbm() const { return at<16>().as_uint32(); } + bool has_l3dm() const { return at<17>().valid(); } + uint32_t l3dm() const { return at<17>().as_uint32(); } +}; + +class SchedSwitchWithCtrsFtraceEvent : public ::protozero::Message { + public: + using Decoder = SchedSwitchWithCtrsFtraceEvent_Decoder; + enum : int32_t { + kOldPidFieldNumber = 1, + kNewPidFieldNumber = 2, + kCctrFieldNumber = 3, + kCtr0FieldNumber = 4, + kCtr1FieldNumber = 5, + kCtr2FieldNumber = 6, + kCtr3FieldNumber = 7, + kLctr0FieldNumber = 8, + kLctr1FieldNumber = 9, + kCtr4FieldNumber = 10, + kCtr5FieldNumber = 11, + kPrevCommFieldNumber = 12, + kPrevPidFieldNumber = 13, + kCycFieldNumber = 14, + kInstFieldNumber = 15, + kStallbmFieldNumber = 16, + kL3dmFieldNumber = 17, + }; + static constexpr const char* GetName() { return ".perfetto.protos.SchedSwitchWithCtrsFtraceEvent"; } + + + using FieldMetadata_OldPid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + SchedSwitchWithCtrsFtraceEvent>; + + static constexpr FieldMetadata_OldPid kOldPid{}; + void set_old_pid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_OldPid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NewPid = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + SchedSwitchWithCtrsFtraceEvent>; + + static constexpr FieldMetadata_NewPid kNewPid{}; + void set_new_pid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_NewPid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Cctr = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SchedSwitchWithCtrsFtraceEvent>; + + static constexpr FieldMetadata_Cctr kCctr{}; + void set_cctr(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Cctr::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ctr0 = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SchedSwitchWithCtrsFtraceEvent>; + + static constexpr FieldMetadata_Ctr0 kCtr0{}; + void set_ctr0(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ctr0::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ctr1 = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SchedSwitchWithCtrsFtraceEvent>; + + static constexpr FieldMetadata_Ctr1 kCtr1{}; + void set_ctr1(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ctr1::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ctr2 = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SchedSwitchWithCtrsFtraceEvent>; + + static constexpr FieldMetadata_Ctr2 kCtr2{}; + void set_ctr2(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ctr2::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ctr3 = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SchedSwitchWithCtrsFtraceEvent>; + + static constexpr FieldMetadata_Ctr3 kCtr3{}; + void set_ctr3(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ctr3::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Lctr0 = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SchedSwitchWithCtrsFtraceEvent>; + + static constexpr FieldMetadata_Lctr0 kLctr0{}; + void set_lctr0(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Lctr0::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Lctr1 = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SchedSwitchWithCtrsFtraceEvent>; + + static constexpr FieldMetadata_Lctr1 kLctr1{}; + void set_lctr1(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Lctr1::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ctr4 = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SchedSwitchWithCtrsFtraceEvent>; + + static constexpr FieldMetadata_Ctr4 kCtr4{}; + void set_ctr4(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ctr4::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ctr5 = + ::protozero::proto_utils::FieldMetadata< + 11, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SchedSwitchWithCtrsFtraceEvent>; + + static constexpr FieldMetadata_Ctr5 kCtr5{}; + void set_ctr5(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ctr5::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PrevComm = + ::protozero::proto_utils::FieldMetadata< + 12, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + SchedSwitchWithCtrsFtraceEvent>; + + static constexpr FieldMetadata_PrevComm kPrevComm{}; + void set_prev_comm(const char* data, size_t size) { + AppendBytes(FieldMetadata_PrevComm::kFieldId, data, size); + } + void set_prev_comm(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_PrevComm::kFieldId, chars.data, chars.size); + } + void set_prev_comm(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_PrevComm::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PrevPid = + ::protozero::proto_utils::FieldMetadata< + 13, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + SchedSwitchWithCtrsFtraceEvent>; + + static constexpr FieldMetadata_PrevPid kPrevPid{}; + void set_prev_pid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_PrevPid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Cyc = + ::protozero::proto_utils::FieldMetadata< + 14, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SchedSwitchWithCtrsFtraceEvent>; + + static constexpr FieldMetadata_Cyc kCyc{}; + void set_cyc(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Cyc::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Inst = + ::protozero::proto_utils::FieldMetadata< + 15, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SchedSwitchWithCtrsFtraceEvent>; + + static constexpr FieldMetadata_Inst kInst{}; + void set_inst(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Inst::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Stallbm = + ::protozero::proto_utils::FieldMetadata< + 16, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SchedSwitchWithCtrsFtraceEvent>; + + static constexpr FieldMetadata_Stallbm kStallbm{}; + void set_stallbm(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Stallbm::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_L3dm = + ::protozero::proto_utils::FieldMetadata< + 17, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SchedSwitchWithCtrsFtraceEvent>; + + static constexpr FieldMetadata_L3dm kL3dm{}; + void set_l3dm(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_L3dm::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class PanelWriteGenericFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + PanelWriteGenericFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit PanelWriteGenericFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit PanelWriteGenericFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_pid() const { return at<1>().valid(); } + int32_t pid() const { return at<1>().as_int32(); } + bool has_trace_name() const { return at<2>().valid(); } + ::protozero::ConstChars trace_name() const { return at<2>().as_string(); } + bool has_trace_begin() const { return at<3>().valid(); } + uint32_t trace_begin() const { return at<3>().as_uint32(); } + bool has_name() const { return at<4>().valid(); } + ::protozero::ConstChars name() const { return at<4>().as_string(); } + bool has_type() const { return at<5>().valid(); } + uint32_t type() const { return at<5>().as_uint32(); } + bool has_value() const { return at<6>().valid(); } + int32_t value() const { return at<6>().as_int32(); } +}; + +class PanelWriteGenericFtraceEvent : public ::protozero::Message { + public: + using Decoder = PanelWriteGenericFtraceEvent_Decoder; + enum : int32_t { + kPidFieldNumber = 1, + kTraceNameFieldNumber = 2, + kTraceBeginFieldNumber = 3, + kNameFieldNumber = 4, + kTypeFieldNumber = 5, + kValueFieldNumber = 6, + }; + static constexpr const char* GetName() { return ".perfetto.protos.PanelWriteGenericFtraceEvent"; } + + + using FieldMetadata_Pid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + PanelWriteGenericFtraceEvent>; + + static constexpr FieldMetadata_Pid kPid{}; + void set_pid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TraceName = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + PanelWriteGenericFtraceEvent>; + + static constexpr FieldMetadata_TraceName kTraceName{}; + void set_trace_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_TraceName::kFieldId, data, size); + } + void set_trace_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_TraceName::kFieldId, chars.data, chars.size); + } + void set_trace_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_TraceName::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TraceBegin = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + PanelWriteGenericFtraceEvent>; + + static constexpr FieldMetadata_TraceBegin kTraceBegin{}; + void set_trace_begin(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TraceBegin::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + PanelWriteGenericFtraceEvent>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Type = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + PanelWriteGenericFtraceEvent>; + + static constexpr FieldMetadata_Type kType{}; + void set_type(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Value = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + PanelWriteGenericFtraceEvent>; + + static constexpr FieldMetadata_Value kValue{}; + void set_value(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class DsiTxFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + DsiTxFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit DsiTxFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit DsiTxFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_last() const { return at<1>().valid(); } + uint32_t last() const { return at<1>().as_uint32(); } + bool has_tx_buf() const { return at<2>().valid(); } + uint32_t tx_buf() const { return at<2>().as_uint32(); } + bool has_type() const { return at<3>().valid(); } + uint32_t type() const { return at<3>().as_uint32(); } +}; + +class DsiTxFtraceEvent : public ::protozero::Message { + public: + using Decoder = DsiTxFtraceEvent_Decoder; + enum : int32_t { + kLastFieldNumber = 1, + kTxBufFieldNumber = 2, + kTypeFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.DsiTxFtraceEvent"; } + + + using FieldMetadata_Last = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + DsiTxFtraceEvent>; + + static constexpr FieldMetadata_Last kLast{}; + void set_last(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Last::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TxBuf = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + DsiTxFtraceEvent>; + + static constexpr FieldMetadata_TxBuf kTxBuf{}; + void set_tx_buf(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TxBuf::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Type = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + DsiTxFtraceEvent>; + + static constexpr FieldMetadata_Type kType{}; + void set_type(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class DsiRxFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + DsiRxFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit DsiRxFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit DsiRxFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_cmd() const { return at<1>().valid(); } + uint32_t cmd() const { return at<1>().as_uint32(); } + bool has_rx_buf() const { return at<2>().valid(); } + uint32_t rx_buf() const { return at<2>().as_uint32(); } +}; + +class DsiRxFtraceEvent : public ::protozero::Message { + public: + using Decoder = DsiRxFtraceEvent_Decoder; + enum : int32_t { + kCmdFieldNumber = 1, + kRxBufFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.DsiRxFtraceEvent"; } + + + using FieldMetadata_Cmd = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + DsiRxFtraceEvent>; + + static constexpr FieldMetadata_Cmd kCmd{}; + void set_cmd(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Cmd::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_RxBuf = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + DsiRxFtraceEvent>; + + static constexpr FieldMetadata_RxBuf kRxBuf{}; + void set_rx_buf(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_RxBuf::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class DsiCmdFifoStatusFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + DsiCmdFifoStatusFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit DsiCmdFifoStatusFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit DsiCmdFifoStatusFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_header() const { return at<1>().valid(); } + uint32_t header() const { return at<1>().as_uint32(); } + bool has_payload() const { return at<2>().valid(); } + uint32_t payload() const { return at<2>().as_uint32(); } +}; + +class DsiCmdFifoStatusFtraceEvent : public ::protozero::Message { + public: + using Decoder = DsiCmdFifoStatusFtraceEvent_Decoder; + enum : int32_t { + kHeaderFieldNumber = 1, + kPayloadFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.DsiCmdFifoStatusFtraceEvent"; } + + + using FieldMetadata_Header = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + DsiCmdFifoStatusFtraceEvent>; + + static constexpr FieldMetadata_Header kHeader{}; + void set_header(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Header::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Payload = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + DsiCmdFifoStatusFtraceEvent>; + + static constexpr FieldMetadata_Payload kPayload{}; + void set_payload(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Payload::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class MarkVictimFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + MarkVictimFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MarkVictimFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MarkVictimFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_pid() const { return at<1>().valid(); } + int32_t pid() const { return at<1>().as_int32(); } +}; + +class MarkVictimFtraceEvent : public ::protozero::Message { + public: + using Decoder = MarkVictimFtraceEvent_Decoder; + enum : int32_t { + kPidFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MarkVictimFtraceEvent"; } + + + using FieldMetadata_Pid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MarkVictimFtraceEvent>; + + static constexpr FieldMetadata_Pid kPid{}; + void set_pid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class OomScoreAdjUpdateFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + OomScoreAdjUpdateFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit OomScoreAdjUpdateFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit OomScoreAdjUpdateFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_comm() const { return at<1>().valid(); } + ::protozero::ConstChars comm() const { return at<1>().as_string(); } + bool has_oom_score_adj() const { return at<2>().valid(); } + int32_t oom_score_adj() const { return at<2>().as_int32(); } + bool has_pid() const { return at<3>().valid(); } + int32_t pid() const { return at<3>().as_int32(); } +}; + +class OomScoreAdjUpdateFtraceEvent : public ::protozero::Message { + public: + using Decoder = OomScoreAdjUpdateFtraceEvent_Decoder; + enum : int32_t { + kCommFieldNumber = 1, + kOomScoreAdjFieldNumber = 2, + kPidFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.OomScoreAdjUpdateFtraceEvent"; } + + + using FieldMetadata_Comm = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + OomScoreAdjUpdateFtraceEvent>; + + static constexpr FieldMetadata_Comm kComm{}; + void set_comm(const char* data, size_t size) { + AppendBytes(FieldMetadata_Comm::kFieldId, data, size); + } + void set_comm(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Comm::kFieldId, chars.data, chars.size); + } + void set_comm(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Comm::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_OomScoreAdj = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + OomScoreAdjUpdateFtraceEvent>; + + static constexpr FieldMetadata_OomScoreAdj kOomScoreAdj{}; + void set_oom_score_adj(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_OomScoreAdj::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pid = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + OomScoreAdjUpdateFtraceEvent>; + + static constexpr FieldMetadata_Pid kPid{}; + void set_pid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class NapiGroReceiveExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + NapiGroReceiveExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit NapiGroReceiveExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit NapiGroReceiveExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_ret() const { return at<1>().valid(); } + int32_t ret() const { return at<1>().as_int32(); } +}; + +class NapiGroReceiveExitFtraceEvent : public ::protozero::Message { + public: + using Decoder = NapiGroReceiveExitFtraceEvent_Decoder; + enum : int32_t { + kRetFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.NapiGroReceiveExitFtraceEvent"; } + + + using FieldMetadata_Ret = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + NapiGroReceiveExitFtraceEvent>; + + static constexpr FieldMetadata_Ret kRet{}; + void set_ret(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class NapiGroReceiveEntryFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + NapiGroReceiveEntryFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit NapiGroReceiveEntryFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit NapiGroReceiveEntryFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_data_len() const { return at<1>().valid(); } + uint32_t data_len() const { return at<1>().as_uint32(); } + bool has_gso_size() const { return at<2>().valid(); } + uint32_t gso_size() const { return at<2>().as_uint32(); } + bool has_gso_type() const { return at<3>().valid(); } + uint32_t gso_type() const { return at<3>().as_uint32(); } + bool has_hash() const { return at<4>().valid(); } + uint32_t hash() const { return at<4>().as_uint32(); } + bool has_ip_summed() const { return at<5>().valid(); } + uint32_t ip_summed() const { return at<5>().as_uint32(); } + bool has_l4_hash() const { return at<6>().valid(); } + uint32_t l4_hash() const { return at<6>().as_uint32(); } + bool has_len() const { return at<7>().valid(); } + uint32_t len() const { return at<7>().as_uint32(); } + bool has_mac_header() const { return at<8>().valid(); } + int32_t mac_header() const { return at<8>().as_int32(); } + bool has_mac_header_valid() const { return at<9>().valid(); } + uint32_t mac_header_valid() const { return at<9>().as_uint32(); } + bool has_name() const { return at<10>().valid(); } + ::protozero::ConstChars name() const { return at<10>().as_string(); } + bool has_napi_id() const { return at<11>().valid(); } + uint32_t napi_id() const { return at<11>().as_uint32(); } + bool has_nr_frags() const { return at<12>().valid(); } + uint32_t nr_frags() const { return at<12>().as_uint32(); } + bool has_protocol() const { return at<13>().valid(); } + uint32_t protocol() const { return at<13>().as_uint32(); } + bool has_queue_mapping() const { return at<14>().valid(); } + uint32_t queue_mapping() const { return at<14>().as_uint32(); } + bool has_skbaddr() const { return at<15>().valid(); } + uint64_t skbaddr() const { return at<15>().as_uint64(); } + bool has_truesize() const { return at<16>().valid(); } + uint32_t truesize() const { return at<16>().as_uint32(); } + bool has_vlan_proto() const { return at<17>().valid(); } + uint32_t vlan_proto() const { return at<17>().as_uint32(); } + bool has_vlan_tagged() const { return at<18>().valid(); } + uint32_t vlan_tagged() const { return at<18>().as_uint32(); } + bool has_vlan_tci() const { return at<19>().valid(); } + uint32_t vlan_tci() const { return at<19>().as_uint32(); } +}; + +class NapiGroReceiveEntryFtraceEvent : public ::protozero::Message { + public: + using Decoder = NapiGroReceiveEntryFtraceEvent_Decoder; + enum : int32_t { + kDataLenFieldNumber = 1, + kGsoSizeFieldNumber = 2, + kGsoTypeFieldNumber = 3, + kHashFieldNumber = 4, + kIpSummedFieldNumber = 5, + kL4HashFieldNumber = 6, + kLenFieldNumber = 7, + kMacHeaderFieldNumber = 8, + kMacHeaderValidFieldNumber = 9, + kNameFieldNumber = 10, + kNapiIdFieldNumber = 11, + kNrFragsFieldNumber = 12, + kProtocolFieldNumber = 13, + kQueueMappingFieldNumber = 14, + kSkbaddrFieldNumber = 15, + kTruesizeFieldNumber = 16, + kVlanProtoFieldNumber = 17, + kVlanTaggedFieldNumber = 18, + kVlanTciFieldNumber = 19, + }; + static constexpr const char* GetName() { return ".perfetto.protos.NapiGroReceiveEntryFtraceEvent"; } + + + using FieldMetadata_DataLen = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + NapiGroReceiveEntryFtraceEvent>; + + static constexpr FieldMetadata_DataLen kDataLen{}; + void set_data_len(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_DataLen::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_GsoSize = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + NapiGroReceiveEntryFtraceEvent>; + + static constexpr FieldMetadata_GsoSize kGsoSize{}; + void set_gso_size(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_GsoSize::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_GsoType = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + NapiGroReceiveEntryFtraceEvent>; + + static constexpr FieldMetadata_GsoType kGsoType{}; + void set_gso_type(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_GsoType::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Hash = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + NapiGroReceiveEntryFtraceEvent>; + + static constexpr FieldMetadata_Hash kHash{}; + void set_hash(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Hash::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_IpSummed = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + NapiGroReceiveEntryFtraceEvent>; + + static constexpr FieldMetadata_IpSummed kIpSummed{}; + void set_ip_summed(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_IpSummed::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_L4Hash = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + NapiGroReceiveEntryFtraceEvent>; + + static constexpr FieldMetadata_L4Hash kL4Hash{}; + void set_l4_hash(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_L4Hash::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Len = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + NapiGroReceiveEntryFtraceEvent>; + + static constexpr FieldMetadata_Len kLen{}; + void set_len(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_MacHeader = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + NapiGroReceiveEntryFtraceEvent>; + + static constexpr FieldMetadata_MacHeader kMacHeader{}; + void set_mac_header(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_MacHeader::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_MacHeaderValid = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + NapiGroReceiveEntryFtraceEvent>; + + static constexpr FieldMetadata_MacHeaderValid kMacHeaderValid{}; + void set_mac_header_valid(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_MacHeaderValid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + NapiGroReceiveEntryFtraceEvent>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NapiId = + ::protozero::proto_utils::FieldMetadata< + 11, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + NapiGroReceiveEntryFtraceEvent>; + + static constexpr FieldMetadata_NapiId kNapiId{}; + void set_napi_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_NapiId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NrFrags = + ::protozero::proto_utils::FieldMetadata< + 12, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + NapiGroReceiveEntryFtraceEvent>; + + static constexpr FieldMetadata_NrFrags kNrFrags{}; + void set_nr_frags(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_NrFrags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Protocol = + ::protozero::proto_utils::FieldMetadata< + 13, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + NapiGroReceiveEntryFtraceEvent>; + + static constexpr FieldMetadata_Protocol kProtocol{}; + void set_protocol(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Protocol::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_QueueMapping = + ::protozero::proto_utils::FieldMetadata< + 14, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + NapiGroReceiveEntryFtraceEvent>; + + static constexpr FieldMetadata_QueueMapping kQueueMapping{}; + void set_queue_mapping(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_QueueMapping::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Skbaddr = + ::protozero::proto_utils::FieldMetadata< + 15, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + NapiGroReceiveEntryFtraceEvent>; + + static constexpr FieldMetadata_Skbaddr kSkbaddr{}; + void set_skbaddr(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Skbaddr::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Truesize = + ::protozero::proto_utils::FieldMetadata< + 16, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + NapiGroReceiveEntryFtraceEvent>; + + static constexpr FieldMetadata_Truesize kTruesize{}; + void set_truesize(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Truesize::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_VlanProto = + ::protozero::proto_utils::FieldMetadata< + 17, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + NapiGroReceiveEntryFtraceEvent>; + + static constexpr FieldMetadata_VlanProto kVlanProto{}; + void set_vlan_proto(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_VlanProto::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_VlanTagged = + ::protozero::proto_utils::FieldMetadata< + 18, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + NapiGroReceiveEntryFtraceEvent>; + + static constexpr FieldMetadata_VlanTagged kVlanTagged{}; + void set_vlan_tagged(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_VlanTagged::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_VlanTci = + ::protozero::proto_utils::FieldMetadata< + 19, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + NapiGroReceiveEntryFtraceEvent>; + + static constexpr FieldMetadata_VlanTci kVlanTci{}; + void set_vlan_tci(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_VlanTci::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class NetDevXmitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + NetDevXmitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit NetDevXmitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit NetDevXmitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_len() const { return at<1>().valid(); } + uint32_t len() const { return at<1>().as_uint32(); } + bool has_name() const { return at<2>().valid(); } + ::protozero::ConstChars name() const { return at<2>().as_string(); } + bool has_rc() const { return at<3>().valid(); } + int32_t rc() const { return at<3>().as_int32(); } + bool has_skbaddr() const { return at<4>().valid(); } + uint64_t skbaddr() const { return at<4>().as_uint64(); } +}; + +class NetDevXmitFtraceEvent : public ::protozero::Message { + public: + using Decoder = NetDevXmitFtraceEvent_Decoder; + enum : int32_t { + kLenFieldNumber = 1, + kNameFieldNumber = 2, + kRcFieldNumber = 3, + kSkbaddrFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.NetDevXmitFtraceEvent"; } + + + using FieldMetadata_Len = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + NetDevXmitFtraceEvent>; + + static constexpr FieldMetadata_Len kLen{}; + void set_len(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + NetDevXmitFtraceEvent>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Rc = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + NetDevXmitFtraceEvent>; + + static constexpr FieldMetadata_Rc kRc{}; + void set_rc(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Rc::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Skbaddr = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + NetDevXmitFtraceEvent>; + + static constexpr FieldMetadata_Skbaddr kSkbaddr{}; + void set_skbaddr(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Skbaddr::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class NetifReceiveSkbFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + NetifReceiveSkbFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit NetifReceiveSkbFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit NetifReceiveSkbFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_len() const { return at<1>().valid(); } + uint32_t len() const { return at<1>().as_uint32(); } + bool has_name() const { return at<2>().valid(); } + ::protozero::ConstChars name() const { return at<2>().as_string(); } + bool has_skbaddr() const { return at<3>().valid(); } + uint64_t skbaddr() const { return at<3>().as_uint64(); } +}; + +class NetifReceiveSkbFtraceEvent : public ::protozero::Message { + public: + using Decoder = NetifReceiveSkbFtraceEvent_Decoder; + enum : int32_t { + kLenFieldNumber = 1, + kNameFieldNumber = 2, + kSkbaddrFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.NetifReceiveSkbFtraceEvent"; } + + + using FieldMetadata_Len = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + NetifReceiveSkbFtraceEvent>; + + static constexpr FieldMetadata_Len kLen{}; + void set_len(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + NetifReceiveSkbFtraceEvent>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Skbaddr = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + NetifReceiveSkbFtraceEvent>; + + static constexpr FieldMetadata_Skbaddr kSkbaddr{}; + void set_skbaddr(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Skbaddr::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class MmEventRecordFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + MmEventRecordFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MmEventRecordFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MmEventRecordFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_avg_lat() const { return at<1>().valid(); } + uint32_t avg_lat() const { return at<1>().as_uint32(); } + bool has_count() const { return at<2>().valid(); } + uint32_t count() const { return at<2>().as_uint32(); } + bool has_max_lat() const { return at<3>().valid(); } + uint32_t max_lat() const { return at<3>().as_uint32(); } + bool has_type() const { return at<4>().valid(); } + uint32_t type() const { return at<4>().as_uint32(); } +}; + +class MmEventRecordFtraceEvent : public ::protozero::Message { + public: + using Decoder = MmEventRecordFtraceEvent_Decoder; + enum : int32_t { + kAvgLatFieldNumber = 1, + kCountFieldNumber = 2, + kMaxLatFieldNumber = 3, + kTypeFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MmEventRecordFtraceEvent"; } + + + using FieldMetadata_AvgLat = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MmEventRecordFtraceEvent>; + + static constexpr FieldMetadata_AvgLat kAvgLat{}; + void set_avg_lat(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_AvgLat::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Count = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MmEventRecordFtraceEvent>; + + static constexpr FieldMetadata_Count kCount{}; + void set_count(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Count::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_MaxLat = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MmEventRecordFtraceEvent>; + + static constexpr FieldMetadata_MaxLat kMaxLat{}; + void set_max_lat(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_MaxLat::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Type = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MmEventRecordFtraceEvent>; + + static constexpr FieldMetadata_Type kType{}; + void set_type(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class RotatorBwAoAsContextFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + RotatorBwAoAsContextFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit RotatorBwAoAsContextFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit RotatorBwAoAsContextFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_state() const { return at<1>().valid(); } + uint32_t state() const { return at<1>().as_uint32(); } +}; + +class RotatorBwAoAsContextFtraceEvent : public ::protozero::Message { + public: + using Decoder = RotatorBwAoAsContextFtraceEvent_Decoder; + enum : int32_t { + kStateFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.RotatorBwAoAsContextFtraceEvent"; } + + + using FieldMetadata_State = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + RotatorBwAoAsContextFtraceEvent>; + + static constexpr FieldMetadata_State kState{}; + void set_state(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_State::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class MdpPerfUpdateBusFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + MdpPerfUpdateBusFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MdpPerfUpdateBusFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MdpPerfUpdateBusFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_client() const { return at<1>().valid(); } + int32_t client() const { return at<1>().as_int32(); } + bool has_ab_quota() const { return at<2>().valid(); } + uint64_t ab_quota() const { return at<2>().as_uint64(); } + bool has_ib_quota() const { return at<3>().valid(); } + uint64_t ib_quota() const { return at<3>().as_uint64(); } +}; + +class MdpPerfUpdateBusFtraceEvent : public ::protozero::Message { + public: + using Decoder = MdpPerfUpdateBusFtraceEvent_Decoder; + enum : int32_t { + kClientFieldNumber = 1, + kAbQuotaFieldNumber = 2, + kIbQuotaFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MdpPerfUpdateBusFtraceEvent"; } + + + using FieldMetadata_Client = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MdpPerfUpdateBusFtraceEvent>; + + static constexpr FieldMetadata_Client kClient{}; + void set_client(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Client::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_AbQuota = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MdpPerfUpdateBusFtraceEvent>; + + static constexpr FieldMetadata_AbQuota kAbQuota{}; + void set_ab_quota(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_AbQuota::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_IbQuota = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MdpPerfUpdateBusFtraceEvent>; + + static constexpr FieldMetadata_IbQuota kIbQuota{}; + void set_ib_quota(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_IbQuota::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class MdpPerfPrefillCalcFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + MdpPerfPrefillCalcFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MdpPerfPrefillCalcFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MdpPerfPrefillCalcFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_pnum() const { return at<1>().valid(); } + uint32_t pnum() const { return at<1>().as_uint32(); } + bool has_latency_buf() const { return at<2>().valid(); } + uint32_t latency_buf() const { return at<2>().as_uint32(); } + bool has_ot() const { return at<3>().valid(); } + uint32_t ot() const { return at<3>().as_uint32(); } + bool has_y_buf() const { return at<4>().valid(); } + uint32_t y_buf() const { return at<4>().as_uint32(); } + bool has_y_scaler() const { return at<5>().valid(); } + uint32_t y_scaler() const { return at<5>().as_uint32(); } + bool has_pp_lines() const { return at<6>().valid(); } + uint32_t pp_lines() const { return at<6>().as_uint32(); } + bool has_pp_bytes() const { return at<7>().valid(); } + uint32_t pp_bytes() const { return at<7>().as_uint32(); } + bool has_post_sc() const { return at<8>().valid(); } + uint32_t post_sc() const { return at<8>().as_uint32(); } + bool has_fbc_bytes() const { return at<9>().valid(); } + uint32_t fbc_bytes() const { return at<9>().as_uint32(); } + bool has_prefill_bytes() const { return at<10>().valid(); } + uint32_t prefill_bytes() const { return at<10>().as_uint32(); } +}; + +class MdpPerfPrefillCalcFtraceEvent : public ::protozero::Message { + public: + using Decoder = MdpPerfPrefillCalcFtraceEvent_Decoder; + enum : int32_t { + kPnumFieldNumber = 1, + kLatencyBufFieldNumber = 2, + kOtFieldNumber = 3, + kYBufFieldNumber = 4, + kYScalerFieldNumber = 5, + kPpLinesFieldNumber = 6, + kPpBytesFieldNumber = 7, + kPostScFieldNumber = 8, + kFbcBytesFieldNumber = 9, + kPrefillBytesFieldNumber = 10, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MdpPerfPrefillCalcFtraceEvent"; } + + + using FieldMetadata_Pnum = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MdpPerfPrefillCalcFtraceEvent>; + + static constexpr FieldMetadata_Pnum kPnum{}; + void set_pnum(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pnum::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_LatencyBuf = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MdpPerfPrefillCalcFtraceEvent>; + + static constexpr FieldMetadata_LatencyBuf kLatencyBuf{}; + void set_latency_buf(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_LatencyBuf::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ot = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MdpPerfPrefillCalcFtraceEvent>; + + static constexpr FieldMetadata_Ot kOt{}; + void set_ot(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ot::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_YBuf = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MdpPerfPrefillCalcFtraceEvent>; + + static constexpr FieldMetadata_YBuf kYBuf{}; + void set_y_buf(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_YBuf::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_YScaler = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MdpPerfPrefillCalcFtraceEvent>; + + static constexpr FieldMetadata_YScaler kYScaler{}; + void set_y_scaler(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_YScaler::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PpLines = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MdpPerfPrefillCalcFtraceEvent>; + + static constexpr FieldMetadata_PpLines kPpLines{}; + void set_pp_lines(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_PpLines::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PpBytes = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MdpPerfPrefillCalcFtraceEvent>; + + static constexpr FieldMetadata_PpBytes kPpBytes{}; + void set_pp_bytes(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_PpBytes::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PostSc = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MdpPerfPrefillCalcFtraceEvent>; + + static constexpr FieldMetadata_PostSc kPostSc{}; + void set_post_sc(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_PostSc::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FbcBytes = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MdpPerfPrefillCalcFtraceEvent>; + + static constexpr FieldMetadata_FbcBytes kFbcBytes{}; + void set_fbc_bytes(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_FbcBytes::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PrefillBytes = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MdpPerfPrefillCalcFtraceEvent>; + + static constexpr FieldMetadata_PrefillBytes kPrefillBytes{}; + void set_prefill_bytes(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_PrefillBytes::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class MdpCmdWaitPingpongFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + MdpCmdWaitPingpongFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MdpCmdWaitPingpongFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MdpCmdWaitPingpongFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_ctl_num() const { return at<1>().valid(); } + uint32_t ctl_num() const { return at<1>().as_uint32(); } + bool has_kickoff_cnt() const { return at<2>().valid(); } + int32_t kickoff_cnt() const { return at<2>().as_int32(); } +}; + +class MdpCmdWaitPingpongFtraceEvent : public ::protozero::Message { + public: + using Decoder = MdpCmdWaitPingpongFtraceEvent_Decoder; + enum : int32_t { + kCtlNumFieldNumber = 1, + kKickoffCntFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MdpCmdWaitPingpongFtraceEvent"; } + + + using FieldMetadata_CtlNum = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MdpCmdWaitPingpongFtraceEvent>; + + static constexpr FieldMetadata_CtlNum kCtlNum{}; + void set_ctl_num(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_CtlNum::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_KickoffCnt = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MdpCmdWaitPingpongFtraceEvent>; + + static constexpr FieldMetadata_KickoffCnt kKickoffCnt{}; + void set_kickoff_cnt(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_KickoffCnt::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class MdpVideoUnderrunDoneFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + MdpVideoUnderrunDoneFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MdpVideoUnderrunDoneFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MdpVideoUnderrunDoneFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_ctl_num() const { return at<1>().valid(); } + uint32_t ctl_num() const { return at<1>().as_uint32(); } + bool has_underrun_cnt() const { return at<2>().valid(); } + uint32_t underrun_cnt() const { return at<2>().as_uint32(); } +}; + +class MdpVideoUnderrunDoneFtraceEvent : public ::protozero::Message { + public: + using Decoder = MdpVideoUnderrunDoneFtraceEvent_Decoder; + enum : int32_t { + kCtlNumFieldNumber = 1, + kUnderrunCntFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MdpVideoUnderrunDoneFtraceEvent"; } + + + using FieldMetadata_CtlNum = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MdpVideoUnderrunDoneFtraceEvent>; + + static constexpr FieldMetadata_CtlNum kCtlNum{}; + void set_ctl_num(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_CtlNum::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_UnderrunCnt = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MdpVideoUnderrunDoneFtraceEvent>; + + static constexpr FieldMetadata_UnderrunCnt kUnderrunCnt{}; + void set_underrun_cnt(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_UnderrunCnt::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class MdpPerfSetWmLevelsFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + MdpPerfSetWmLevelsFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MdpPerfSetWmLevelsFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MdpPerfSetWmLevelsFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_pnum() const { return at<1>().valid(); } + uint32_t pnum() const { return at<1>().as_uint32(); } + bool has_use_space() const { return at<2>().valid(); } + uint32_t use_space() const { return at<2>().as_uint32(); } + bool has_priority_bytes() const { return at<3>().valid(); } + uint32_t priority_bytes() const { return at<3>().as_uint32(); } + bool has_wm0() const { return at<4>().valid(); } + uint32_t wm0() const { return at<4>().as_uint32(); } + bool has_wm1() const { return at<5>().valid(); } + uint32_t wm1() const { return at<5>().as_uint32(); } + bool has_wm2() const { return at<6>().valid(); } + uint32_t wm2() const { return at<6>().as_uint32(); } + bool has_mb_cnt() const { return at<7>().valid(); } + uint32_t mb_cnt() const { return at<7>().as_uint32(); } + bool has_mb_size() const { return at<8>().valid(); } + uint32_t mb_size() const { return at<8>().as_uint32(); } +}; + +class MdpPerfSetWmLevelsFtraceEvent : public ::protozero::Message { + public: + using Decoder = MdpPerfSetWmLevelsFtraceEvent_Decoder; + enum : int32_t { + kPnumFieldNumber = 1, + kUseSpaceFieldNumber = 2, + kPriorityBytesFieldNumber = 3, + kWm0FieldNumber = 4, + kWm1FieldNumber = 5, + kWm2FieldNumber = 6, + kMbCntFieldNumber = 7, + kMbSizeFieldNumber = 8, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MdpPerfSetWmLevelsFtraceEvent"; } + + + using FieldMetadata_Pnum = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MdpPerfSetWmLevelsFtraceEvent>; + + static constexpr FieldMetadata_Pnum kPnum{}; + void set_pnum(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pnum::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_UseSpace = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MdpPerfSetWmLevelsFtraceEvent>; + + static constexpr FieldMetadata_UseSpace kUseSpace{}; + void set_use_space(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_UseSpace::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PriorityBytes = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MdpPerfSetWmLevelsFtraceEvent>; + + static constexpr FieldMetadata_PriorityBytes kPriorityBytes{}; + void set_priority_bytes(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_PriorityBytes::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Wm0 = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MdpPerfSetWmLevelsFtraceEvent>; + + static constexpr FieldMetadata_Wm0 kWm0{}; + void set_wm0(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Wm0::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Wm1 = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MdpPerfSetWmLevelsFtraceEvent>; + + static constexpr FieldMetadata_Wm1 kWm1{}; + void set_wm1(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Wm1::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Wm2 = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MdpPerfSetWmLevelsFtraceEvent>; + + static constexpr FieldMetadata_Wm2 kWm2{}; + void set_wm2(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Wm2::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_MbCnt = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MdpPerfSetWmLevelsFtraceEvent>; + + static constexpr FieldMetadata_MbCnt kMbCnt{}; + void set_mb_cnt(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_MbCnt::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_MbSize = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MdpPerfSetWmLevelsFtraceEvent>; + + static constexpr FieldMetadata_MbSize kMbSize{}; + void set_mb_size(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_MbSize::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class MdpMixerUpdateFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + MdpMixerUpdateFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MdpMixerUpdateFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MdpMixerUpdateFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_mixer_num() const { return at<1>().valid(); } + uint32_t mixer_num() const { return at<1>().as_uint32(); } +}; + +class MdpMixerUpdateFtraceEvent : public ::protozero::Message { + public: + using Decoder = MdpMixerUpdateFtraceEvent_Decoder; + enum : int32_t { + kMixerNumFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MdpMixerUpdateFtraceEvent"; } + + + using FieldMetadata_MixerNum = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MdpMixerUpdateFtraceEvent>; + + static constexpr FieldMetadata_MixerNum kMixerNum{}; + void set_mixer_num(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_MixerNum::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class MdpCmdReleaseBwFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + MdpCmdReleaseBwFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MdpCmdReleaseBwFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MdpCmdReleaseBwFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_ctl_num() const { return at<1>().valid(); } + uint32_t ctl_num() const { return at<1>().as_uint32(); } +}; + +class MdpCmdReleaseBwFtraceEvent : public ::protozero::Message { + public: + using Decoder = MdpCmdReleaseBwFtraceEvent_Decoder; + enum : int32_t { + kCtlNumFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MdpCmdReleaseBwFtraceEvent"; } + + + using FieldMetadata_CtlNum = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MdpCmdReleaseBwFtraceEvent>; + + static constexpr FieldMetadata_CtlNum kCtlNum{}; + void set_ctl_num(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_CtlNum::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class MdpTraceCounterFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + MdpTraceCounterFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MdpTraceCounterFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MdpTraceCounterFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_pid() const { return at<1>().valid(); } + int32_t pid() const { return at<1>().as_int32(); } + bool has_counter_name() const { return at<2>().valid(); } + ::protozero::ConstChars counter_name() const { return at<2>().as_string(); } + bool has_value() const { return at<3>().valid(); } + int32_t value() const { return at<3>().as_int32(); } +}; + +class MdpTraceCounterFtraceEvent : public ::protozero::Message { + public: + using Decoder = MdpTraceCounterFtraceEvent_Decoder; + enum : int32_t { + kPidFieldNumber = 1, + kCounterNameFieldNumber = 2, + kValueFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MdpTraceCounterFtraceEvent"; } + + + using FieldMetadata_Pid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MdpTraceCounterFtraceEvent>; + + static constexpr FieldMetadata_Pid kPid{}; + void set_pid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CounterName = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + MdpTraceCounterFtraceEvent>; + + static constexpr FieldMetadata_CounterName kCounterName{}; + void set_counter_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_CounterName::kFieldId, data, size); + } + void set_counter_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_CounterName::kFieldId, chars.data, chars.size); + } + void set_counter_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_CounterName::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Value = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MdpTraceCounterFtraceEvent>; + + static constexpr FieldMetadata_Value kValue{}; + void set_value(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class MdpPerfSetQosLutsFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + MdpPerfSetQosLutsFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MdpPerfSetQosLutsFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MdpPerfSetQosLutsFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_pnum() const { return at<1>().valid(); } + uint32_t pnum() const { return at<1>().as_uint32(); } + bool has_fmt() const { return at<2>().valid(); } + uint32_t fmt() const { return at<2>().as_uint32(); } + bool has_intf() const { return at<3>().valid(); } + uint32_t intf() const { return at<3>().as_uint32(); } + bool has_rot() const { return at<4>().valid(); } + uint32_t rot() const { return at<4>().as_uint32(); } + bool has_fl() const { return at<5>().valid(); } + uint32_t fl() const { return at<5>().as_uint32(); } + bool has_lut() const { return at<6>().valid(); } + uint32_t lut() const { return at<6>().as_uint32(); } + bool has_linear() const { return at<7>().valid(); } + uint32_t linear() const { return at<7>().as_uint32(); } +}; + +class MdpPerfSetQosLutsFtraceEvent : public ::protozero::Message { + public: + using Decoder = MdpPerfSetQosLutsFtraceEvent_Decoder; + enum : int32_t { + kPnumFieldNumber = 1, + kFmtFieldNumber = 2, + kIntfFieldNumber = 3, + kRotFieldNumber = 4, + kFlFieldNumber = 5, + kLutFieldNumber = 6, + kLinearFieldNumber = 7, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MdpPerfSetQosLutsFtraceEvent"; } + + + using FieldMetadata_Pnum = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MdpPerfSetQosLutsFtraceEvent>; + + static constexpr FieldMetadata_Pnum kPnum{}; + void set_pnum(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pnum::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Fmt = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MdpPerfSetQosLutsFtraceEvent>; + + static constexpr FieldMetadata_Fmt kFmt{}; + void set_fmt(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Fmt::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Intf = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MdpPerfSetQosLutsFtraceEvent>; + + static constexpr FieldMetadata_Intf kIntf{}; + void set_intf(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Intf::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Rot = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MdpPerfSetQosLutsFtraceEvent>; + + static constexpr FieldMetadata_Rot kRot{}; + void set_rot(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Rot::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Fl = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MdpPerfSetQosLutsFtraceEvent>; + + static constexpr FieldMetadata_Fl kFl{}; + void set_fl(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Fl::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Lut = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MdpPerfSetQosLutsFtraceEvent>; + + static constexpr FieldMetadata_Lut kLut{}; + void set_lut(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Lut::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Linear = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MdpPerfSetQosLutsFtraceEvent>; + + static constexpr FieldMetadata_Linear kLinear{}; + void set_linear(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Linear::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class MdpMisrCrcFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + MdpMisrCrcFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MdpMisrCrcFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MdpMisrCrcFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_block_id() const { return at<1>().valid(); } + uint32_t block_id() const { return at<1>().as_uint32(); } + bool has_vsync_cnt() const { return at<2>().valid(); } + uint32_t vsync_cnt() const { return at<2>().as_uint32(); } + bool has_crc() const { return at<3>().valid(); } + uint32_t crc() const { return at<3>().as_uint32(); } +}; + +class MdpMisrCrcFtraceEvent : public ::protozero::Message { + public: + using Decoder = MdpMisrCrcFtraceEvent_Decoder; + enum : int32_t { + kBlockIdFieldNumber = 1, + kVsyncCntFieldNumber = 2, + kCrcFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MdpMisrCrcFtraceEvent"; } + + + using FieldMetadata_BlockId = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MdpMisrCrcFtraceEvent>; + + static constexpr FieldMetadata_BlockId kBlockId{}; + void set_block_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_BlockId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_VsyncCnt = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MdpMisrCrcFtraceEvent>; + + static constexpr FieldMetadata_VsyncCnt kVsyncCnt{}; + void set_vsync_cnt(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_VsyncCnt::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Crc = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MdpMisrCrcFtraceEvent>; + + static constexpr FieldMetadata_Crc kCrc{}; + void set_crc(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Crc::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class MdpCmdReadptrDoneFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + MdpCmdReadptrDoneFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MdpCmdReadptrDoneFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MdpCmdReadptrDoneFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_ctl_num() const { return at<1>().valid(); } + uint32_t ctl_num() const { return at<1>().as_uint32(); } + bool has_koff_cnt() const { return at<2>().valid(); } + int32_t koff_cnt() const { return at<2>().as_int32(); } +}; + +class MdpCmdReadptrDoneFtraceEvent : public ::protozero::Message { + public: + using Decoder = MdpCmdReadptrDoneFtraceEvent_Decoder; + enum : int32_t { + kCtlNumFieldNumber = 1, + kKoffCntFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MdpCmdReadptrDoneFtraceEvent"; } + + + using FieldMetadata_CtlNum = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MdpCmdReadptrDoneFtraceEvent>; + + static constexpr FieldMetadata_CtlNum kCtlNum{}; + void set_ctl_num(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_CtlNum::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_KoffCnt = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MdpCmdReadptrDoneFtraceEvent>; + + static constexpr FieldMetadata_KoffCnt kKoffCnt{}; + void set_koff_cnt(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_KoffCnt::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class MdpSsppSetFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + MdpSsppSetFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MdpSsppSetFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MdpSsppSetFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_num() const { return at<1>().valid(); } + uint32_t num() const { return at<1>().as_uint32(); } + bool has_play_cnt() const { return at<2>().valid(); } + uint32_t play_cnt() const { return at<2>().as_uint32(); } + bool has_mixer() const { return at<3>().valid(); } + uint32_t mixer() const { return at<3>().as_uint32(); } + bool has_stage() const { return at<4>().valid(); } + uint32_t stage() const { return at<4>().as_uint32(); } + bool has_flags() const { return at<5>().valid(); } + uint32_t flags() const { return at<5>().as_uint32(); } + bool has_format() const { return at<6>().valid(); } + uint32_t format() const { return at<6>().as_uint32(); } + bool has_img_w() const { return at<7>().valid(); } + uint32_t img_w() const { return at<7>().as_uint32(); } + bool has_img_h() const { return at<8>().valid(); } + uint32_t img_h() const { return at<8>().as_uint32(); } + bool has_src_x() const { return at<9>().valid(); } + uint32_t src_x() const { return at<9>().as_uint32(); } + bool has_src_y() const { return at<10>().valid(); } + uint32_t src_y() const { return at<10>().as_uint32(); } + bool has_src_w() const { return at<11>().valid(); } + uint32_t src_w() const { return at<11>().as_uint32(); } + bool has_src_h() const { return at<12>().valid(); } + uint32_t src_h() const { return at<12>().as_uint32(); } + bool has_dst_x() const { return at<13>().valid(); } + uint32_t dst_x() const { return at<13>().as_uint32(); } + bool has_dst_y() const { return at<14>().valid(); } + uint32_t dst_y() const { return at<14>().as_uint32(); } + bool has_dst_w() const { return at<15>().valid(); } + uint32_t dst_w() const { return at<15>().as_uint32(); } + bool has_dst_h() const { return at<16>().valid(); } + uint32_t dst_h() const { return at<16>().as_uint32(); } +}; + +class MdpSsppSetFtraceEvent : public ::protozero::Message { + public: + using Decoder = MdpSsppSetFtraceEvent_Decoder; + enum : int32_t { + kNumFieldNumber = 1, + kPlayCntFieldNumber = 2, + kMixerFieldNumber = 3, + kStageFieldNumber = 4, + kFlagsFieldNumber = 5, + kFormatFieldNumber = 6, + kImgWFieldNumber = 7, + kImgHFieldNumber = 8, + kSrcXFieldNumber = 9, + kSrcYFieldNumber = 10, + kSrcWFieldNumber = 11, + kSrcHFieldNumber = 12, + kDstXFieldNumber = 13, + kDstYFieldNumber = 14, + kDstWFieldNumber = 15, + kDstHFieldNumber = 16, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MdpSsppSetFtraceEvent"; } + + + using FieldMetadata_Num = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MdpSsppSetFtraceEvent>; + + static constexpr FieldMetadata_Num kNum{}; + void set_num(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Num::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PlayCnt = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MdpSsppSetFtraceEvent>; + + static constexpr FieldMetadata_PlayCnt kPlayCnt{}; + void set_play_cnt(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_PlayCnt::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Mixer = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MdpSsppSetFtraceEvent>; + + static constexpr FieldMetadata_Mixer kMixer{}; + void set_mixer(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Mixer::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Stage = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MdpSsppSetFtraceEvent>; + + static constexpr FieldMetadata_Stage kStage{}; + void set_stage(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Stage::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Flags = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MdpSsppSetFtraceEvent>; + + static constexpr FieldMetadata_Flags kFlags{}; + void set_flags(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Format = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MdpSsppSetFtraceEvent>; + + static constexpr FieldMetadata_Format kFormat{}; + void set_format(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Format::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ImgW = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MdpSsppSetFtraceEvent>; + + static constexpr FieldMetadata_ImgW kImgW{}; + void set_img_w(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ImgW::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ImgH = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MdpSsppSetFtraceEvent>; + + static constexpr FieldMetadata_ImgH kImgH{}; + void set_img_h(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ImgH::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SrcX = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MdpSsppSetFtraceEvent>; + + static constexpr FieldMetadata_SrcX kSrcX{}; + void set_src_x(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_SrcX::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SrcY = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MdpSsppSetFtraceEvent>; + + static constexpr FieldMetadata_SrcY kSrcY{}; + void set_src_y(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_SrcY::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SrcW = + ::protozero::proto_utils::FieldMetadata< + 11, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MdpSsppSetFtraceEvent>; + + static constexpr FieldMetadata_SrcW kSrcW{}; + void set_src_w(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_SrcW::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SrcH = + ::protozero::proto_utils::FieldMetadata< + 12, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MdpSsppSetFtraceEvent>; + + static constexpr FieldMetadata_SrcH kSrcH{}; + void set_src_h(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_SrcH::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DstX = + ::protozero::proto_utils::FieldMetadata< + 13, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MdpSsppSetFtraceEvent>; + + static constexpr FieldMetadata_DstX kDstX{}; + void set_dst_x(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_DstX::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DstY = + ::protozero::proto_utils::FieldMetadata< + 14, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MdpSsppSetFtraceEvent>; + + static constexpr FieldMetadata_DstY kDstY{}; + void set_dst_y(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_DstY::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DstW = + ::protozero::proto_utils::FieldMetadata< + 15, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MdpSsppSetFtraceEvent>; + + static constexpr FieldMetadata_DstW kDstW{}; + void set_dst_w(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_DstW::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DstH = + ::protozero::proto_utils::FieldMetadata< + 16, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MdpSsppSetFtraceEvent>; + + static constexpr FieldMetadata_DstH kDstH{}; + void set_dst_h(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_DstH::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class MdpPerfSetPanicLutsFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + MdpPerfSetPanicLutsFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MdpPerfSetPanicLutsFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MdpPerfSetPanicLutsFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_pnum() const { return at<1>().valid(); } + uint32_t pnum() const { return at<1>().as_uint32(); } + bool has_fmt() const { return at<2>().valid(); } + uint32_t fmt() const { return at<2>().as_uint32(); } + bool has_mode() const { return at<3>().valid(); } + uint32_t mode() const { return at<3>().as_uint32(); } + bool has_panic_lut() const { return at<4>().valid(); } + uint32_t panic_lut() const { return at<4>().as_uint32(); } + bool has_robust_lut() const { return at<5>().valid(); } + uint32_t robust_lut() const { return at<5>().as_uint32(); } +}; + +class MdpPerfSetPanicLutsFtraceEvent : public ::protozero::Message { + public: + using Decoder = MdpPerfSetPanicLutsFtraceEvent_Decoder; + enum : int32_t { + kPnumFieldNumber = 1, + kFmtFieldNumber = 2, + kModeFieldNumber = 3, + kPanicLutFieldNumber = 4, + kRobustLutFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MdpPerfSetPanicLutsFtraceEvent"; } + + + using FieldMetadata_Pnum = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MdpPerfSetPanicLutsFtraceEvent>; + + static constexpr FieldMetadata_Pnum kPnum{}; + void set_pnum(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pnum::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Fmt = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MdpPerfSetPanicLutsFtraceEvent>; + + static constexpr FieldMetadata_Fmt kFmt{}; + void set_fmt(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Fmt::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Mode = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MdpPerfSetPanicLutsFtraceEvent>; + + static constexpr FieldMetadata_Mode kMode{}; + void set_mode(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Mode::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PanicLut = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MdpPerfSetPanicLutsFtraceEvent>; + + static constexpr FieldMetadata_PanicLut kPanicLut{}; + void set_panic_lut(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_PanicLut::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_RobustLut = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MdpPerfSetPanicLutsFtraceEvent>; + + static constexpr FieldMetadata_RobustLut kRobustLut{}; + void set_robust_lut(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_RobustLut::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class MdpCompareBwFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + MdpCompareBwFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MdpCompareBwFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MdpCompareBwFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_new_ab() const { return at<1>().valid(); } + uint64_t new_ab() const { return at<1>().as_uint64(); } + bool has_new_ib() const { return at<2>().valid(); } + uint64_t new_ib() const { return at<2>().as_uint64(); } + bool has_new_wb() const { return at<3>().valid(); } + uint64_t new_wb() const { return at<3>().as_uint64(); } + bool has_old_ab() const { return at<4>().valid(); } + uint64_t old_ab() const { return at<4>().as_uint64(); } + bool has_old_ib() const { return at<5>().valid(); } + uint64_t old_ib() const { return at<5>().as_uint64(); } + bool has_old_wb() const { return at<6>().valid(); } + uint64_t old_wb() const { return at<6>().as_uint64(); } + bool has_params_changed() const { return at<7>().valid(); } + uint32_t params_changed() const { return at<7>().as_uint32(); } + bool has_update_bw() const { return at<8>().valid(); } + uint32_t update_bw() const { return at<8>().as_uint32(); } +}; + +class MdpCompareBwFtraceEvent : public ::protozero::Message { + public: + using Decoder = MdpCompareBwFtraceEvent_Decoder; + enum : int32_t { + kNewAbFieldNumber = 1, + kNewIbFieldNumber = 2, + kNewWbFieldNumber = 3, + kOldAbFieldNumber = 4, + kOldIbFieldNumber = 5, + kOldWbFieldNumber = 6, + kParamsChangedFieldNumber = 7, + kUpdateBwFieldNumber = 8, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MdpCompareBwFtraceEvent"; } + + + using FieldMetadata_NewAb = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MdpCompareBwFtraceEvent>; + + static constexpr FieldMetadata_NewAb kNewAb{}; + void set_new_ab(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_NewAb::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NewIb = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MdpCompareBwFtraceEvent>; + + static constexpr FieldMetadata_NewIb kNewIb{}; + void set_new_ib(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_NewIb::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NewWb = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MdpCompareBwFtraceEvent>; + + static constexpr FieldMetadata_NewWb kNewWb{}; + void set_new_wb(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_NewWb::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_OldAb = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MdpCompareBwFtraceEvent>; + + static constexpr FieldMetadata_OldAb kOldAb{}; + void set_old_ab(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_OldAb::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_OldIb = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MdpCompareBwFtraceEvent>; + + static constexpr FieldMetadata_OldIb kOldIb{}; + void set_old_ib(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_OldIb::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_OldWb = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MdpCompareBwFtraceEvent>; + + static constexpr FieldMetadata_OldWb kOldWb{}; + void set_old_wb(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_OldWb::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ParamsChanged = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MdpCompareBwFtraceEvent>; + + static constexpr FieldMetadata_ParamsChanged kParamsChanged{}; + void set_params_changed(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ParamsChanged::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_UpdateBw = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MdpCompareBwFtraceEvent>; + + static constexpr FieldMetadata_UpdateBw kUpdateBw{}; + void set_update_bw(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_UpdateBw::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class MdpCmdPingpongDoneFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + MdpCmdPingpongDoneFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MdpCmdPingpongDoneFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MdpCmdPingpongDoneFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_ctl_num() const { return at<1>().valid(); } + uint32_t ctl_num() const { return at<1>().as_uint32(); } + bool has_intf_num() const { return at<2>().valid(); } + uint32_t intf_num() const { return at<2>().as_uint32(); } + bool has_pp_num() const { return at<3>().valid(); } + uint32_t pp_num() const { return at<3>().as_uint32(); } + bool has_koff_cnt() const { return at<4>().valid(); } + int32_t koff_cnt() const { return at<4>().as_int32(); } +}; + +class MdpCmdPingpongDoneFtraceEvent : public ::protozero::Message { + public: + using Decoder = MdpCmdPingpongDoneFtraceEvent_Decoder; + enum : int32_t { + kCtlNumFieldNumber = 1, + kIntfNumFieldNumber = 2, + kPpNumFieldNumber = 3, + kKoffCntFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MdpCmdPingpongDoneFtraceEvent"; } + + + using FieldMetadata_CtlNum = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MdpCmdPingpongDoneFtraceEvent>; + + static constexpr FieldMetadata_CtlNum kCtlNum{}; + void set_ctl_num(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_CtlNum::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_IntfNum = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MdpCmdPingpongDoneFtraceEvent>; + + static constexpr FieldMetadata_IntfNum kIntfNum{}; + void set_intf_num(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_IntfNum::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PpNum = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MdpCmdPingpongDoneFtraceEvent>; + + static constexpr FieldMetadata_PpNum kPpNum{}; + void set_pp_num(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_PpNum::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_KoffCnt = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MdpCmdPingpongDoneFtraceEvent>; + + static constexpr FieldMetadata_KoffCnt kKoffCnt{}; + void set_koff_cnt(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_KoffCnt::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class TracingMarkWriteFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + TracingMarkWriteFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TracingMarkWriteFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TracingMarkWriteFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_pid() const { return at<1>().valid(); } + int32_t pid() const { return at<1>().as_int32(); } + bool has_trace_name() const { return at<2>().valid(); } + ::protozero::ConstChars trace_name() const { return at<2>().as_string(); } + bool has_trace_begin() const { return at<3>().valid(); } + uint32_t trace_begin() const { return at<3>().as_uint32(); } +}; + +class TracingMarkWriteFtraceEvent : public ::protozero::Message { + public: + using Decoder = TracingMarkWriteFtraceEvent_Decoder; + enum : int32_t { + kPidFieldNumber = 1, + kTraceNameFieldNumber = 2, + kTraceBeginFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.TracingMarkWriteFtraceEvent"; } + + + using FieldMetadata_Pid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + TracingMarkWriteFtraceEvent>; + + static constexpr FieldMetadata_Pid kPid{}; + void set_pid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TraceName = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + TracingMarkWriteFtraceEvent>; + + static constexpr FieldMetadata_TraceName kTraceName{}; + void set_trace_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_TraceName::kFieldId, data, size); + } + void set_trace_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_TraceName::kFieldId, chars.data, chars.size); + } + void set_trace_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_TraceName::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TraceBegin = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + TracingMarkWriteFtraceEvent>; + + static constexpr FieldMetadata_TraceBegin kTraceBegin{}; + void set_trace_begin(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TraceBegin::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class MdpSsppChangeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + MdpSsppChangeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MdpSsppChangeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MdpSsppChangeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_num() const { return at<1>().valid(); } + uint32_t num() const { return at<1>().as_uint32(); } + bool has_play_cnt() const { return at<2>().valid(); } + uint32_t play_cnt() const { return at<2>().as_uint32(); } + bool has_mixer() const { return at<3>().valid(); } + uint32_t mixer() const { return at<3>().as_uint32(); } + bool has_stage() const { return at<4>().valid(); } + uint32_t stage() const { return at<4>().as_uint32(); } + bool has_flags() const { return at<5>().valid(); } + uint32_t flags() const { return at<5>().as_uint32(); } + bool has_format() const { return at<6>().valid(); } + uint32_t format() const { return at<6>().as_uint32(); } + bool has_img_w() const { return at<7>().valid(); } + uint32_t img_w() const { return at<7>().as_uint32(); } + bool has_img_h() const { return at<8>().valid(); } + uint32_t img_h() const { return at<8>().as_uint32(); } + bool has_src_x() const { return at<9>().valid(); } + uint32_t src_x() const { return at<9>().as_uint32(); } + bool has_src_y() const { return at<10>().valid(); } + uint32_t src_y() const { return at<10>().as_uint32(); } + bool has_src_w() const { return at<11>().valid(); } + uint32_t src_w() const { return at<11>().as_uint32(); } + bool has_src_h() const { return at<12>().valid(); } + uint32_t src_h() const { return at<12>().as_uint32(); } + bool has_dst_x() const { return at<13>().valid(); } + uint32_t dst_x() const { return at<13>().as_uint32(); } + bool has_dst_y() const { return at<14>().valid(); } + uint32_t dst_y() const { return at<14>().as_uint32(); } + bool has_dst_w() const { return at<15>().valid(); } + uint32_t dst_w() const { return at<15>().as_uint32(); } + bool has_dst_h() const { return at<16>().valid(); } + uint32_t dst_h() const { return at<16>().as_uint32(); } +}; + +class MdpSsppChangeFtraceEvent : public ::protozero::Message { + public: + using Decoder = MdpSsppChangeFtraceEvent_Decoder; + enum : int32_t { + kNumFieldNumber = 1, + kPlayCntFieldNumber = 2, + kMixerFieldNumber = 3, + kStageFieldNumber = 4, + kFlagsFieldNumber = 5, + kFormatFieldNumber = 6, + kImgWFieldNumber = 7, + kImgHFieldNumber = 8, + kSrcXFieldNumber = 9, + kSrcYFieldNumber = 10, + kSrcWFieldNumber = 11, + kSrcHFieldNumber = 12, + kDstXFieldNumber = 13, + kDstYFieldNumber = 14, + kDstWFieldNumber = 15, + kDstHFieldNumber = 16, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MdpSsppChangeFtraceEvent"; } + + + using FieldMetadata_Num = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MdpSsppChangeFtraceEvent>; + + static constexpr FieldMetadata_Num kNum{}; + void set_num(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Num::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PlayCnt = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MdpSsppChangeFtraceEvent>; + + static constexpr FieldMetadata_PlayCnt kPlayCnt{}; + void set_play_cnt(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_PlayCnt::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Mixer = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MdpSsppChangeFtraceEvent>; + + static constexpr FieldMetadata_Mixer kMixer{}; + void set_mixer(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Mixer::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Stage = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MdpSsppChangeFtraceEvent>; + + static constexpr FieldMetadata_Stage kStage{}; + void set_stage(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Stage::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Flags = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MdpSsppChangeFtraceEvent>; + + static constexpr FieldMetadata_Flags kFlags{}; + void set_flags(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Format = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MdpSsppChangeFtraceEvent>; + + static constexpr FieldMetadata_Format kFormat{}; + void set_format(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Format::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ImgW = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MdpSsppChangeFtraceEvent>; + + static constexpr FieldMetadata_ImgW kImgW{}; + void set_img_w(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ImgW::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ImgH = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MdpSsppChangeFtraceEvent>; + + static constexpr FieldMetadata_ImgH kImgH{}; + void set_img_h(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ImgH::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SrcX = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MdpSsppChangeFtraceEvent>; + + static constexpr FieldMetadata_SrcX kSrcX{}; + void set_src_x(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_SrcX::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SrcY = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MdpSsppChangeFtraceEvent>; + + static constexpr FieldMetadata_SrcY kSrcY{}; + void set_src_y(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_SrcY::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SrcW = + ::protozero::proto_utils::FieldMetadata< + 11, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MdpSsppChangeFtraceEvent>; + + static constexpr FieldMetadata_SrcW kSrcW{}; + void set_src_w(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_SrcW::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SrcH = + ::protozero::proto_utils::FieldMetadata< + 12, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MdpSsppChangeFtraceEvent>; + + static constexpr FieldMetadata_SrcH kSrcH{}; + void set_src_h(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_SrcH::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DstX = + ::protozero::proto_utils::FieldMetadata< + 13, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MdpSsppChangeFtraceEvent>; + + static constexpr FieldMetadata_DstX kDstX{}; + void set_dst_x(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_DstX::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DstY = + ::protozero::proto_utils::FieldMetadata< + 14, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MdpSsppChangeFtraceEvent>; + + static constexpr FieldMetadata_DstY kDstY{}; + void set_dst_y(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_DstY::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DstW = + ::protozero::proto_utils::FieldMetadata< + 15, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MdpSsppChangeFtraceEvent>; + + static constexpr FieldMetadata_DstW kDstW{}; + void set_dst_w(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_DstW::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DstH = + ::protozero::proto_utils::FieldMetadata< + 16, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MdpSsppChangeFtraceEvent>; + + static constexpr FieldMetadata_DstH kDstH{}; + void set_dst_h(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_DstH::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class MdpPerfSetOtFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + MdpPerfSetOtFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MdpPerfSetOtFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MdpPerfSetOtFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_pnum() const { return at<1>().valid(); } + uint32_t pnum() const { return at<1>().as_uint32(); } + bool has_xin_id() const { return at<2>().valid(); } + uint32_t xin_id() const { return at<2>().as_uint32(); } + bool has_rd_lim() const { return at<3>().valid(); } + uint32_t rd_lim() const { return at<3>().as_uint32(); } + bool has_is_vbif_rt() const { return at<4>().valid(); } + uint32_t is_vbif_rt() const { return at<4>().as_uint32(); } +}; + +class MdpPerfSetOtFtraceEvent : public ::protozero::Message { + public: + using Decoder = MdpPerfSetOtFtraceEvent_Decoder; + enum : int32_t { + kPnumFieldNumber = 1, + kXinIdFieldNumber = 2, + kRdLimFieldNumber = 3, + kIsVbifRtFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MdpPerfSetOtFtraceEvent"; } + + + using FieldMetadata_Pnum = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MdpPerfSetOtFtraceEvent>; + + static constexpr FieldMetadata_Pnum kPnum{}; + void set_pnum(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pnum::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_XinId = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MdpPerfSetOtFtraceEvent>; + + static constexpr FieldMetadata_XinId kXinId{}; + void set_xin_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_XinId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_RdLim = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MdpPerfSetOtFtraceEvent>; + + static constexpr FieldMetadata_RdLim kRdLim{}; + void set_rd_lim(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_RdLim::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_IsVbifRt = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MdpPerfSetOtFtraceEvent>; + + static constexpr FieldMetadata_IsVbifRt kIsVbifRt{}; + void set_is_vbif_rt(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_IsVbifRt::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class MdpCommitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + MdpCommitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MdpCommitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MdpCommitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_num() const { return at<1>().valid(); } + uint32_t num() const { return at<1>().as_uint32(); } + bool has_play_cnt() const { return at<2>().valid(); } + uint32_t play_cnt() const { return at<2>().as_uint32(); } + bool has_clk_rate() const { return at<3>().valid(); } + uint32_t clk_rate() const { return at<3>().as_uint32(); } + bool has_bandwidth() const { return at<4>().valid(); } + uint64_t bandwidth() const { return at<4>().as_uint64(); } +}; + +class MdpCommitFtraceEvent : public ::protozero::Message { + public: + using Decoder = MdpCommitFtraceEvent_Decoder; + enum : int32_t { + kNumFieldNumber = 1, + kPlayCntFieldNumber = 2, + kClkRateFieldNumber = 3, + kBandwidthFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MdpCommitFtraceEvent"; } + + + using FieldMetadata_Num = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MdpCommitFtraceEvent>; + + static constexpr FieldMetadata_Num kNum{}; + void set_num(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Num::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PlayCnt = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MdpCommitFtraceEvent>; + + static constexpr FieldMetadata_PlayCnt kPlayCnt{}; + void set_play_cnt(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_PlayCnt::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ClkRate = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MdpCommitFtraceEvent>; + + static constexpr FieldMetadata_ClkRate kClkRate{}; + void set_clk_rate(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ClkRate::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Bandwidth = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MdpCommitFtraceEvent>; + + static constexpr FieldMetadata_Bandwidth kBandwidth{}; + void set_bandwidth(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Bandwidth::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class MdpCmdKickoffFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + MdpCmdKickoffFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MdpCmdKickoffFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MdpCmdKickoffFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_ctl_num() const { return at<1>().valid(); } + uint32_t ctl_num() const { return at<1>().as_uint32(); } + bool has_kickoff_cnt() const { return at<2>().valid(); } + int32_t kickoff_cnt() const { return at<2>().as_int32(); } +}; + +class MdpCmdKickoffFtraceEvent : public ::protozero::Message { + public: + using Decoder = MdpCmdKickoffFtraceEvent_Decoder; + enum : int32_t { + kCtlNumFieldNumber = 1, + kKickoffCntFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MdpCmdKickoffFtraceEvent"; } + + + using FieldMetadata_CtlNum = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MdpCmdKickoffFtraceEvent>; + + static constexpr FieldMetadata_CtlNum kCtlNum{}; + void set_ctl_num(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_CtlNum::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_KickoffCnt = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MdpCmdKickoffFtraceEvent>; + + static constexpr FieldMetadata_KickoffCnt kKickoffCnt{}; + void set_kickoff_cnt(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_KickoffCnt::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class MaliMaliCSFINTERRUPTENDFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + MaliMaliCSFINTERRUPTENDFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MaliMaliCSFINTERRUPTENDFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MaliMaliCSFINTERRUPTENDFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_kctx_tgid() const { return at<1>().valid(); } + int32_t kctx_tgid() const { return at<1>().as_int32(); } + bool has_kctx_id() const { return at<2>().valid(); } + uint32_t kctx_id() const { return at<2>().as_uint32(); } + bool has_info_val() const { return at<3>().valid(); } + uint64_t info_val() const { return at<3>().as_uint64(); } +}; + +class MaliMaliCSFINTERRUPTENDFtraceEvent : public ::protozero::Message { + public: + using Decoder = MaliMaliCSFINTERRUPTENDFtraceEvent_Decoder; + enum : int32_t { + kKctxTgidFieldNumber = 1, + kKctxIdFieldNumber = 2, + kInfoValFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MaliMaliCSFINTERRUPTENDFtraceEvent"; } + + + using FieldMetadata_KctxTgid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MaliMaliCSFINTERRUPTENDFtraceEvent>; + + static constexpr FieldMetadata_KctxTgid kKctxTgid{}; + void set_kctx_tgid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_KctxTgid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_KctxId = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MaliMaliCSFINTERRUPTENDFtraceEvent>; + + static constexpr FieldMetadata_KctxId kKctxId{}; + void set_kctx_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_KctxId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_InfoVal = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MaliMaliCSFINTERRUPTENDFtraceEvent>; + + static constexpr FieldMetadata_InfoVal kInfoVal{}; + void set_info_val(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_InfoVal::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class MaliMaliCSFINTERRUPTSTARTFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + MaliMaliCSFINTERRUPTSTARTFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MaliMaliCSFINTERRUPTSTARTFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MaliMaliCSFINTERRUPTSTARTFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_kctx_tgid() const { return at<1>().valid(); } + int32_t kctx_tgid() const { return at<1>().as_int32(); } + bool has_kctx_id() const { return at<2>().valid(); } + uint32_t kctx_id() const { return at<2>().as_uint32(); } + bool has_info_val() const { return at<3>().valid(); } + uint64_t info_val() const { return at<3>().as_uint64(); } +}; + +class MaliMaliCSFINTERRUPTSTARTFtraceEvent : public ::protozero::Message { + public: + using Decoder = MaliMaliCSFINTERRUPTSTARTFtraceEvent_Decoder; + enum : int32_t { + kKctxTgidFieldNumber = 1, + kKctxIdFieldNumber = 2, + kInfoValFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MaliMaliCSFINTERRUPTSTARTFtraceEvent"; } + + + using FieldMetadata_KctxTgid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MaliMaliCSFINTERRUPTSTARTFtraceEvent>; + + static constexpr FieldMetadata_KctxTgid kKctxTgid{}; + void set_kctx_tgid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_KctxTgid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_KctxId = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MaliMaliCSFINTERRUPTSTARTFtraceEvent>; + + static constexpr FieldMetadata_KctxId kKctxId{}; + void set_kctx_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_KctxId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_InfoVal = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MaliMaliCSFINTERRUPTSTARTFtraceEvent>; + + static constexpr FieldMetadata_InfoVal kInfoVal{}; + void set_info_val(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_InfoVal::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class MaliMaliKCPUFENCEWAITENDFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + MaliMaliKCPUFENCEWAITENDFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MaliMaliKCPUFENCEWAITENDFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MaliMaliKCPUFENCEWAITENDFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_info_val1() const { return at<1>().valid(); } + uint64_t info_val1() const { return at<1>().as_uint64(); } + bool has_info_val2() const { return at<2>().valid(); } + uint64_t info_val2() const { return at<2>().as_uint64(); } + bool has_kctx_tgid() const { return at<3>().valid(); } + int32_t kctx_tgid() const { return at<3>().as_int32(); } + bool has_kctx_id() const { return at<4>().valid(); } + uint32_t kctx_id() const { return at<4>().as_uint32(); } + bool has_id() const { return at<5>().valid(); } + uint32_t id() const { return at<5>().as_uint32(); } +}; + +class MaliMaliKCPUFENCEWAITENDFtraceEvent : public ::protozero::Message { + public: + using Decoder = MaliMaliKCPUFENCEWAITENDFtraceEvent_Decoder; + enum : int32_t { + kInfoVal1FieldNumber = 1, + kInfoVal2FieldNumber = 2, + kKctxTgidFieldNumber = 3, + kKctxIdFieldNumber = 4, + kIdFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MaliMaliKCPUFENCEWAITENDFtraceEvent"; } + + + using FieldMetadata_InfoVal1 = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MaliMaliKCPUFENCEWAITENDFtraceEvent>; + + static constexpr FieldMetadata_InfoVal1 kInfoVal1{}; + void set_info_val1(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_InfoVal1::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_InfoVal2 = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MaliMaliKCPUFENCEWAITENDFtraceEvent>; + + static constexpr FieldMetadata_InfoVal2 kInfoVal2{}; + void set_info_val2(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_InfoVal2::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_KctxTgid = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MaliMaliKCPUFENCEWAITENDFtraceEvent>; + + static constexpr FieldMetadata_KctxTgid kKctxTgid{}; + void set_kctx_tgid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_KctxTgid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_KctxId = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MaliMaliKCPUFENCEWAITENDFtraceEvent>; + + static constexpr FieldMetadata_KctxId kKctxId{}; + void set_kctx_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_KctxId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Id = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MaliMaliKCPUFENCEWAITENDFtraceEvent>; + + static constexpr FieldMetadata_Id kId{}; + void set_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class MaliMaliKCPUFENCEWAITSTARTFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + MaliMaliKCPUFENCEWAITSTARTFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MaliMaliKCPUFENCEWAITSTARTFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MaliMaliKCPUFENCEWAITSTARTFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_info_val1() const { return at<1>().valid(); } + uint64_t info_val1() const { return at<1>().as_uint64(); } + bool has_info_val2() const { return at<2>().valid(); } + uint64_t info_val2() const { return at<2>().as_uint64(); } + bool has_kctx_tgid() const { return at<3>().valid(); } + int32_t kctx_tgid() const { return at<3>().as_int32(); } + bool has_kctx_id() const { return at<4>().valid(); } + uint32_t kctx_id() const { return at<4>().as_uint32(); } + bool has_id() const { return at<5>().valid(); } + uint32_t id() const { return at<5>().as_uint32(); } +}; + +class MaliMaliKCPUFENCEWAITSTARTFtraceEvent : public ::protozero::Message { + public: + using Decoder = MaliMaliKCPUFENCEWAITSTARTFtraceEvent_Decoder; + enum : int32_t { + kInfoVal1FieldNumber = 1, + kInfoVal2FieldNumber = 2, + kKctxTgidFieldNumber = 3, + kKctxIdFieldNumber = 4, + kIdFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MaliMaliKCPUFENCEWAITSTARTFtraceEvent"; } + + + using FieldMetadata_InfoVal1 = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MaliMaliKCPUFENCEWAITSTARTFtraceEvent>; + + static constexpr FieldMetadata_InfoVal1 kInfoVal1{}; + void set_info_val1(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_InfoVal1::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_InfoVal2 = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MaliMaliKCPUFENCEWAITSTARTFtraceEvent>; + + static constexpr FieldMetadata_InfoVal2 kInfoVal2{}; + void set_info_val2(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_InfoVal2::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_KctxTgid = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MaliMaliKCPUFENCEWAITSTARTFtraceEvent>; + + static constexpr FieldMetadata_KctxTgid kKctxTgid{}; + void set_kctx_tgid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_KctxTgid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_KctxId = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MaliMaliKCPUFENCEWAITSTARTFtraceEvent>; + + static constexpr FieldMetadata_KctxId kKctxId{}; + void set_kctx_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_KctxId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Id = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MaliMaliKCPUFENCEWAITSTARTFtraceEvent>; + + static constexpr FieldMetadata_Id kId{}; + void set_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class MaliMaliKCPUFENCESIGNALFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + MaliMaliKCPUFENCESIGNALFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MaliMaliKCPUFENCESIGNALFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MaliMaliKCPUFENCESIGNALFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_info_val1() const { return at<1>().valid(); } + uint64_t info_val1() const { return at<1>().as_uint64(); } + bool has_info_val2() const { return at<2>().valid(); } + uint64_t info_val2() const { return at<2>().as_uint64(); } + bool has_kctx_tgid() const { return at<3>().valid(); } + int32_t kctx_tgid() const { return at<3>().as_int32(); } + bool has_kctx_id() const { return at<4>().valid(); } + uint32_t kctx_id() const { return at<4>().as_uint32(); } + bool has_id() const { return at<5>().valid(); } + uint32_t id() const { return at<5>().as_uint32(); } +}; + +class MaliMaliKCPUFENCESIGNALFtraceEvent : public ::protozero::Message { + public: + using Decoder = MaliMaliKCPUFENCESIGNALFtraceEvent_Decoder; + enum : int32_t { + kInfoVal1FieldNumber = 1, + kInfoVal2FieldNumber = 2, + kKctxTgidFieldNumber = 3, + kKctxIdFieldNumber = 4, + kIdFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MaliMaliKCPUFENCESIGNALFtraceEvent"; } + + + using FieldMetadata_InfoVal1 = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MaliMaliKCPUFENCESIGNALFtraceEvent>; + + static constexpr FieldMetadata_InfoVal1 kInfoVal1{}; + void set_info_val1(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_InfoVal1::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_InfoVal2 = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MaliMaliKCPUFENCESIGNALFtraceEvent>; + + static constexpr FieldMetadata_InfoVal2 kInfoVal2{}; + void set_info_val2(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_InfoVal2::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_KctxTgid = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MaliMaliKCPUFENCESIGNALFtraceEvent>; + + static constexpr FieldMetadata_KctxTgid kKctxTgid{}; + void set_kctx_tgid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_KctxTgid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_KctxId = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MaliMaliKCPUFENCESIGNALFtraceEvent>; + + static constexpr FieldMetadata_KctxId kKctxId{}; + void set_kctx_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_KctxId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Id = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MaliMaliKCPUFENCESIGNALFtraceEvent>; + + static constexpr FieldMetadata_Id kId{}; + void set_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class MaliMaliKCPUCQSWAITENDFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + MaliMaliKCPUCQSWAITENDFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MaliMaliKCPUCQSWAITENDFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MaliMaliKCPUCQSWAITENDFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_id() const { return at<1>().valid(); } + uint32_t id() const { return at<1>().as_uint32(); } + bool has_info_val1() const { return at<2>().valid(); } + uint64_t info_val1() const { return at<2>().as_uint64(); } + bool has_info_val2() const { return at<3>().valid(); } + uint64_t info_val2() const { return at<3>().as_uint64(); } + bool has_kctx_id() const { return at<4>().valid(); } + uint32_t kctx_id() const { return at<4>().as_uint32(); } + bool has_kctx_tgid() const { return at<5>().valid(); } + int32_t kctx_tgid() const { return at<5>().as_int32(); } +}; + +class MaliMaliKCPUCQSWAITENDFtraceEvent : public ::protozero::Message { + public: + using Decoder = MaliMaliKCPUCQSWAITENDFtraceEvent_Decoder; + enum : int32_t { + kIdFieldNumber = 1, + kInfoVal1FieldNumber = 2, + kInfoVal2FieldNumber = 3, + kKctxIdFieldNumber = 4, + kKctxTgidFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MaliMaliKCPUCQSWAITENDFtraceEvent"; } + + + using FieldMetadata_Id = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MaliMaliKCPUCQSWAITENDFtraceEvent>; + + static constexpr FieldMetadata_Id kId{}; + void set_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_InfoVal1 = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MaliMaliKCPUCQSWAITENDFtraceEvent>; + + static constexpr FieldMetadata_InfoVal1 kInfoVal1{}; + void set_info_val1(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_InfoVal1::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_InfoVal2 = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MaliMaliKCPUCQSWAITENDFtraceEvent>; + + static constexpr FieldMetadata_InfoVal2 kInfoVal2{}; + void set_info_val2(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_InfoVal2::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_KctxId = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MaliMaliKCPUCQSWAITENDFtraceEvent>; + + static constexpr FieldMetadata_KctxId kKctxId{}; + void set_kctx_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_KctxId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_KctxTgid = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MaliMaliKCPUCQSWAITENDFtraceEvent>; + + static constexpr FieldMetadata_KctxTgid kKctxTgid{}; + void set_kctx_tgid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_KctxTgid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class MaliMaliKCPUCQSWAITSTARTFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + MaliMaliKCPUCQSWAITSTARTFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MaliMaliKCPUCQSWAITSTARTFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MaliMaliKCPUCQSWAITSTARTFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_id() const { return at<1>().valid(); } + uint32_t id() const { return at<1>().as_uint32(); } + bool has_info_val1() const { return at<2>().valid(); } + uint64_t info_val1() const { return at<2>().as_uint64(); } + bool has_info_val2() const { return at<3>().valid(); } + uint64_t info_val2() const { return at<3>().as_uint64(); } + bool has_kctx_id() const { return at<4>().valid(); } + uint32_t kctx_id() const { return at<4>().as_uint32(); } + bool has_kctx_tgid() const { return at<5>().valid(); } + int32_t kctx_tgid() const { return at<5>().as_int32(); } +}; + +class MaliMaliKCPUCQSWAITSTARTFtraceEvent : public ::protozero::Message { + public: + using Decoder = MaliMaliKCPUCQSWAITSTARTFtraceEvent_Decoder; + enum : int32_t { + kIdFieldNumber = 1, + kInfoVal1FieldNumber = 2, + kInfoVal2FieldNumber = 3, + kKctxIdFieldNumber = 4, + kKctxTgidFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MaliMaliKCPUCQSWAITSTARTFtraceEvent"; } + + + using FieldMetadata_Id = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MaliMaliKCPUCQSWAITSTARTFtraceEvent>; + + static constexpr FieldMetadata_Id kId{}; + void set_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_InfoVal1 = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MaliMaliKCPUCQSWAITSTARTFtraceEvent>; + + static constexpr FieldMetadata_InfoVal1 kInfoVal1{}; + void set_info_val1(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_InfoVal1::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_InfoVal2 = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MaliMaliKCPUCQSWAITSTARTFtraceEvent>; + + static constexpr FieldMetadata_InfoVal2 kInfoVal2{}; + void set_info_val2(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_InfoVal2::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_KctxId = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MaliMaliKCPUCQSWAITSTARTFtraceEvent>; + + static constexpr FieldMetadata_KctxId kKctxId{}; + void set_kctx_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_KctxId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_KctxTgid = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MaliMaliKCPUCQSWAITSTARTFtraceEvent>; + + static constexpr FieldMetadata_KctxTgid kKctxTgid{}; + void set_kctx_tgid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_KctxTgid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class MaliMaliKCPUCQSSETFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + MaliMaliKCPUCQSSETFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MaliMaliKCPUCQSSETFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MaliMaliKCPUCQSSETFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_id() const { return at<1>().valid(); } + uint32_t id() const { return at<1>().as_uint32(); } + bool has_info_val1() const { return at<2>().valid(); } + uint64_t info_val1() const { return at<2>().as_uint64(); } + bool has_info_val2() const { return at<3>().valid(); } + uint64_t info_val2() const { return at<3>().as_uint64(); } + bool has_kctx_id() const { return at<4>().valid(); } + uint32_t kctx_id() const { return at<4>().as_uint32(); } + bool has_kctx_tgid() const { return at<5>().valid(); } + int32_t kctx_tgid() const { return at<5>().as_int32(); } +}; + +class MaliMaliKCPUCQSSETFtraceEvent : public ::protozero::Message { + public: + using Decoder = MaliMaliKCPUCQSSETFtraceEvent_Decoder; + enum : int32_t { + kIdFieldNumber = 1, + kInfoVal1FieldNumber = 2, + kInfoVal2FieldNumber = 3, + kKctxIdFieldNumber = 4, + kKctxTgidFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MaliMaliKCPUCQSSETFtraceEvent"; } + + + using FieldMetadata_Id = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MaliMaliKCPUCQSSETFtraceEvent>; + + static constexpr FieldMetadata_Id kId{}; + void set_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_InfoVal1 = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MaliMaliKCPUCQSSETFtraceEvent>; + + static constexpr FieldMetadata_InfoVal1 kInfoVal1{}; + void set_info_val1(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_InfoVal1::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_InfoVal2 = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MaliMaliKCPUCQSSETFtraceEvent>; + + static constexpr FieldMetadata_InfoVal2 kInfoVal2{}; + void set_info_val2(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_InfoVal2::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_KctxId = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MaliMaliKCPUCQSSETFtraceEvent>; + + static constexpr FieldMetadata_KctxId kKctxId{}; + void set_kctx_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_KctxId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_KctxTgid = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MaliMaliKCPUCQSSETFtraceEvent>; + + static constexpr FieldMetadata_KctxTgid kKctxTgid{}; + void set_kctx_tgid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_KctxTgid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class MaliTracingMarkWriteFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + MaliTracingMarkWriteFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MaliTracingMarkWriteFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MaliTracingMarkWriteFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_name() const { return at<1>().valid(); } + ::protozero::ConstChars name() const { return at<1>().as_string(); } + bool has_pid() const { return at<2>().valid(); } + int32_t pid() const { return at<2>().as_int32(); } + bool has_type() const { return at<3>().valid(); } + uint32_t type() const { return at<3>().as_uint32(); } + bool has_value() const { return at<4>().valid(); } + int32_t value() const { return at<4>().as_int32(); } +}; + +class MaliTracingMarkWriteFtraceEvent : public ::protozero::Message { + public: + using Decoder = MaliTracingMarkWriteFtraceEvent_Decoder; + enum : int32_t { + kNameFieldNumber = 1, + kPidFieldNumber = 2, + kTypeFieldNumber = 3, + kValueFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MaliTracingMarkWriteFtraceEvent"; } + + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + MaliTracingMarkWriteFtraceEvent>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pid = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MaliTracingMarkWriteFtraceEvent>; + + static constexpr FieldMetadata_Pid kPid{}; + void set_pid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Type = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MaliTracingMarkWriteFtraceEvent>; + + static constexpr FieldMetadata_Type kType{}; + void set_type(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Value = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MaliTracingMarkWriteFtraceEvent>; + + static constexpr FieldMetadata_Value kValue{}; + void set_value(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class LwisTracingMarkWriteFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + LwisTracingMarkWriteFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit LwisTracingMarkWriteFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit LwisTracingMarkWriteFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_lwis_name() const { return at<1>().valid(); } + ::protozero::ConstChars lwis_name() const { return at<1>().as_string(); } + bool has_type() const { return at<2>().valid(); } + uint32_t type() const { return at<2>().as_uint32(); } + bool has_pid() const { return at<3>().valid(); } + int32_t pid() const { return at<3>().as_int32(); } + bool has_func_name() const { return at<4>().valid(); } + ::protozero::ConstChars func_name() const { return at<4>().as_string(); } + bool has_value() const { return at<5>().valid(); } + int64_t value() const { return at<5>().as_int64(); } +}; + +class LwisTracingMarkWriteFtraceEvent : public ::protozero::Message { + public: + using Decoder = LwisTracingMarkWriteFtraceEvent_Decoder; + enum : int32_t { + kLwisNameFieldNumber = 1, + kTypeFieldNumber = 2, + kPidFieldNumber = 3, + kFuncNameFieldNumber = 4, + kValueFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.LwisTracingMarkWriteFtraceEvent"; } + + + using FieldMetadata_LwisName = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + LwisTracingMarkWriteFtraceEvent>; + + static constexpr FieldMetadata_LwisName kLwisName{}; + void set_lwis_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_LwisName::kFieldId, data, size); + } + void set_lwis_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_LwisName::kFieldId, chars.data, chars.size); + } + void set_lwis_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_LwisName::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Type = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + LwisTracingMarkWriteFtraceEvent>; + + static constexpr FieldMetadata_Type kType{}; + void set_type(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pid = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + LwisTracingMarkWriteFtraceEvent>; + + static constexpr FieldMetadata_Pid kPid{}; + void set_pid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FuncName = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + LwisTracingMarkWriteFtraceEvent>; + + static constexpr FieldMetadata_FuncName kFuncName{}; + void set_func_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_FuncName::kFieldId, data, size); + } + void set_func_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_FuncName::kFieldId, chars.data, chars.size); + } + void set_func_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_FuncName::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Value = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + LwisTracingMarkWriteFtraceEvent>; + + static constexpr FieldMetadata_Value kValue{}; + void set_value(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } +}; + +class LowmemoryKillFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + LowmemoryKillFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit LowmemoryKillFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit LowmemoryKillFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_comm() const { return at<1>().valid(); } + ::protozero::ConstChars comm() const { return at<1>().as_string(); } + bool has_pid() const { return at<2>().valid(); } + int32_t pid() const { return at<2>().as_int32(); } + bool has_pagecache_size() const { return at<3>().valid(); } + int64_t pagecache_size() const { return at<3>().as_int64(); } + bool has_pagecache_limit() const { return at<4>().valid(); } + int64_t pagecache_limit() const { return at<4>().as_int64(); } + bool has_free() const { return at<5>().valid(); } + int64_t free() const { return at<5>().as_int64(); } +}; + +class LowmemoryKillFtraceEvent : public ::protozero::Message { + public: + using Decoder = LowmemoryKillFtraceEvent_Decoder; + enum : int32_t { + kCommFieldNumber = 1, + kPidFieldNumber = 2, + kPagecacheSizeFieldNumber = 3, + kPagecacheLimitFieldNumber = 4, + kFreeFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.LowmemoryKillFtraceEvent"; } + + + using FieldMetadata_Comm = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + LowmemoryKillFtraceEvent>; + + static constexpr FieldMetadata_Comm kComm{}; + void set_comm(const char* data, size_t size) { + AppendBytes(FieldMetadata_Comm::kFieldId, data, size); + } + void set_comm(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Comm::kFieldId, chars.data, chars.size); + } + void set_comm(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Comm::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pid = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + LowmemoryKillFtraceEvent>; + + static constexpr FieldMetadata_Pid kPid{}; + void set_pid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PagecacheSize = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + LowmemoryKillFtraceEvent>; + + static constexpr FieldMetadata_PagecacheSize kPagecacheSize{}; + void set_pagecache_size(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_PagecacheSize::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PagecacheLimit = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + LowmemoryKillFtraceEvent>; + + static constexpr FieldMetadata_PagecacheLimit kPagecacheLimit{}; + void set_pagecache_limit(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_PagecacheLimit::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Free = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + LowmemoryKillFtraceEvent>; + + static constexpr FieldMetadata_Free kFree{}; + void set_free(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Free::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } +}; + +class VgicUpdateIrqPendingFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + VgicUpdateIrqPendingFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit VgicUpdateIrqPendingFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit VgicUpdateIrqPendingFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_irq() const { return at<1>().valid(); } + uint32_t irq() const { return at<1>().as_uint32(); } + bool has_level() const { return at<2>().valid(); } + uint32_t level() const { return at<2>().as_uint32(); } + bool has_vcpu_id() const { return at<3>().valid(); } + uint64_t vcpu_id() const { return at<3>().as_uint64(); } +}; + +class VgicUpdateIrqPendingFtraceEvent : public ::protozero::Message { + public: + using Decoder = VgicUpdateIrqPendingFtraceEvent_Decoder; + enum : int32_t { + kIrqFieldNumber = 1, + kLevelFieldNumber = 2, + kVcpuIdFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.VgicUpdateIrqPendingFtraceEvent"; } + + + using FieldMetadata_Irq = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + VgicUpdateIrqPendingFtraceEvent>; + + static constexpr FieldMetadata_Irq kIrq{}; + void set_irq(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Irq::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Level = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + VgicUpdateIrqPendingFtraceEvent>; + + static constexpr FieldMetadata_Level kLevel{}; + void set_level(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Level::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_VcpuId = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + VgicUpdateIrqPendingFtraceEvent>; + + static constexpr FieldMetadata_VcpuId kVcpuId{}; + void set_vcpu_id(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_VcpuId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class TrapRegFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + TrapRegFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TrapRegFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TrapRegFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_fn() const { return at<1>().valid(); } + ::protozero::ConstChars fn() const { return at<1>().as_string(); } + bool has_is_write() const { return at<2>().valid(); } + uint32_t is_write() const { return at<2>().as_uint32(); } + bool has_reg() const { return at<3>().valid(); } + int32_t reg() const { return at<3>().as_int32(); } + bool has_write_value() const { return at<4>().valid(); } + uint64_t write_value() const { return at<4>().as_uint64(); } +}; + +class TrapRegFtraceEvent : public ::protozero::Message { + public: + using Decoder = TrapRegFtraceEvent_Decoder; + enum : int32_t { + kFnFieldNumber = 1, + kIsWriteFieldNumber = 2, + kRegFieldNumber = 3, + kWriteValueFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.TrapRegFtraceEvent"; } + + + using FieldMetadata_Fn = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + TrapRegFtraceEvent>; + + static constexpr FieldMetadata_Fn kFn{}; + void set_fn(const char* data, size_t size) { + AppendBytes(FieldMetadata_Fn::kFieldId, data, size); + } + void set_fn(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Fn::kFieldId, chars.data, chars.size); + } + void set_fn(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Fn::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_IsWrite = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + TrapRegFtraceEvent>; + + static constexpr FieldMetadata_IsWrite kIsWrite{}; + void set_is_write(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_IsWrite::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Reg = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + TrapRegFtraceEvent>; + + static constexpr FieldMetadata_Reg kReg{}; + void set_reg(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Reg::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_WriteValue = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TrapRegFtraceEvent>; + + static constexpr FieldMetadata_WriteValue kWriteValue{}; + void set_write_value(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_WriteValue::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class KvmWfxArm64FtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + KvmWfxArm64FtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit KvmWfxArm64FtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit KvmWfxArm64FtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_is_wfe() const { return at<1>().valid(); } + uint32_t is_wfe() const { return at<1>().as_uint32(); } + bool has_vcpu_pc() const { return at<2>().valid(); } + uint64_t vcpu_pc() const { return at<2>().as_uint64(); } +}; + +class KvmWfxArm64FtraceEvent : public ::protozero::Message { + public: + using Decoder = KvmWfxArm64FtraceEvent_Decoder; + enum : int32_t { + kIsWfeFieldNumber = 1, + kVcpuPcFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.KvmWfxArm64FtraceEvent"; } + + + using FieldMetadata_IsWfe = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + KvmWfxArm64FtraceEvent>; + + static constexpr FieldMetadata_IsWfe kIsWfe{}; + void set_is_wfe(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_IsWfe::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_VcpuPc = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + KvmWfxArm64FtraceEvent>; + + static constexpr FieldMetadata_VcpuPc kVcpuPc{}; + void set_vcpu_pc(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_VcpuPc::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class KvmVcpuWakeupFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + KvmVcpuWakeupFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit KvmVcpuWakeupFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit KvmVcpuWakeupFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_ns() const { return at<1>().valid(); } + uint64_t ns() const { return at<1>().as_uint64(); } + bool has_valid() const { return at<2>().valid(); } + uint32_t valid() const { return at<2>().as_uint32(); } + bool has_waited() const { return at<3>().valid(); } + uint32_t waited() const { return at<3>().as_uint32(); } +}; + +class KvmVcpuWakeupFtraceEvent : public ::protozero::Message { + public: + using Decoder = KvmVcpuWakeupFtraceEvent_Decoder; + enum : int32_t { + kNsFieldNumber = 1, + kValidFieldNumber = 2, + kWaitedFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.KvmVcpuWakeupFtraceEvent"; } + + + using FieldMetadata_Ns = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + KvmVcpuWakeupFtraceEvent>; + + static constexpr FieldMetadata_Ns kNs{}; + void set_ns(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ns::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Valid = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + KvmVcpuWakeupFtraceEvent>; + + static constexpr FieldMetadata_Valid kValid{}; + void set_valid(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Valid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Waited = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + KvmVcpuWakeupFtraceEvent>; + + static constexpr FieldMetadata_Waited kWaited{}; + void set_waited(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Waited::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class KvmUserspaceExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + KvmUserspaceExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit KvmUserspaceExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit KvmUserspaceExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_reason() const { return at<1>().valid(); } + uint32_t reason() const { return at<1>().as_uint32(); } +}; + +class KvmUserspaceExitFtraceEvent : public ::protozero::Message { + public: + using Decoder = KvmUserspaceExitFtraceEvent_Decoder; + enum : int32_t { + kReasonFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.KvmUserspaceExitFtraceEvent"; } + + + using FieldMetadata_Reason = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + KvmUserspaceExitFtraceEvent>; + + static constexpr FieldMetadata_Reason kReason{}; + void set_reason(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Reason::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class KvmUnmapHvaRangeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + KvmUnmapHvaRangeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit KvmUnmapHvaRangeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit KvmUnmapHvaRangeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_end() const { return at<1>().valid(); } + uint64_t end() const { return at<1>().as_uint64(); } + bool has_start() const { return at<2>().valid(); } + uint64_t start() const { return at<2>().as_uint64(); } +}; + +class KvmUnmapHvaRangeFtraceEvent : public ::protozero::Message { + public: + using Decoder = KvmUnmapHvaRangeFtraceEvent_Decoder; + enum : int32_t { + kEndFieldNumber = 1, + kStartFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.KvmUnmapHvaRangeFtraceEvent"; } + + + using FieldMetadata_End = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + KvmUnmapHvaRangeFtraceEvent>; + + static constexpr FieldMetadata_End kEnd{}; + void set_end(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_End::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Start = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + KvmUnmapHvaRangeFtraceEvent>; + + static constexpr FieldMetadata_Start kStart{}; + void set_start(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Start::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class KvmToggleCacheFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + KvmToggleCacheFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit KvmToggleCacheFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit KvmToggleCacheFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_now() const { return at<1>().valid(); } + uint32_t now() const { return at<1>().as_uint32(); } + bool has_vcpu_pc() const { return at<2>().valid(); } + uint64_t vcpu_pc() const { return at<2>().as_uint64(); } + bool has_was() const { return at<3>().valid(); } + uint32_t was() const { return at<3>().as_uint32(); } +}; + +class KvmToggleCacheFtraceEvent : public ::protozero::Message { + public: + using Decoder = KvmToggleCacheFtraceEvent_Decoder; + enum : int32_t { + kNowFieldNumber = 1, + kVcpuPcFieldNumber = 2, + kWasFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.KvmToggleCacheFtraceEvent"; } + + + using FieldMetadata_Now = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + KvmToggleCacheFtraceEvent>; + + static constexpr FieldMetadata_Now kNow{}; + void set_now(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Now::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_VcpuPc = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + KvmToggleCacheFtraceEvent>; + + static constexpr FieldMetadata_VcpuPc kVcpuPc{}; + void set_vcpu_pc(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_VcpuPc::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Was = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + KvmToggleCacheFtraceEvent>; + + static constexpr FieldMetadata_Was kWas{}; + void set_was(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Was::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class KvmTimerUpdateIrqFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + KvmTimerUpdateIrqFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit KvmTimerUpdateIrqFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit KvmTimerUpdateIrqFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_irq() const { return at<1>().valid(); } + uint32_t irq() const { return at<1>().as_uint32(); } + bool has_level() const { return at<2>().valid(); } + int32_t level() const { return at<2>().as_int32(); } + bool has_vcpu_id() const { return at<3>().valid(); } + uint64_t vcpu_id() const { return at<3>().as_uint64(); } +}; + +class KvmTimerUpdateIrqFtraceEvent : public ::protozero::Message { + public: + using Decoder = KvmTimerUpdateIrqFtraceEvent_Decoder; + enum : int32_t { + kIrqFieldNumber = 1, + kLevelFieldNumber = 2, + kVcpuIdFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.KvmTimerUpdateIrqFtraceEvent"; } + + + using FieldMetadata_Irq = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + KvmTimerUpdateIrqFtraceEvent>; + + static constexpr FieldMetadata_Irq kIrq{}; + void set_irq(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Irq::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Level = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + KvmTimerUpdateIrqFtraceEvent>; + + static constexpr FieldMetadata_Level kLevel{}; + void set_level(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Level::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_VcpuId = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + KvmTimerUpdateIrqFtraceEvent>; + + static constexpr FieldMetadata_VcpuId kVcpuId{}; + void set_vcpu_id(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_VcpuId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class KvmTimerSaveStateFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + KvmTimerSaveStateFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit KvmTimerSaveStateFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit KvmTimerSaveStateFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_ctl() const { return at<1>().valid(); } + uint64_t ctl() const { return at<1>().as_uint64(); } + bool has_cval() const { return at<2>().valid(); } + uint64_t cval() const { return at<2>().as_uint64(); } + bool has_timer_idx() const { return at<3>().valid(); } + int32_t timer_idx() const { return at<3>().as_int32(); } +}; + +class KvmTimerSaveStateFtraceEvent : public ::protozero::Message { + public: + using Decoder = KvmTimerSaveStateFtraceEvent_Decoder; + enum : int32_t { + kCtlFieldNumber = 1, + kCvalFieldNumber = 2, + kTimerIdxFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.KvmTimerSaveStateFtraceEvent"; } + + + using FieldMetadata_Ctl = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + KvmTimerSaveStateFtraceEvent>; + + static constexpr FieldMetadata_Ctl kCtl{}; + void set_ctl(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ctl::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Cval = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + KvmTimerSaveStateFtraceEvent>; + + static constexpr FieldMetadata_Cval kCval{}; + void set_cval(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Cval::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TimerIdx = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + KvmTimerSaveStateFtraceEvent>; + + static constexpr FieldMetadata_TimerIdx kTimerIdx{}; + void set_timer_idx(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TimerIdx::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class KvmTimerRestoreStateFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + KvmTimerRestoreStateFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit KvmTimerRestoreStateFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit KvmTimerRestoreStateFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_ctl() const { return at<1>().valid(); } + uint64_t ctl() const { return at<1>().as_uint64(); } + bool has_cval() const { return at<2>().valid(); } + uint64_t cval() const { return at<2>().as_uint64(); } + bool has_timer_idx() const { return at<3>().valid(); } + int32_t timer_idx() const { return at<3>().as_int32(); } +}; + +class KvmTimerRestoreStateFtraceEvent : public ::protozero::Message { + public: + using Decoder = KvmTimerRestoreStateFtraceEvent_Decoder; + enum : int32_t { + kCtlFieldNumber = 1, + kCvalFieldNumber = 2, + kTimerIdxFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.KvmTimerRestoreStateFtraceEvent"; } + + + using FieldMetadata_Ctl = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + KvmTimerRestoreStateFtraceEvent>; + + static constexpr FieldMetadata_Ctl kCtl{}; + void set_ctl(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ctl::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Cval = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + KvmTimerRestoreStateFtraceEvent>; + + static constexpr FieldMetadata_Cval kCval{}; + void set_cval(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Cval::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TimerIdx = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + KvmTimerRestoreStateFtraceEvent>; + + static constexpr FieldMetadata_TimerIdx kTimerIdx{}; + void set_timer_idx(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TimerIdx::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class KvmTimerHrtimerExpireFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + KvmTimerHrtimerExpireFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit KvmTimerHrtimerExpireFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit KvmTimerHrtimerExpireFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_timer_idx() const { return at<1>().valid(); } + int32_t timer_idx() const { return at<1>().as_int32(); } +}; + +class KvmTimerHrtimerExpireFtraceEvent : public ::protozero::Message { + public: + using Decoder = KvmTimerHrtimerExpireFtraceEvent_Decoder; + enum : int32_t { + kTimerIdxFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.KvmTimerHrtimerExpireFtraceEvent"; } + + + using FieldMetadata_TimerIdx = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + KvmTimerHrtimerExpireFtraceEvent>; + + static constexpr FieldMetadata_TimerIdx kTimerIdx{}; + void set_timer_idx(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TimerIdx::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class KvmTimerEmulateFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + KvmTimerEmulateFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit KvmTimerEmulateFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit KvmTimerEmulateFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_should_fire() const { return at<1>().valid(); } + uint32_t should_fire() const { return at<1>().as_uint32(); } + bool has_timer_idx() const { return at<2>().valid(); } + int32_t timer_idx() const { return at<2>().as_int32(); } +}; + +class KvmTimerEmulateFtraceEvent : public ::protozero::Message { + public: + using Decoder = KvmTimerEmulateFtraceEvent_Decoder; + enum : int32_t { + kShouldFireFieldNumber = 1, + kTimerIdxFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.KvmTimerEmulateFtraceEvent"; } + + + using FieldMetadata_ShouldFire = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + KvmTimerEmulateFtraceEvent>; + + static constexpr FieldMetadata_ShouldFire kShouldFire{}; + void set_should_fire(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ShouldFire::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TimerIdx = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + KvmTimerEmulateFtraceEvent>; + + static constexpr FieldMetadata_TimerIdx kTimerIdx{}; + void set_timer_idx(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TimerIdx::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class KvmTestAgeHvaFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + KvmTestAgeHvaFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit KvmTestAgeHvaFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit KvmTestAgeHvaFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_hva() const { return at<1>().valid(); } + uint64_t hva() const { return at<1>().as_uint64(); } +}; + +class KvmTestAgeHvaFtraceEvent : public ::protozero::Message { + public: + using Decoder = KvmTestAgeHvaFtraceEvent_Decoder; + enum : int32_t { + kHvaFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.KvmTestAgeHvaFtraceEvent"; } + + + using FieldMetadata_Hva = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + KvmTestAgeHvaFtraceEvent>; + + static constexpr FieldMetadata_Hva kHva{}; + void set_hva(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Hva::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class KvmSysAccessFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + KvmSysAccessFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit KvmSysAccessFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit KvmSysAccessFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_crm() const { return at<1>().valid(); } + uint32_t crm() const { return at<1>().as_uint32(); } + bool has_crn() const { return at<2>().valid(); } + uint32_t crn() const { return at<2>().as_uint32(); } + bool has_op0() const { return at<3>().valid(); } + uint32_t op0() const { return at<3>().as_uint32(); } + bool has_op1() const { return at<4>().valid(); } + uint32_t op1() const { return at<4>().as_uint32(); } + bool has_op2() const { return at<5>().valid(); } + uint32_t op2() const { return at<5>().as_uint32(); } + bool has_is_write() const { return at<6>().valid(); } + uint32_t is_write() const { return at<6>().as_uint32(); } + bool has_name() const { return at<7>().valid(); } + ::protozero::ConstChars name() const { return at<7>().as_string(); } + bool has_vcpu_pc() const { return at<8>().valid(); } + uint64_t vcpu_pc() const { return at<8>().as_uint64(); } +}; + +class KvmSysAccessFtraceEvent : public ::protozero::Message { + public: + using Decoder = KvmSysAccessFtraceEvent_Decoder; + enum : int32_t { + kCRmFieldNumber = 1, + kCRnFieldNumber = 2, + kOp0FieldNumber = 3, + kOp1FieldNumber = 4, + kOp2FieldNumber = 5, + kIsWriteFieldNumber = 6, + kNameFieldNumber = 7, + kVcpuPcFieldNumber = 8, + }; + static constexpr const char* GetName() { return ".perfetto.protos.KvmSysAccessFtraceEvent"; } + + + using FieldMetadata_CRm = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + KvmSysAccessFtraceEvent>; + + static constexpr FieldMetadata_CRm kCRm{}; + void set_crm(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_CRm::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CRn = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + KvmSysAccessFtraceEvent>; + + static constexpr FieldMetadata_CRn kCRn{}; + void set_crn(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_CRn::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Op0 = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + KvmSysAccessFtraceEvent>; + + static constexpr FieldMetadata_Op0 kOp0{}; + void set_op0(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Op0::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Op1 = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + KvmSysAccessFtraceEvent>; + + static constexpr FieldMetadata_Op1 kOp1{}; + void set_op1(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Op1::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Op2 = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + KvmSysAccessFtraceEvent>; + + static constexpr FieldMetadata_Op2 kOp2{}; + void set_op2(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Op2::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_IsWrite = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + KvmSysAccessFtraceEvent>; + + static constexpr FieldMetadata_IsWrite kIsWrite{}; + void set_is_write(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_IsWrite::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + KvmSysAccessFtraceEvent>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_VcpuPc = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + KvmSysAccessFtraceEvent>; + + static constexpr FieldMetadata_VcpuPc kVcpuPc{}; + void set_vcpu_pc(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_VcpuPc::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class KvmSetWayFlushFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + KvmSetWayFlushFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit KvmSetWayFlushFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit KvmSetWayFlushFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_cache() const { return at<1>().valid(); } + uint32_t cache() const { return at<1>().as_uint32(); } + bool has_vcpu_pc() const { return at<2>().valid(); } + uint64_t vcpu_pc() const { return at<2>().as_uint64(); } +}; + +class KvmSetWayFlushFtraceEvent : public ::protozero::Message { + public: + using Decoder = KvmSetWayFlushFtraceEvent_Decoder; + enum : int32_t { + kCacheFieldNumber = 1, + kVcpuPcFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.KvmSetWayFlushFtraceEvent"; } + + + using FieldMetadata_Cache = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + KvmSetWayFlushFtraceEvent>; + + static constexpr FieldMetadata_Cache kCache{}; + void set_cache(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Cache::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_VcpuPc = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + KvmSetWayFlushFtraceEvent>; + + static constexpr FieldMetadata_VcpuPc kVcpuPc{}; + void set_vcpu_pc(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_VcpuPc::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class KvmSetSpteHvaFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + KvmSetSpteHvaFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit KvmSetSpteHvaFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit KvmSetSpteHvaFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_hva() const { return at<1>().valid(); } + uint64_t hva() const { return at<1>().as_uint64(); } +}; + +class KvmSetSpteHvaFtraceEvent : public ::protozero::Message { + public: + using Decoder = KvmSetSpteHvaFtraceEvent_Decoder; + enum : int32_t { + kHvaFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.KvmSetSpteHvaFtraceEvent"; } + + + using FieldMetadata_Hva = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + KvmSetSpteHvaFtraceEvent>; + + static constexpr FieldMetadata_Hva kHva{}; + void set_hva(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Hva::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class KvmSetIrqFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + KvmSetIrqFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit KvmSetIrqFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit KvmSetIrqFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_gsi() const { return at<1>().valid(); } + uint32_t gsi() const { return at<1>().as_uint32(); } + bool has_irq_source_id() const { return at<2>().valid(); } + int32_t irq_source_id() const { return at<2>().as_int32(); } + bool has_level() const { return at<3>().valid(); } + int32_t level() const { return at<3>().as_int32(); } +}; + +class KvmSetIrqFtraceEvent : public ::protozero::Message { + public: + using Decoder = KvmSetIrqFtraceEvent_Decoder; + enum : int32_t { + kGsiFieldNumber = 1, + kIrqSourceIdFieldNumber = 2, + kLevelFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.KvmSetIrqFtraceEvent"; } + + + using FieldMetadata_Gsi = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + KvmSetIrqFtraceEvent>; + + static constexpr FieldMetadata_Gsi kGsi{}; + void set_gsi(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Gsi::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_IrqSourceId = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + KvmSetIrqFtraceEvent>; + + static constexpr FieldMetadata_IrqSourceId kIrqSourceId{}; + void set_irq_source_id(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_IrqSourceId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Level = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + KvmSetIrqFtraceEvent>; + + static constexpr FieldMetadata_Level kLevel{}; + void set_level(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Level::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class KvmSetGuestDebugFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + KvmSetGuestDebugFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit KvmSetGuestDebugFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit KvmSetGuestDebugFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_guest_debug() const { return at<1>().valid(); } + uint32_t guest_debug() const { return at<1>().as_uint32(); } + bool has_vcpu() const { return at<2>().valid(); } + uint64_t vcpu() const { return at<2>().as_uint64(); } +}; + +class KvmSetGuestDebugFtraceEvent : public ::protozero::Message { + public: + using Decoder = KvmSetGuestDebugFtraceEvent_Decoder; + enum : int32_t { + kGuestDebugFieldNumber = 1, + kVcpuFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.KvmSetGuestDebugFtraceEvent"; } + + + using FieldMetadata_GuestDebug = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + KvmSetGuestDebugFtraceEvent>; + + static constexpr FieldMetadata_GuestDebug kGuestDebug{}; + void set_guest_debug(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_GuestDebug::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Vcpu = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + KvmSetGuestDebugFtraceEvent>; + + static constexpr FieldMetadata_Vcpu kVcpu{}; + void set_vcpu(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Vcpu::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class KvmMmioEmulateFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + KvmMmioEmulateFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit KvmMmioEmulateFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit KvmMmioEmulateFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_cpsr() const { return at<1>().valid(); } + uint64_t cpsr() const { return at<1>().as_uint64(); } + bool has_instr() const { return at<2>().valid(); } + uint64_t instr() const { return at<2>().as_uint64(); } + bool has_vcpu_pc() const { return at<3>().valid(); } + uint64_t vcpu_pc() const { return at<3>().as_uint64(); } +}; + +class KvmMmioEmulateFtraceEvent : public ::protozero::Message { + public: + using Decoder = KvmMmioEmulateFtraceEvent_Decoder; + enum : int32_t { + kCpsrFieldNumber = 1, + kInstrFieldNumber = 2, + kVcpuPcFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.KvmMmioEmulateFtraceEvent"; } + + + using FieldMetadata_Cpsr = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + KvmMmioEmulateFtraceEvent>; + + static constexpr FieldMetadata_Cpsr kCpsr{}; + void set_cpsr(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Cpsr::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Instr = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + KvmMmioEmulateFtraceEvent>; + + static constexpr FieldMetadata_Instr kInstr{}; + void set_instr(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Instr::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_VcpuPc = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + KvmMmioEmulateFtraceEvent>; + + static constexpr FieldMetadata_VcpuPc kVcpuPc{}; + void set_vcpu_pc(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_VcpuPc::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class KvmMmioFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + KvmMmioFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit KvmMmioFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit KvmMmioFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_gpa() const { return at<1>().valid(); } + uint64_t gpa() const { return at<1>().as_uint64(); } + bool has_len() const { return at<2>().valid(); } + uint32_t len() const { return at<2>().as_uint32(); } + bool has_type() const { return at<3>().valid(); } + uint32_t type() const { return at<3>().as_uint32(); } + bool has_val() const { return at<4>().valid(); } + uint64_t val() const { return at<4>().as_uint64(); } +}; + +class KvmMmioFtraceEvent : public ::protozero::Message { + public: + using Decoder = KvmMmioFtraceEvent_Decoder; + enum : int32_t { + kGpaFieldNumber = 1, + kLenFieldNumber = 2, + kTypeFieldNumber = 3, + kValFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.KvmMmioFtraceEvent"; } + + + using FieldMetadata_Gpa = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + KvmMmioFtraceEvent>; + + static constexpr FieldMetadata_Gpa kGpa{}; + void set_gpa(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Gpa::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Len = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + KvmMmioFtraceEvent>; + + static constexpr FieldMetadata_Len kLen{}; + void set_len(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Type = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + KvmMmioFtraceEvent>; + + static constexpr FieldMetadata_Type kType{}; + void set_type(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Val = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + KvmMmioFtraceEvent>; + + static constexpr FieldMetadata_Val kVal{}; + void set_val(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Val::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class KvmIrqLineFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + KvmIrqLineFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit KvmIrqLineFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit KvmIrqLineFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_irq_num() const { return at<1>().valid(); } + int32_t irq_num() const { return at<1>().as_int32(); } + bool has_level() const { return at<2>().valid(); } + int32_t level() const { return at<2>().as_int32(); } + bool has_type() const { return at<3>().valid(); } + uint32_t type() const { return at<3>().as_uint32(); } + bool has_vcpu_idx() const { return at<4>().valid(); } + int32_t vcpu_idx() const { return at<4>().as_int32(); } +}; + +class KvmIrqLineFtraceEvent : public ::protozero::Message { + public: + using Decoder = KvmIrqLineFtraceEvent_Decoder; + enum : int32_t { + kIrqNumFieldNumber = 1, + kLevelFieldNumber = 2, + kTypeFieldNumber = 3, + kVcpuIdxFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.KvmIrqLineFtraceEvent"; } + + + using FieldMetadata_IrqNum = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + KvmIrqLineFtraceEvent>; + + static constexpr FieldMetadata_IrqNum kIrqNum{}; + void set_irq_num(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_IrqNum::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Level = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + KvmIrqLineFtraceEvent>; + + static constexpr FieldMetadata_Level kLevel{}; + void set_level(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Level::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Type = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + KvmIrqLineFtraceEvent>; + + static constexpr FieldMetadata_Type kType{}; + void set_type(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_VcpuIdx = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + KvmIrqLineFtraceEvent>; + + static constexpr FieldMetadata_VcpuIdx kVcpuIdx{}; + void set_vcpu_idx(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_VcpuIdx::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class KvmHvcArm64FtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + KvmHvcArm64FtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit KvmHvcArm64FtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit KvmHvcArm64FtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_imm() const { return at<1>().valid(); } + uint64_t imm() const { return at<1>().as_uint64(); } + bool has_r0() const { return at<2>().valid(); } + uint64_t r0() const { return at<2>().as_uint64(); } + bool has_vcpu_pc() const { return at<3>().valid(); } + uint64_t vcpu_pc() const { return at<3>().as_uint64(); } +}; + +class KvmHvcArm64FtraceEvent : public ::protozero::Message { + public: + using Decoder = KvmHvcArm64FtraceEvent_Decoder; + enum : int32_t { + kImmFieldNumber = 1, + kR0FieldNumber = 2, + kVcpuPcFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.KvmHvcArm64FtraceEvent"; } + + + using FieldMetadata_Imm = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + KvmHvcArm64FtraceEvent>; + + static constexpr FieldMetadata_Imm kImm{}; + void set_imm(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Imm::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_R0 = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + KvmHvcArm64FtraceEvent>; + + static constexpr FieldMetadata_R0 kR0{}; + void set_r0(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_R0::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_VcpuPc = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + KvmHvcArm64FtraceEvent>; + + static constexpr FieldMetadata_VcpuPc kVcpuPc{}; + void set_vcpu_pc(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_VcpuPc::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class KvmHandleSysRegFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + KvmHandleSysRegFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit KvmHandleSysRegFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit KvmHandleSysRegFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_hsr() const { return at<1>().valid(); } + uint64_t hsr() const { return at<1>().as_uint64(); } +}; + +class KvmHandleSysRegFtraceEvent : public ::protozero::Message { + public: + using Decoder = KvmHandleSysRegFtraceEvent_Decoder; + enum : int32_t { + kHsrFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.KvmHandleSysRegFtraceEvent"; } + + + using FieldMetadata_Hsr = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + KvmHandleSysRegFtraceEvent>; + + static constexpr FieldMetadata_Hsr kHsr{}; + void set_hsr(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Hsr::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class KvmGuestFaultFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + KvmGuestFaultFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit KvmGuestFaultFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit KvmGuestFaultFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_hsr() const { return at<1>().valid(); } + uint64_t hsr() const { return at<1>().as_uint64(); } + bool has_hxfar() const { return at<2>().valid(); } + uint64_t hxfar() const { return at<2>().as_uint64(); } + bool has_ipa() const { return at<3>().valid(); } + uint64_t ipa() const { return at<3>().as_uint64(); } + bool has_vcpu_pc() const { return at<4>().valid(); } + uint64_t vcpu_pc() const { return at<4>().as_uint64(); } +}; + +class KvmGuestFaultFtraceEvent : public ::protozero::Message { + public: + using Decoder = KvmGuestFaultFtraceEvent_Decoder; + enum : int32_t { + kHsrFieldNumber = 1, + kHxfarFieldNumber = 2, + kIpaFieldNumber = 3, + kVcpuPcFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.KvmGuestFaultFtraceEvent"; } + + + using FieldMetadata_Hsr = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + KvmGuestFaultFtraceEvent>; + + static constexpr FieldMetadata_Hsr kHsr{}; + void set_hsr(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Hsr::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Hxfar = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + KvmGuestFaultFtraceEvent>; + + static constexpr FieldMetadata_Hxfar kHxfar{}; + void set_hxfar(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Hxfar::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ipa = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + KvmGuestFaultFtraceEvent>; + + static constexpr FieldMetadata_Ipa kIpa{}; + void set_ipa(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ipa::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_VcpuPc = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + KvmGuestFaultFtraceEvent>; + + static constexpr FieldMetadata_VcpuPc kVcpuPc{}; + void set_vcpu_pc(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_VcpuPc::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class KvmGetTimerMapFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + KvmGetTimerMapFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit KvmGetTimerMapFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit KvmGetTimerMapFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_direct_ptimer() const { return at<1>().valid(); } + int32_t direct_ptimer() const { return at<1>().as_int32(); } + bool has_direct_vtimer() const { return at<2>().valid(); } + int32_t direct_vtimer() const { return at<2>().as_int32(); } + bool has_emul_ptimer() const { return at<3>().valid(); } + int32_t emul_ptimer() const { return at<3>().as_int32(); } + bool has_vcpu_id() const { return at<4>().valid(); } + uint64_t vcpu_id() const { return at<4>().as_uint64(); } +}; + +class KvmGetTimerMapFtraceEvent : public ::protozero::Message { + public: + using Decoder = KvmGetTimerMapFtraceEvent_Decoder; + enum : int32_t { + kDirectPtimerFieldNumber = 1, + kDirectVtimerFieldNumber = 2, + kEmulPtimerFieldNumber = 3, + kVcpuIdFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.KvmGetTimerMapFtraceEvent"; } + + + using FieldMetadata_DirectPtimer = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + KvmGetTimerMapFtraceEvent>; + + static constexpr FieldMetadata_DirectPtimer kDirectPtimer{}; + void set_direct_ptimer(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_DirectPtimer::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DirectVtimer = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + KvmGetTimerMapFtraceEvent>; + + static constexpr FieldMetadata_DirectVtimer kDirectVtimer{}; + void set_direct_vtimer(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_DirectVtimer::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_EmulPtimer = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + KvmGetTimerMapFtraceEvent>; + + static constexpr FieldMetadata_EmulPtimer kEmulPtimer{}; + void set_emul_ptimer(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_EmulPtimer::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_VcpuId = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + KvmGetTimerMapFtraceEvent>; + + static constexpr FieldMetadata_VcpuId kVcpuId{}; + void set_vcpu_id(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_VcpuId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class KvmFpuFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + KvmFpuFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit KvmFpuFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit KvmFpuFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_load() const { return at<1>().valid(); } + uint32_t load() const { return at<1>().as_uint32(); } +}; + +class KvmFpuFtraceEvent : public ::protozero::Message { + public: + using Decoder = KvmFpuFtraceEvent_Decoder; + enum : int32_t { + kLoadFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.KvmFpuFtraceEvent"; } + + + using FieldMetadata_Load = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + KvmFpuFtraceEvent>; + + static constexpr FieldMetadata_Load kLoad{}; + void set_load(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Load::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class KvmExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + KvmExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit KvmExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit KvmExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_esr_ec() const { return at<1>().valid(); } + uint32_t esr_ec() const { return at<1>().as_uint32(); } + bool has_ret() const { return at<2>().valid(); } + int32_t ret() const { return at<2>().as_int32(); } + bool has_vcpu_pc() const { return at<3>().valid(); } + uint64_t vcpu_pc() const { return at<3>().as_uint64(); } +}; + +class KvmExitFtraceEvent : public ::protozero::Message { + public: + using Decoder = KvmExitFtraceEvent_Decoder; + enum : int32_t { + kEsrEcFieldNumber = 1, + kRetFieldNumber = 2, + kVcpuPcFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.KvmExitFtraceEvent"; } + + + using FieldMetadata_EsrEc = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + KvmExitFtraceEvent>; + + static constexpr FieldMetadata_EsrEc kEsrEc{}; + void set_esr_ec(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_EsrEc::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ret = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + KvmExitFtraceEvent>; + + static constexpr FieldMetadata_Ret kRet{}; + void set_ret(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_VcpuPc = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + KvmExitFtraceEvent>; + + static constexpr FieldMetadata_VcpuPc kVcpuPc{}; + void set_vcpu_pc(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_VcpuPc::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class KvmEntryFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + KvmEntryFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit KvmEntryFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit KvmEntryFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_vcpu_pc() const { return at<1>().valid(); } + uint64_t vcpu_pc() const { return at<1>().as_uint64(); } +}; + +class KvmEntryFtraceEvent : public ::protozero::Message { + public: + using Decoder = KvmEntryFtraceEvent_Decoder; + enum : int32_t { + kVcpuPcFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.KvmEntryFtraceEvent"; } + + + using FieldMetadata_VcpuPc = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + KvmEntryFtraceEvent>; + + static constexpr FieldMetadata_VcpuPc kVcpuPc{}; + void set_vcpu_pc(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_VcpuPc::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class KvmArmSetupDebugFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + KvmArmSetupDebugFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit KvmArmSetupDebugFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit KvmArmSetupDebugFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_guest_debug() const { return at<1>().valid(); } + uint32_t guest_debug() const { return at<1>().as_uint32(); } + bool has_vcpu() const { return at<2>().valid(); } + uint64_t vcpu() const { return at<2>().as_uint64(); } +}; + +class KvmArmSetupDebugFtraceEvent : public ::protozero::Message { + public: + using Decoder = KvmArmSetupDebugFtraceEvent_Decoder; + enum : int32_t { + kGuestDebugFieldNumber = 1, + kVcpuFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.KvmArmSetupDebugFtraceEvent"; } + + + using FieldMetadata_GuestDebug = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + KvmArmSetupDebugFtraceEvent>; + + static constexpr FieldMetadata_GuestDebug kGuestDebug{}; + void set_guest_debug(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_GuestDebug::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Vcpu = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + KvmArmSetupDebugFtraceEvent>; + + static constexpr FieldMetadata_Vcpu kVcpu{}; + void set_vcpu(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Vcpu::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class KvmArmSetRegsetFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + KvmArmSetRegsetFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit KvmArmSetRegsetFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit KvmArmSetRegsetFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_len() const { return at<1>().valid(); } + int32_t len() const { return at<1>().as_int32(); } + bool has_name() const { return at<2>().valid(); } + ::protozero::ConstChars name() const { return at<2>().as_string(); } +}; + +class KvmArmSetRegsetFtraceEvent : public ::protozero::Message { + public: + using Decoder = KvmArmSetRegsetFtraceEvent_Decoder; + enum : int32_t { + kLenFieldNumber = 1, + kNameFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.KvmArmSetRegsetFtraceEvent"; } + + + using FieldMetadata_Len = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + KvmArmSetRegsetFtraceEvent>; + + static constexpr FieldMetadata_Len kLen{}; + void set_len(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + KvmArmSetRegsetFtraceEvent>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class KvmArmSetDreg32FtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + KvmArmSetDreg32FtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit KvmArmSetDreg32FtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit KvmArmSetDreg32FtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_name() const { return at<1>().valid(); } + ::protozero::ConstChars name() const { return at<1>().as_string(); } + bool has_value() const { return at<2>().valid(); } + uint32_t value() const { return at<2>().as_uint32(); } +}; + +class KvmArmSetDreg32FtraceEvent : public ::protozero::Message { + public: + using Decoder = KvmArmSetDreg32FtraceEvent_Decoder; + enum : int32_t { + kNameFieldNumber = 1, + kValueFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.KvmArmSetDreg32FtraceEvent"; } + + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + KvmArmSetDreg32FtraceEvent>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Value = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + KvmArmSetDreg32FtraceEvent>; + + static constexpr FieldMetadata_Value kValue{}; + void set_value(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class KvmArmClearDebugFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + KvmArmClearDebugFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit KvmArmClearDebugFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit KvmArmClearDebugFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_guest_debug() const { return at<1>().valid(); } + uint32_t guest_debug() const { return at<1>().as_uint32(); } +}; + +class KvmArmClearDebugFtraceEvent : public ::protozero::Message { + public: + using Decoder = KvmArmClearDebugFtraceEvent_Decoder; + enum : int32_t { + kGuestDebugFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.KvmArmClearDebugFtraceEvent"; } + + + using FieldMetadata_GuestDebug = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + KvmArmClearDebugFtraceEvent>; + + static constexpr FieldMetadata_GuestDebug kGuestDebug{}; + void set_guest_debug(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_GuestDebug::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class KvmAgePageFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + KvmAgePageFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit KvmAgePageFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit KvmAgePageFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_gfn() const { return at<1>().valid(); } + uint64_t gfn() const { return at<1>().as_uint64(); } + bool has_hva() const { return at<2>().valid(); } + uint64_t hva() const { return at<2>().as_uint64(); } + bool has_level() const { return at<3>().valid(); } + uint32_t level() const { return at<3>().as_uint32(); } + bool has_referenced() const { return at<4>().valid(); } + uint32_t referenced() const { return at<4>().as_uint32(); } +}; + +class KvmAgePageFtraceEvent : public ::protozero::Message { + public: + using Decoder = KvmAgePageFtraceEvent_Decoder; + enum : int32_t { + kGfnFieldNumber = 1, + kHvaFieldNumber = 2, + kLevelFieldNumber = 3, + kReferencedFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.KvmAgePageFtraceEvent"; } + + + using FieldMetadata_Gfn = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + KvmAgePageFtraceEvent>; + + static constexpr FieldMetadata_Gfn kGfn{}; + void set_gfn(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Gfn::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Hva = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + KvmAgePageFtraceEvent>; + + static constexpr FieldMetadata_Hva kHva{}; + void set_hva(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Hva::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Level = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + KvmAgePageFtraceEvent>; + + static constexpr FieldMetadata_Level kLevel{}; + void set_level(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Level::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Referenced = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + KvmAgePageFtraceEvent>; + + static constexpr FieldMetadata_Referenced kReferenced{}; + void set_referenced(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Referenced::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class KvmAgeHvaFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + KvmAgeHvaFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit KvmAgeHvaFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit KvmAgeHvaFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_end() const { return at<1>().valid(); } + uint64_t end() const { return at<1>().as_uint64(); } + bool has_start() const { return at<2>().valid(); } + uint64_t start() const { return at<2>().as_uint64(); } +}; + +class KvmAgeHvaFtraceEvent : public ::protozero::Message { + public: + using Decoder = KvmAgeHvaFtraceEvent_Decoder; + enum : int32_t { + kEndFieldNumber = 1, + kStartFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.KvmAgeHvaFtraceEvent"; } + + + using FieldMetadata_End = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + KvmAgeHvaFtraceEvent>; + + static constexpr FieldMetadata_End kEnd{}; + void set_end(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_End::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Start = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + KvmAgeHvaFtraceEvent>; + + static constexpr FieldMetadata_Start kStart{}; + void set_start(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Start::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class KvmAckIrqFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + KvmAckIrqFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit KvmAckIrqFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit KvmAckIrqFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_irqchip() const { return at<1>().valid(); } + uint32_t irqchip() const { return at<1>().as_uint32(); } + bool has_pin() const { return at<2>().valid(); } + uint32_t pin() const { return at<2>().as_uint32(); } +}; + +class KvmAckIrqFtraceEvent : public ::protozero::Message { + public: + using Decoder = KvmAckIrqFtraceEvent_Decoder; + enum : int32_t { + kIrqchipFieldNumber = 1, + kPinFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.KvmAckIrqFtraceEvent"; } + + + using FieldMetadata_Irqchip = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + KvmAckIrqFtraceEvent>; + + static constexpr FieldMetadata_Irqchip kIrqchip{}; + void set_irqchip(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Irqchip::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pin = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + KvmAckIrqFtraceEvent>; + + static constexpr FieldMetadata_Pin kPin{}; + void set_pin(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pin::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class KvmAccessFaultFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + KvmAccessFaultFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit KvmAccessFaultFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit KvmAccessFaultFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_ipa() const { return at<1>().valid(); } + uint64_t ipa() const { return at<1>().as_uint64(); } +}; + +class KvmAccessFaultFtraceEvent : public ::protozero::Message { + public: + using Decoder = KvmAccessFaultFtraceEvent_Decoder; + enum : int32_t { + kIpaFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.KvmAccessFaultFtraceEvent"; } + + + using FieldMetadata_Ipa = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + KvmAccessFaultFtraceEvent>; + + static constexpr FieldMetadata_Ipa kIpa{}; + void set_ipa(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ipa::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class IonBufferDestroyFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + IonBufferDestroyFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit IonBufferDestroyFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit IonBufferDestroyFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_addr() const { return at<1>().valid(); } + uint64_t addr() const { return at<1>().as_uint64(); } + bool has_len() const { return at<2>().valid(); } + uint64_t len() const { return at<2>().as_uint64(); } +}; + +class IonBufferDestroyFtraceEvent : public ::protozero::Message { + public: + using Decoder = IonBufferDestroyFtraceEvent_Decoder; + enum : int32_t { + kAddrFieldNumber = 1, + kLenFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.IonBufferDestroyFtraceEvent"; } + + + using FieldMetadata_Addr = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + IonBufferDestroyFtraceEvent>; + + static constexpr FieldMetadata_Addr kAddr{}; + void set_addr(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Addr::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Len = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + IonBufferDestroyFtraceEvent>; + + static constexpr FieldMetadata_Len kLen{}; + void set_len(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class IonBufferCreateFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + IonBufferCreateFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit IonBufferCreateFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit IonBufferCreateFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_addr() const { return at<1>().valid(); } + uint64_t addr() const { return at<1>().as_uint64(); } + bool has_len() const { return at<2>().valid(); } + uint64_t len() const { return at<2>().as_uint64(); } +}; + +class IonBufferCreateFtraceEvent : public ::protozero::Message { + public: + using Decoder = IonBufferCreateFtraceEvent_Decoder; + enum : int32_t { + kAddrFieldNumber = 1, + kLenFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.IonBufferCreateFtraceEvent"; } + + + using FieldMetadata_Addr = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + IonBufferCreateFtraceEvent>; + + static constexpr FieldMetadata_Addr kAddr{}; + void set_addr(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Addr::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Len = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + IonBufferCreateFtraceEvent>; + + static constexpr FieldMetadata_Len kLen{}; + void set_len(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class IonHeapGrowFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + IonHeapGrowFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit IonHeapGrowFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit IonHeapGrowFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_heap_name() const { return at<1>().valid(); } + ::protozero::ConstChars heap_name() const { return at<1>().as_string(); } + bool has_len() const { return at<2>().valid(); } + uint64_t len() const { return at<2>().as_uint64(); } + bool has_total_allocated() const { return at<3>().valid(); } + int64_t total_allocated() const { return at<3>().as_int64(); } +}; + +class IonHeapGrowFtraceEvent : public ::protozero::Message { + public: + using Decoder = IonHeapGrowFtraceEvent_Decoder; + enum : int32_t { + kHeapNameFieldNumber = 1, + kLenFieldNumber = 2, + kTotalAllocatedFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.IonHeapGrowFtraceEvent"; } + + + using FieldMetadata_HeapName = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + IonHeapGrowFtraceEvent>; + + static constexpr FieldMetadata_HeapName kHeapName{}; + void set_heap_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_HeapName::kFieldId, data, size); + } + void set_heap_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_HeapName::kFieldId, chars.data, chars.size); + } + void set_heap_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_HeapName::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Len = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + IonHeapGrowFtraceEvent>; + + static constexpr FieldMetadata_Len kLen{}; + void set_len(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TotalAllocated = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + IonHeapGrowFtraceEvent>; + + static constexpr FieldMetadata_TotalAllocated kTotalAllocated{}; + void set_total_allocated(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_TotalAllocated::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } +}; + +class IonHeapShrinkFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + IonHeapShrinkFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit IonHeapShrinkFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit IonHeapShrinkFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_heap_name() const { return at<1>().valid(); } + ::protozero::ConstChars heap_name() const { return at<1>().as_string(); } + bool has_len() const { return at<2>().valid(); } + uint64_t len() const { return at<2>().as_uint64(); } + bool has_total_allocated() const { return at<3>().valid(); } + int64_t total_allocated() const { return at<3>().as_int64(); } +}; + +class IonHeapShrinkFtraceEvent : public ::protozero::Message { + public: + using Decoder = IonHeapShrinkFtraceEvent_Decoder; + enum : int32_t { + kHeapNameFieldNumber = 1, + kLenFieldNumber = 2, + kTotalAllocatedFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.IonHeapShrinkFtraceEvent"; } + + + using FieldMetadata_HeapName = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + IonHeapShrinkFtraceEvent>; + + static constexpr FieldMetadata_HeapName kHeapName{}; + void set_heap_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_HeapName::kFieldId, data, size); + } + void set_heap_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_HeapName::kFieldId, chars.data, chars.size); + } + void set_heap_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_HeapName::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Len = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + IonHeapShrinkFtraceEvent>; + + static constexpr FieldMetadata_Len kLen{}; + void set_len(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TotalAllocated = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + IonHeapShrinkFtraceEvent>; + + static constexpr FieldMetadata_TotalAllocated kTotalAllocated{}; + void set_total_allocated(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_TotalAllocated::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } +}; + +class RssStatFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + RssStatFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit RssStatFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit RssStatFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_member() const { return at<1>().valid(); } + int32_t member() const { return at<1>().as_int32(); } + bool has_size() const { return at<2>().valid(); } + int64_t size() const { return at<2>().as_int64(); } + bool has_curr() const { return at<3>().valid(); } + uint32_t curr() const { return at<3>().as_uint32(); } + bool has_mm_id() const { return at<4>().valid(); } + uint32_t mm_id() const { return at<4>().as_uint32(); } +}; + +class RssStatFtraceEvent : public ::protozero::Message { + public: + using Decoder = RssStatFtraceEvent_Decoder; + enum : int32_t { + kMemberFieldNumber = 1, + kSizeFieldNumber = 2, + kCurrFieldNumber = 3, + kMmIdFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.RssStatFtraceEvent"; } + + + using FieldMetadata_Member = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + RssStatFtraceEvent>; + + static constexpr FieldMetadata_Member kMember{}; + void set_member(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Member::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Size = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + RssStatFtraceEvent>; + + static constexpr FieldMetadata_Size kSize{}; + void set_size(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Size::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Curr = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + RssStatFtraceEvent>; + + static constexpr FieldMetadata_Curr kCurr{}; + void set_curr(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Curr::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_MmId = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + RssStatFtraceEvent>; + + static constexpr FieldMetadata_MmId kMmId{}; + void set_mm_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_MmId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class MmPagePcpuDrainFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + MmPagePcpuDrainFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MmPagePcpuDrainFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MmPagePcpuDrainFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_migratetype() const { return at<1>().valid(); } + int32_t migratetype() const { return at<1>().as_int32(); } + bool has_order() const { return at<2>().valid(); } + uint32_t order() const { return at<2>().as_uint32(); } + bool has_page() const { return at<3>().valid(); } + uint64_t page() const { return at<3>().as_uint64(); } + bool has_pfn() const { return at<4>().valid(); } + uint64_t pfn() const { return at<4>().as_uint64(); } +}; + +class MmPagePcpuDrainFtraceEvent : public ::protozero::Message { + public: + using Decoder = MmPagePcpuDrainFtraceEvent_Decoder; + enum : int32_t { + kMigratetypeFieldNumber = 1, + kOrderFieldNumber = 2, + kPageFieldNumber = 3, + kPfnFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MmPagePcpuDrainFtraceEvent"; } + + + using FieldMetadata_Migratetype = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MmPagePcpuDrainFtraceEvent>; + + static constexpr FieldMetadata_Migratetype kMigratetype{}; + void set_migratetype(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Migratetype::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Order = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MmPagePcpuDrainFtraceEvent>; + + static constexpr FieldMetadata_Order kOrder{}; + void set_order(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Order::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Page = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MmPagePcpuDrainFtraceEvent>; + + static constexpr FieldMetadata_Page kPage{}; + void set_page(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Page::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pfn = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MmPagePcpuDrainFtraceEvent>; + + static constexpr FieldMetadata_Pfn kPfn{}; + void set_pfn(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pfn::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class MmPageFreeBatchedFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + MmPageFreeBatchedFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MmPageFreeBatchedFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MmPageFreeBatchedFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_cold() const { return at<1>().valid(); } + int32_t cold() const { return at<1>().as_int32(); } + bool has_page() const { return at<2>().valid(); } + uint64_t page() const { return at<2>().as_uint64(); } + bool has_pfn() const { return at<3>().valid(); } + uint64_t pfn() const { return at<3>().as_uint64(); } +}; + +class MmPageFreeBatchedFtraceEvent : public ::protozero::Message { + public: + using Decoder = MmPageFreeBatchedFtraceEvent_Decoder; + enum : int32_t { + kColdFieldNumber = 1, + kPageFieldNumber = 2, + kPfnFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MmPageFreeBatchedFtraceEvent"; } + + + using FieldMetadata_Cold = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MmPageFreeBatchedFtraceEvent>; + + static constexpr FieldMetadata_Cold kCold{}; + void set_cold(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Cold::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Page = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MmPageFreeBatchedFtraceEvent>; + + static constexpr FieldMetadata_Page kPage{}; + void set_page(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Page::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pfn = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MmPageFreeBatchedFtraceEvent>; + + static constexpr FieldMetadata_Pfn kPfn{}; + void set_pfn(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pfn::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class MmPageFreeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + MmPageFreeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MmPageFreeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MmPageFreeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_order() const { return at<1>().valid(); } + uint32_t order() const { return at<1>().as_uint32(); } + bool has_page() const { return at<2>().valid(); } + uint64_t page() const { return at<2>().as_uint64(); } + bool has_pfn() const { return at<3>().valid(); } + uint64_t pfn() const { return at<3>().as_uint64(); } +}; + +class MmPageFreeFtraceEvent : public ::protozero::Message { + public: + using Decoder = MmPageFreeFtraceEvent_Decoder; + enum : int32_t { + kOrderFieldNumber = 1, + kPageFieldNumber = 2, + kPfnFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MmPageFreeFtraceEvent"; } + + + using FieldMetadata_Order = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MmPageFreeFtraceEvent>; + + static constexpr FieldMetadata_Order kOrder{}; + void set_order(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Order::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Page = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MmPageFreeFtraceEvent>; + + static constexpr FieldMetadata_Page kPage{}; + void set_page(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Page::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pfn = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MmPageFreeFtraceEvent>; + + static constexpr FieldMetadata_Pfn kPfn{}; + void set_pfn(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pfn::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class MmPageAllocZoneLockedFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + MmPageAllocZoneLockedFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MmPageAllocZoneLockedFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MmPageAllocZoneLockedFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_migratetype() const { return at<1>().valid(); } + int32_t migratetype() const { return at<1>().as_int32(); } + bool has_order() const { return at<2>().valid(); } + uint32_t order() const { return at<2>().as_uint32(); } + bool has_page() const { return at<3>().valid(); } + uint64_t page() const { return at<3>().as_uint64(); } + bool has_pfn() const { return at<4>().valid(); } + uint64_t pfn() const { return at<4>().as_uint64(); } +}; + +class MmPageAllocZoneLockedFtraceEvent : public ::protozero::Message { + public: + using Decoder = MmPageAllocZoneLockedFtraceEvent_Decoder; + enum : int32_t { + kMigratetypeFieldNumber = 1, + kOrderFieldNumber = 2, + kPageFieldNumber = 3, + kPfnFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MmPageAllocZoneLockedFtraceEvent"; } + + + using FieldMetadata_Migratetype = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MmPageAllocZoneLockedFtraceEvent>; + + static constexpr FieldMetadata_Migratetype kMigratetype{}; + void set_migratetype(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Migratetype::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Order = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MmPageAllocZoneLockedFtraceEvent>; + + static constexpr FieldMetadata_Order kOrder{}; + void set_order(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Order::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Page = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MmPageAllocZoneLockedFtraceEvent>; + + static constexpr FieldMetadata_Page kPage{}; + void set_page(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Page::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pfn = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MmPageAllocZoneLockedFtraceEvent>; + + static constexpr FieldMetadata_Pfn kPfn{}; + void set_pfn(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pfn::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class MmPageAllocExtfragFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + MmPageAllocExtfragFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MmPageAllocExtfragFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MmPageAllocExtfragFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_alloc_migratetype() const { return at<1>().valid(); } + int32_t alloc_migratetype() const { return at<1>().as_int32(); } + bool has_alloc_order() const { return at<2>().valid(); } + int32_t alloc_order() const { return at<2>().as_int32(); } + bool has_fallback_migratetype() const { return at<3>().valid(); } + int32_t fallback_migratetype() const { return at<3>().as_int32(); } + bool has_fallback_order() const { return at<4>().valid(); } + int32_t fallback_order() const { return at<4>().as_int32(); } + bool has_page() const { return at<5>().valid(); } + uint64_t page() const { return at<5>().as_uint64(); } + bool has_change_ownership() const { return at<6>().valid(); } + int32_t change_ownership() const { return at<6>().as_int32(); } + bool has_pfn() const { return at<7>().valid(); } + uint64_t pfn() const { return at<7>().as_uint64(); } +}; + +class MmPageAllocExtfragFtraceEvent : public ::protozero::Message { + public: + using Decoder = MmPageAllocExtfragFtraceEvent_Decoder; + enum : int32_t { + kAllocMigratetypeFieldNumber = 1, + kAllocOrderFieldNumber = 2, + kFallbackMigratetypeFieldNumber = 3, + kFallbackOrderFieldNumber = 4, + kPageFieldNumber = 5, + kChangeOwnershipFieldNumber = 6, + kPfnFieldNumber = 7, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MmPageAllocExtfragFtraceEvent"; } + + + using FieldMetadata_AllocMigratetype = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MmPageAllocExtfragFtraceEvent>; + + static constexpr FieldMetadata_AllocMigratetype kAllocMigratetype{}; + void set_alloc_migratetype(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_AllocMigratetype::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_AllocOrder = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MmPageAllocExtfragFtraceEvent>; + + static constexpr FieldMetadata_AllocOrder kAllocOrder{}; + void set_alloc_order(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_AllocOrder::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FallbackMigratetype = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MmPageAllocExtfragFtraceEvent>; + + static constexpr FieldMetadata_FallbackMigratetype kFallbackMigratetype{}; + void set_fallback_migratetype(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_FallbackMigratetype::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FallbackOrder = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MmPageAllocExtfragFtraceEvent>; + + static constexpr FieldMetadata_FallbackOrder kFallbackOrder{}; + void set_fallback_order(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_FallbackOrder::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Page = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MmPageAllocExtfragFtraceEvent>; + + static constexpr FieldMetadata_Page kPage{}; + void set_page(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Page::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ChangeOwnership = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MmPageAllocExtfragFtraceEvent>; + + static constexpr FieldMetadata_ChangeOwnership kChangeOwnership{}; + void set_change_ownership(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ChangeOwnership::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pfn = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MmPageAllocExtfragFtraceEvent>; + + static constexpr FieldMetadata_Pfn kPfn{}; + void set_pfn(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pfn::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class MmPageAllocFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + MmPageAllocFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MmPageAllocFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MmPageAllocFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_gfp_flags() const { return at<1>().valid(); } + uint32_t gfp_flags() const { return at<1>().as_uint32(); } + bool has_migratetype() const { return at<2>().valid(); } + int32_t migratetype() const { return at<2>().as_int32(); } + bool has_order() const { return at<3>().valid(); } + uint32_t order() const { return at<3>().as_uint32(); } + bool has_page() const { return at<4>().valid(); } + uint64_t page() const { return at<4>().as_uint64(); } + bool has_pfn() const { return at<5>().valid(); } + uint64_t pfn() const { return at<5>().as_uint64(); } +}; + +class MmPageAllocFtraceEvent : public ::protozero::Message { + public: + using Decoder = MmPageAllocFtraceEvent_Decoder; + enum : int32_t { + kGfpFlagsFieldNumber = 1, + kMigratetypeFieldNumber = 2, + kOrderFieldNumber = 3, + kPageFieldNumber = 4, + kPfnFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MmPageAllocFtraceEvent"; } + + + using FieldMetadata_GfpFlags = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MmPageAllocFtraceEvent>; + + static constexpr FieldMetadata_GfpFlags kGfpFlags{}; + void set_gfp_flags(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_GfpFlags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Migratetype = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MmPageAllocFtraceEvent>; + + static constexpr FieldMetadata_Migratetype kMigratetype{}; + void set_migratetype(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Migratetype::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Order = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MmPageAllocFtraceEvent>; + + static constexpr FieldMetadata_Order kOrder{}; + void set_order(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Order::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Page = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MmPageAllocFtraceEvent>; + + static constexpr FieldMetadata_Page kPage{}; + void set_page(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Page::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pfn = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MmPageAllocFtraceEvent>; + + static constexpr FieldMetadata_Pfn kPfn{}; + void set_pfn(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pfn::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class MigrateRetryFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + MigrateRetryFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MigrateRetryFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MigrateRetryFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_tries() const { return at<1>().valid(); } + int32_t tries() const { return at<1>().as_int32(); } +}; + +class MigrateRetryFtraceEvent : public ::protozero::Message { + public: + using Decoder = MigrateRetryFtraceEvent_Decoder; + enum : int32_t { + kTriesFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MigrateRetryFtraceEvent"; } + + + using FieldMetadata_Tries = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MigrateRetryFtraceEvent>; + + static constexpr FieldMetadata_Tries kTries{}; + void set_tries(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Tries::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class MigratePagesStartFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + MigratePagesStartFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MigratePagesStartFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MigratePagesStartFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_mode() const { return at<1>().valid(); } + int32_t mode() const { return at<1>().as_int32(); } +}; + +class MigratePagesStartFtraceEvent : public ::protozero::Message { + public: + using Decoder = MigratePagesStartFtraceEvent_Decoder; + enum : int32_t { + kModeFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MigratePagesStartFtraceEvent"; } + + + using FieldMetadata_Mode = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MigratePagesStartFtraceEvent>; + + static constexpr FieldMetadata_Mode kMode{}; + void set_mode(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Mode::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class MigratePagesEndFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + MigratePagesEndFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MigratePagesEndFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MigratePagesEndFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_mode() const { return at<1>().valid(); } + int32_t mode() const { return at<1>().as_int32(); } +}; + +class MigratePagesEndFtraceEvent : public ::protozero::Message { + public: + using Decoder = MigratePagesEndFtraceEvent_Decoder; + enum : int32_t { + kModeFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MigratePagesEndFtraceEvent"; } + + + using FieldMetadata_Mode = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MigratePagesEndFtraceEvent>; + + static constexpr FieldMetadata_Mode kMode{}; + void set_mode(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Mode::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class KmemCacheFreeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + KmemCacheFreeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit KmemCacheFreeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit KmemCacheFreeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_call_site() const { return at<1>().valid(); } + uint64_t call_site() const { return at<1>().as_uint64(); } + bool has_ptr() const { return at<2>().valid(); } + uint64_t ptr() const { return at<2>().as_uint64(); } +}; + +class KmemCacheFreeFtraceEvent : public ::protozero::Message { + public: + using Decoder = KmemCacheFreeFtraceEvent_Decoder; + enum : int32_t { + kCallSiteFieldNumber = 1, + kPtrFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.KmemCacheFreeFtraceEvent"; } + + + using FieldMetadata_CallSite = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + KmemCacheFreeFtraceEvent>; + + static constexpr FieldMetadata_CallSite kCallSite{}; + void set_call_site(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_CallSite::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ptr = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + KmemCacheFreeFtraceEvent>; + + static constexpr FieldMetadata_Ptr kPtr{}; + void set_ptr(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ptr::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class KmemCacheAllocNodeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + KmemCacheAllocNodeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit KmemCacheAllocNodeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit KmemCacheAllocNodeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_bytes_alloc() const { return at<1>().valid(); } + uint64_t bytes_alloc() const { return at<1>().as_uint64(); } + bool has_bytes_req() const { return at<2>().valid(); } + uint64_t bytes_req() const { return at<2>().as_uint64(); } + bool has_call_site() const { return at<3>().valid(); } + uint64_t call_site() const { return at<3>().as_uint64(); } + bool has_gfp_flags() const { return at<4>().valid(); } + uint32_t gfp_flags() const { return at<4>().as_uint32(); } + bool has_node() const { return at<5>().valid(); } + int32_t node() const { return at<5>().as_int32(); } + bool has_ptr() const { return at<6>().valid(); } + uint64_t ptr() const { return at<6>().as_uint64(); } +}; + +class KmemCacheAllocNodeFtraceEvent : public ::protozero::Message { + public: + using Decoder = KmemCacheAllocNodeFtraceEvent_Decoder; + enum : int32_t { + kBytesAllocFieldNumber = 1, + kBytesReqFieldNumber = 2, + kCallSiteFieldNumber = 3, + kGfpFlagsFieldNumber = 4, + kNodeFieldNumber = 5, + kPtrFieldNumber = 6, + }; + static constexpr const char* GetName() { return ".perfetto.protos.KmemCacheAllocNodeFtraceEvent"; } + + + using FieldMetadata_BytesAlloc = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + KmemCacheAllocNodeFtraceEvent>; + + static constexpr FieldMetadata_BytesAlloc kBytesAlloc{}; + void set_bytes_alloc(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_BytesAlloc::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_BytesReq = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + KmemCacheAllocNodeFtraceEvent>; + + static constexpr FieldMetadata_BytesReq kBytesReq{}; + void set_bytes_req(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_BytesReq::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CallSite = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + KmemCacheAllocNodeFtraceEvent>; + + static constexpr FieldMetadata_CallSite kCallSite{}; + void set_call_site(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_CallSite::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_GfpFlags = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + KmemCacheAllocNodeFtraceEvent>; + + static constexpr FieldMetadata_GfpFlags kGfpFlags{}; + void set_gfp_flags(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_GfpFlags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Node = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + KmemCacheAllocNodeFtraceEvent>; + + static constexpr FieldMetadata_Node kNode{}; + void set_node(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Node::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ptr = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + KmemCacheAllocNodeFtraceEvent>; + + static constexpr FieldMetadata_Ptr kPtr{}; + void set_ptr(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ptr::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class KmemCacheAllocFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + KmemCacheAllocFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit KmemCacheAllocFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit KmemCacheAllocFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_bytes_alloc() const { return at<1>().valid(); } + uint64_t bytes_alloc() const { return at<1>().as_uint64(); } + bool has_bytes_req() const { return at<2>().valid(); } + uint64_t bytes_req() const { return at<2>().as_uint64(); } + bool has_call_site() const { return at<3>().valid(); } + uint64_t call_site() const { return at<3>().as_uint64(); } + bool has_gfp_flags() const { return at<4>().valid(); } + uint32_t gfp_flags() const { return at<4>().as_uint32(); } + bool has_ptr() const { return at<5>().valid(); } + uint64_t ptr() const { return at<5>().as_uint64(); } +}; + +class KmemCacheAllocFtraceEvent : public ::protozero::Message { + public: + using Decoder = KmemCacheAllocFtraceEvent_Decoder; + enum : int32_t { + kBytesAllocFieldNumber = 1, + kBytesReqFieldNumber = 2, + kCallSiteFieldNumber = 3, + kGfpFlagsFieldNumber = 4, + kPtrFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.KmemCacheAllocFtraceEvent"; } + + + using FieldMetadata_BytesAlloc = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + KmemCacheAllocFtraceEvent>; + + static constexpr FieldMetadata_BytesAlloc kBytesAlloc{}; + void set_bytes_alloc(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_BytesAlloc::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_BytesReq = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + KmemCacheAllocFtraceEvent>; + + static constexpr FieldMetadata_BytesReq kBytesReq{}; + void set_bytes_req(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_BytesReq::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CallSite = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + KmemCacheAllocFtraceEvent>; + + static constexpr FieldMetadata_CallSite kCallSite{}; + void set_call_site(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_CallSite::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_GfpFlags = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + KmemCacheAllocFtraceEvent>; + + static constexpr FieldMetadata_GfpFlags kGfpFlags{}; + void set_gfp_flags(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_GfpFlags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ptr = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + KmemCacheAllocFtraceEvent>; + + static constexpr FieldMetadata_Ptr kPtr{}; + void set_ptr(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ptr::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class KmallocNodeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + KmallocNodeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit KmallocNodeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit KmallocNodeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_bytes_alloc() const { return at<1>().valid(); } + uint64_t bytes_alloc() const { return at<1>().as_uint64(); } + bool has_bytes_req() const { return at<2>().valid(); } + uint64_t bytes_req() const { return at<2>().as_uint64(); } + bool has_call_site() const { return at<3>().valid(); } + uint64_t call_site() const { return at<3>().as_uint64(); } + bool has_gfp_flags() const { return at<4>().valid(); } + uint32_t gfp_flags() const { return at<4>().as_uint32(); } + bool has_node() const { return at<5>().valid(); } + int32_t node() const { return at<5>().as_int32(); } + bool has_ptr() const { return at<6>().valid(); } + uint64_t ptr() const { return at<6>().as_uint64(); } +}; + +class KmallocNodeFtraceEvent : public ::protozero::Message { + public: + using Decoder = KmallocNodeFtraceEvent_Decoder; + enum : int32_t { + kBytesAllocFieldNumber = 1, + kBytesReqFieldNumber = 2, + kCallSiteFieldNumber = 3, + kGfpFlagsFieldNumber = 4, + kNodeFieldNumber = 5, + kPtrFieldNumber = 6, + }; + static constexpr const char* GetName() { return ".perfetto.protos.KmallocNodeFtraceEvent"; } + + + using FieldMetadata_BytesAlloc = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + KmallocNodeFtraceEvent>; + + static constexpr FieldMetadata_BytesAlloc kBytesAlloc{}; + void set_bytes_alloc(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_BytesAlloc::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_BytesReq = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + KmallocNodeFtraceEvent>; + + static constexpr FieldMetadata_BytesReq kBytesReq{}; + void set_bytes_req(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_BytesReq::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CallSite = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + KmallocNodeFtraceEvent>; + + static constexpr FieldMetadata_CallSite kCallSite{}; + void set_call_site(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_CallSite::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_GfpFlags = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + KmallocNodeFtraceEvent>; + + static constexpr FieldMetadata_GfpFlags kGfpFlags{}; + void set_gfp_flags(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_GfpFlags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Node = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + KmallocNodeFtraceEvent>; + + static constexpr FieldMetadata_Node kNode{}; + void set_node(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Node::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ptr = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + KmallocNodeFtraceEvent>; + + static constexpr FieldMetadata_Ptr kPtr{}; + void set_ptr(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ptr::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class KmallocFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + KmallocFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit KmallocFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit KmallocFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_bytes_alloc() const { return at<1>().valid(); } + uint64_t bytes_alloc() const { return at<1>().as_uint64(); } + bool has_bytes_req() const { return at<2>().valid(); } + uint64_t bytes_req() const { return at<2>().as_uint64(); } + bool has_call_site() const { return at<3>().valid(); } + uint64_t call_site() const { return at<3>().as_uint64(); } + bool has_gfp_flags() const { return at<4>().valid(); } + uint32_t gfp_flags() const { return at<4>().as_uint32(); } + bool has_ptr() const { return at<5>().valid(); } + uint64_t ptr() const { return at<5>().as_uint64(); } +}; + +class KmallocFtraceEvent : public ::protozero::Message { + public: + using Decoder = KmallocFtraceEvent_Decoder; + enum : int32_t { + kBytesAllocFieldNumber = 1, + kBytesReqFieldNumber = 2, + kCallSiteFieldNumber = 3, + kGfpFlagsFieldNumber = 4, + kPtrFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.KmallocFtraceEvent"; } + + + using FieldMetadata_BytesAlloc = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + KmallocFtraceEvent>; + + static constexpr FieldMetadata_BytesAlloc kBytesAlloc{}; + void set_bytes_alloc(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_BytesAlloc::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_BytesReq = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + KmallocFtraceEvent>; + + static constexpr FieldMetadata_BytesReq kBytesReq{}; + void set_bytes_req(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_BytesReq::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CallSite = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + KmallocFtraceEvent>; + + static constexpr FieldMetadata_CallSite kCallSite{}; + void set_call_site(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_CallSite::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_GfpFlags = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + KmallocFtraceEvent>; + + static constexpr FieldMetadata_GfpFlags kGfpFlags{}; + void set_gfp_flags(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_GfpFlags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ptr = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + KmallocFtraceEvent>; + + static constexpr FieldMetadata_Ptr kPtr{}; + void set_ptr(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ptr::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class KfreeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + KfreeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit KfreeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit KfreeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_call_site() const { return at<1>().valid(); } + uint64_t call_site() const { return at<1>().as_uint64(); } + bool has_ptr() const { return at<2>().valid(); } + uint64_t ptr() const { return at<2>().as_uint64(); } +}; + +class KfreeFtraceEvent : public ::protozero::Message { + public: + using Decoder = KfreeFtraceEvent_Decoder; + enum : int32_t { + kCallSiteFieldNumber = 1, + kPtrFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.KfreeFtraceEvent"; } + + + using FieldMetadata_CallSite = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + KfreeFtraceEvent>; + + static constexpr FieldMetadata_CallSite kCallSite{}; + void set_call_site(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_CallSite::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ptr = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + KfreeFtraceEvent>; + + static constexpr FieldMetadata_Ptr kPtr{}; + void set_ptr(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ptr::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class IonSecureCmaShrinkPoolStartFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + IonSecureCmaShrinkPoolStartFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit IonSecureCmaShrinkPoolStartFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit IonSecureCmaShrinkPoolStartFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_drained_size() const { return at<1>().valid(); } + uint64_t drained_size() const { return at<1>().as_uint64(); } + bool has_skipped_size() const { return at<2>().valid(); } + uint64_t skipped_size() const { return at<2>().as_uint64(); } +}; + +class IonSecureCmaShrinkPoolStartFtraceEvent : public ::protozero::Message { + public: + using Decoder = IonSecureCmaShrinkPoolStartFtraceEvent_Decoder; + enum : int32_t { + kDrainedSizeFieldNumber = 1, + kSkippedSizeFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.IonSecureCmaShrinkPoolStartFtraceEvent"; } + + + using FieldMetadata_DrainedSize = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + IonSecureCmaShrinkPoolStartFtraceEvent>; + + static constexpr FieldMetadata_DrainedSize kDrainedSize{}; + void set_drained_size(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_DrainedSize::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SkippedSize = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + IonSecureCmaShrinkPoolStartFtraceEvent>; + + static constexpr FieldMetadata_SkippedSize kSkippedSize{}; + void set_skipped_size(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_SkippedSize::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class IonSecureCmaShrinkPoolEndFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + IonSecureCmaShrinkPoolEndFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit IonSecureCmaShrinkPoolEndFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit IonSecureCmaShrinkPoolEndFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_drained_size() const { return at<1>().valid(); } + uint64_t drained_size() const { return at<1>().as_uint64(); } + bool has_skipped_size() const { return at<2>().valid(); } + uint64_t skipped_size() const { return at<2>().as_uint64(); } +}; + +class IonSecureCmaShrinkPoolEndFtraceEvent : public ::protozero::Message { + public: + using Decoder = IonSecureCmaShrinkPoolEndFtraceEvent_Decoder; + enum : int32_t { + kDrainedSizeFieldNumber = 1, + kSkippedSizeFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.IonSecureCmaShrinkPoolEndFtraceEvent"; } + + + using FieldMetadata_DrainedSize = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + IonSecureCmaShrinkPoolEndFtraceEvent>; + + static constexpr FieldMetadata_DrainedSize kDrainedSize{}; + void set_drained_size(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_DrainedSize::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SkippedSize = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + IonSecureCmaShrinkPoolEndFtraceEvent>; + + static constexpr FieldMetadata_SkippedSize kSkippedSize{}; + void set_skipped_size(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_SkippedSize::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class IonSecureCmaAllocateStartFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + IonSecureCmaAllocateStartFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit IonSecureCmaAllocateStartFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit IonSecureCmaAllocateStartFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_align() const { return at<1>().valid(); } + uint64_t align() const { return at<1>().as_uint64(); } + bool has_flags() const { return at<2>().valid(); } + uint64_t flags() const { return at<2>().as_uint64(); } + bool has_heap_name() const { return at<3>().valid(); } + ::protozero::ConstChars heap_name() const { return at<3>().as_string(); } + bool has_len() const { return at<4>().valid(); } + uint64_t len() const { return at<4>().as_uint64(); } +}; + +class IonSecureCmaAllocateStartFtraceEvent : public ::protozero::Message { + public: + using Decoder = IonSecureCmaAllocateStartFtraceEvent_Decoder; + enum : int32_t { + kAlignFieldNumber = 1, + kFlagsFieldNumber = 2, + kHeapNameFieldNumber = 3, + kLenFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.IonSecureCmaAllocateStartFtraceEvent"; } + + + using FieldMetadata_Align = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + IonSecureCmaAllocateStartFtraceEvent>; + + static constexpr FieldMetadata_Align kAlign{}; + void set_align(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Align::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Flags = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + IonSecureCmaAllocateStartFtraceEvent>; + + static constexpr FieldMetadata_Flags kFlags{}; + void set_flags(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_HeapName = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + IonSecureCmaAllocateStartFtraceEvent>; + + static constexpr FieldMetadata_HeapName kHeapName{}; + void set_heap_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_HeapName::kFieldId, data, size); + } + void set_heap_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_HeapName::kFieldId, chars.data, chars.size); + } + void set_heap_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_HeapName::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Len = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + IonSecureCmaAllocateStartFtraceEvent>; + + static constexpr FieldMetadata_Len kLen{}; + void set_len(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class IonSecureCmaAllocateEndFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + IonSecureCmaAllocateEndFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit IonSecureCmaAllocateEndFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit IonSecureCmaAllocateEndFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_align() const { return at<1>().valid(); } + uint64_t align() const { return at<1>().as_uint64(); } + bool has_flags() const { return at<2>().valid(); } + uint64_t flags() const { return at<2>().as_uint64(); } + bool has_heap_name() const { return at<3>().valid(); } + ::protozero::ConstChars heap_name() const { return at<3>().as_string(); } + bool has_len() const { return at<4>().valid(); } + uint64_t len() const { return at<4>().as_uint64(); } +}; + +class IonSecureCmaAllocateEndFtraceEvent : public ::protozero::Message { + public: + using Decoder = IonSecureCmaAllocateEndFtraceEvent_Decoder; + enum : int32_t { + kAlignFieldNumber = 1, + kFlagsFieldNumber = 2, + kHeapNameFieldNumber = 3, + kLenFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.IonSecureCmaAllocateEndFtraceEvent"; } + + + using FieldMetadata_Align = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + IonSecureCmaAllocateEndFtraceEvent>; + + static constexpr FieldMetadata_Align kAlign{}; + void set_align(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Align::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Flags = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + IonSecureCmaAllocateEndFtraceEvent>; + + static constexpr FieldMetadata_Flags kFlags{}; + void set_flags(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_HeapName = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + IonSecureCmaAllocateEndFtraceEvent>; + + static constexpr FieldMetadata_HeapName kHeapName{}; + void set_heap_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_HeapName::kFieldId, data, size); + } + void set_heap_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_HeapName::kFieldId, chars.data, chars.size); + } + void set_heap_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_HeapName::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Len = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + IonSecureCmaAllocateEndFtraceEvent>; + + static constexpr FieldMetadata_Len kLen{}; + void set_len(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class IonSecureCmaAddToPoolStartFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + IonSecureCmaAddToPoolStartFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit IonSecureCmaAddToPoolStartFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit IonSecureCmaAddToPoolStartFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_is_prefetch() const { return at<1>().valid(); } + uint32_t is_prefetch() const { return at<1>().as_uint32(); } + bool has_len() const { return at<2>().valid(); } + uint64_t len() const { return at<2>().as_uint64(); } + bool has_pool_total() const { return at<3>().valid(); } + int32_t pool_total() const { return at<3>().as_int32(); } +}; + +class IonSecureCmaAddToPoolStartFtraceEvent : public ::protozero::Message { + public: + using Decoder = IonSecureCmaAddToPoolStartFtraceEvent_Decoder; + enum : int32_t { + kIsPrefetchFieldNumber = 1, + kLenFieldNumber = 2, + kPoolTotalFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.IonSecureCmaAddToPoolStartFtraceEvent"; } + + + using FieldMetadata_IsPrefetch = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + IonSecureCmaAddToPoolStartFtraceEvent>; + + static constexpr FieldMetadata_IsPrefetch kIsPrefetch{}; + void set_is_prefetch(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_IsPrefetch::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Len = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + IonSecureCmaAddToPoolStartFtraceEvent>; + + static constexpr FieldMetadata_Len kLen{}; + void set_len(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PoolTotal = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + IonSecureCmaAddToPoolStartFtraceEvent>; + + static constexpr FieldMetadata_PoolTotal kPoolTotal{}; + void set_pool_total(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_PoolTotal::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class IonSecureCmaAddToPoolEndFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + IonSecureCmaAddToPoolEndFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit IonSecureCmaAddToPoolEndFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit IonSecureCmaAddToPoolEndFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_is_prefetch() const { return at<1>().valid(); } + uint32_t is_prefetch() const { return at<1>().as_uint32(); } + bool has_len() const { return at<2>().valid(); } + uint64_t len() const { return at<2>().as_uint64(); } + bool has_pool_total() const { return at<3>().valid(); } + int32_t pool_total() const { return at<3>().as_int32(); } +}; + +class IonSecureCmaAddToPoolEndFtraceEvent : public ::protozero::Message { + public: + using Decoder = IonSecureCmaAddToPoolEndFtraceEvent_Decoder; + enum : int32_t { + kIsPrefetchFieldNumber = 1, + kLenFieldNumber = 2, + kPoolTotalFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.IonSecureCmaAddToPoolEndFtraceEvent"; } + + + using FieldMetadata_IsPrefetch = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + IonSecureCmaAddToPoolEndFtraceEvent>; + + static constexpr FieldMetadata_IsPrefetch kIsPrefetch{}; + void set_is_prefetch(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_IsPrefetch::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Len = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + IonSecureCmaAddToPoolEndFtraceEvent>; + + static constexpr FieldMetadata_Len kLen{}; + void set_len(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PoolTotal = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + IonSecureCmaAddToPoolEndFtraceEvent>; + + static constexpr FieldMetadata_PoolTotal kPoolTotal{}; + void set_pool_total(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_PoolTotal::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class IonPrefetchingFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + IonPrefetchingFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit IonPrefetchingFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit IonPrefetchingFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_len() const { return at<1>().valid(); } + uint64_t len() const { return at<1>().as_uint64(); } +}; + +class IonPrefetchingFtraceEvent : public ::protozero::Message { + public: + using Decoder = IonPrefetchingFtraceEvent_Decoder; + enum : int32_t { + kLenFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.IonPrefetchingFtraceEvent"; } + + + using FieldMetadata_Len = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + IonPrefetchingFtraceEvent>; + + static constexpr FieldMetadata_Len kLen{}; + void set_len(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class IonCpSecureBufferStartFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + IonCpSecureBufferStartFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit IonCpSecureBufferStartFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit IonCpSecureBufferStartFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_align() const { return at<1>().valid(); } + uint64_t align() const { return at<1>().as_uint64(); } + bool has_flags() const { return at<2>().valid(); } + uint64_t flags() const { return at<2>().as_uint64(); } + bool has_heap_name() const { return at<3>().valid(); } + ::protozero::ConstChars heap_name() const { return at<3>().as_string(); } + bool has_len() const { return at<4>().valid(); } + uint64_t len() const { return at<4>().as_uint64(); } +}; + +class IonCpSecureBufferStartFtraceEvent : public ::protozero::Message { + public: + using Decoder = IonCpSecureBufferStartFtraceEvent_Decoder; + enum : int32_t { + kAlignFieldNumber = 1, + kFlagsFieldNumber = 2, + kHeapNameFieldNumber = 3, + kLenFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.IonCpSecureBufferStartFtraceEvent"; } + + + using FieldMetadata_Align = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + IonCpSecureBufferStartFtraceEvent>; + + static constexpr FieldMetadata_Align kAlign{}; + void set_align(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Align::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Flags = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + IonCpSecureBufferStartFtraceEvent>; + + static constexpr FieldMetadata_Flags kFlags{}; + void set_flags(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_HeapName = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + IonCpSecureBufferStartFtraceEvent>; + + static constexpr FieldMetadata_HeapName kHeapName{}; + void set_heap_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_HeapName::kFieldId, data, size); + } + void set_heap_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_HeapName::kFieldId, chars.data, chars.size); + } + void set_heap_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_HeapName::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Len = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + IonCpSecureBufferStartFtraceEvent>; + + static constexpr FieldMetadata_Len kLen{}; + void set_len(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class IonCpSecureBufferEndFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + IonCpSecureBufferEndFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit IonCpSecureBufferEndFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit IonCpSecureBufferEndFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_align() const { return at<1>().valid(); } + uint64_t align() const { return at<1>().as_uint64(); } + bool has_flags() const { return at<2>().valid(); } + uint64_t flags() const { return at<2>().as_uint64(); } + bool has_heap_name() const { return at<3>().valid(); } + ::protozero::ConstChars heap_name() const { return at<3>().as_string(); } + bool has_len() const { return at<4>().valid(); } + uint64_t len() const { return at<4>().as_uint64(); } +}; + +class IonCpSecureBufferEndFtraceEvent : public ::protozero::Message { + public: + using Decoder = IonCpSecureBufferEndFtraceEvent_Decoder; + enum : int32_t { + kAlignFieldNumber = 1, + kFlagsFieldNumber = 2, + kHeapNameFieldNumber = 3, + kLenFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.IonCpSecureBufferEndFtraceEvent"; } + + + using FieldMetadata_Align = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + IonCpSecureBufferEndFtraceEvent>; + + static constexpr FieldMetadata_Align kAlign{}; + void set_align(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Align::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Flags = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + IonCpSecureBufferEndFtraceEvent>; + + static constexpr FieldMetadata_Flags kFlags{}; + void set_flags(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_HeapName = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + IonCpSecureBufferEndFtraceEvent>; + + static constexpr FieldMetadata_HeapName kHeapName{}; + void set_heap_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_HeapName::kFieldId, data, size); + } + void set_heap_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_HeapName::kFieldId, chars.data, chars.size); + } + void set_heap_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_HeapName::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Len = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + IonCpSecureBufferEndFtraceEvent>; + + static constexpr FieldMetadata_Len kLen{}; + void set_len(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class IonCpAllocRetryFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + IonCpAllocRetryFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit IonCpAllocRetryFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit IonCpAllocRetryFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_tries() const { return at<1>().valid(); } + int32_t tries() const { return at<1>().as_int32(); } +}; + +class IonCpAllocRetryFtraceEvent : public ::protozero::Message { + public: + using Decoder = IonCpAllocRetryFtraceEvent_Decoder; + enum : int32_t { + kTriesFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.IonCpAllocRetryFtraceEvent"; } + + + using FieldMetadata_Tries = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + IonCpAllocRetryFtraceEvent>; + + static constexpr FieldMetadata_Tries kTries{}; + void set_tries(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Tries::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class IonAllocBufferStartFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + IonAllocBufferStartFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit IonAllocBufferStartFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit IonAllocBufferStartFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_client_name() const { return at<1>().valid(); } + ::protozero::ConstChars client_name() const { return at<1>().as_string(); } + bool has_flags() const { return at<2>().valid(); } + uint32_t flags() const { return at<2>().as_uint32(); } + bool has_heap_name() const { return at<3>().valid(); } + ::protozero::ConstChars heap_name() const { return at<3>().as_string(); } + bool has_len() const { return at<4>().valid(); } + uint64_t len() const { return at<4>().as_uint64(); } + bool has_mask() const { return at<5>().valid(); } + uint32_t mask() const { return at<5>().as_uint32(); } +}; + +class IonAllocBufferStartFtraceEvent : public ::protozero::Message { + public: + using Decoder = IonAllocBufferStartFtraceEvent_Decoder; + enum : int32_t { + kClientNameFieldNumber = 1, + kFlagsFieldNumber = 2, + kHeapNameFieldNumber = 3, + kLenFieldNumber = 4, + kMaskFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.IonAllocBufferStartFtraceEvent"; } + + + using FieldMetadata_ClientName = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + IonAllocBufferStartFtraceEvent>; + + static constexpr FieldMetadata_ClientName kClientName{}; + void set_client_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_ClientName::kFieldId, data, size); + } + void set_client_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_ClientName::kFieldId, chars.data, chars.size); + } + void set_client_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_ClientName::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Flags = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + IonAllocBufferStartFtraceEvent>; + + static constexpr FieldMetadata_Flags kFlags{}; + void set_flags(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_HeapName = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + IonAllocBufferStartFtraceEvent>; + + static constexpr FieldMetadata_HeapName kHeapName{}; + void set_heap_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_HeapName::kFieldId, data, size); + } + void set_heap_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_HeapName::kFieldId, chars.data, chars.size); + } + void set_heap_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_HeapName::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Len = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + IonAllocBufferStartFtraceEvent>; + + static constexpr FieldMetadata_Len kLen{}; + void set_len(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Mask = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + IonAllocBufferStartFtraceEvent>; + + static constexpr FieldMetadata_Mask kMask{}; + void set_mask(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Mask::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class IonAllocBufferFallbackFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + IonAllocBufferFallbackFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit IonAllocBufferFallbackFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit IonAllocBufferFallbackFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_client_name() const { return at<1>().valid(); } + ::protozero::ConstChars client_name() const { return at<1>().as_string(); } + bool has_error() const { return at<2>().valid(); } + int64_t error() const { return at<2>().as_int64(); } + bool has_flags() const { return at<3>().valid(); } + uint32_t flags() const { return at<3>().as_uint32(); } + bool has_heap_name() const { return at<4>().valid(); } + ::protozero::ConstChars heap_name() const { return at<4>().as_string(); } + bool has_len() const { return at<5>().valid(); } + uint64_t len() const { return at<5>().as_uint64(); } + bool has_mask() const { return at<6>().valid(); } + uint32_t mask() const { return at<6>().as_uint32(); } +}; + +class IonAllocBufferFallbackFtraceEvent : public ::protozero::Message { + public: + using Decoder = IonAllocBufferFallbackFtraceEvent_Decoder; + enum : int32_t { + kClientNameFieldNumber = 1, + kErrorFieldNumber = 2, + kFlagsFieldNumber = 3, + kHeapNameFieldNumber = 4, + kLenFieldNumber = 5, + kMaskFieldNumber = 6, + }; + static constexpr const char* GetName() { return ".perfetto.protos.IonAllocBufferFallbackFtraceEvent"; } + + + using FieldMetadata_ClientName = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + IonAllocBufferFallbackFtraceEvent>; + + static constexpr FieldMetadata_ClientName kClientName{}; + void set_client_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_ClientName::kFieldId, data, size); + } + void set_client_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_ClientName::kFieldId, chars.data, chars.size); + } + void set_client_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_ClientName::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Error = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + IonAllocBufferFallbackFtraceEvent>; + + static constexpr FieldMetadata_Error kError{}; + void set_error(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Error::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Flags = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + IonAllocBufferFallbackFtraceEvent>; + + static constexpr FieldMetadata_Flags kFlags{}; + void set_flags(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_HeapName = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + IonAllocBufferFallbackFtraceEvent>; + + static constexpr FieldMetadata_HeapName kHeapName{}; + void set_heap_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_HeapName::kFieldId, data, size); + } + void set_heap_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_HeapName::kFieldId, chars.data, chars.size); + } + void set_heap_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_HeapName::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Len = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + IonAllocBufferFallbackFtraceEvent>; + + static constexpr FieldMetadata_Len kLen{}; + void set_len(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Mask = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + IonAllocBufferFallbackFtraceEvent>; + + static constexpr FieldMetadata_Mask kMask{}; + void set_mask(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Mask::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class IonAllocBufferFailFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + IonAllocBufferFailFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit IonAllocBufferFailFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit IonAllocBufferFailFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_client_name() const { return at<1>().valid(); } + ::protozero::ConstChars client_name() const { return at<1>().as_string(); } + bool has_error() const { return at<2>().valid(); } + int64_t error() const { return at<2>().as_int64(); } + bool has_flags() const { return at<3>().valid(); } + uint32_t flags() const { return at<3>().as_uint32(); } + bool has_heap_name() const { return at<4>().valid(); } + ::protozero::ConstChars heap_name() const { return at<4>().as_string(); } + bool has_len() const { return at<5>().valid(); } + uint64_t len() const { return at<5>().as_uint64(); } + bool has_mask() const { return at<6>().valid(); } + uint32_t mask() const { return at<6>().as_uint32(); } +}; + +class IonAllocBufferFailFtraceEvent : public ::protozero::Message { + public: + using Decoder = IonAllocBufferFailFtraceEvent_Decoder; + enum : int32_t { + kClientNameFieldNumber = 1, + kErrorFieldNumber = 2, + kFlagsFieldNumber = 3, + kHeapNameFieldNumber = 4, + kLenFieldNumber = 5, + kMaskFieldNumber = 6, + }; + static constexpr const char* GetName() { return ".perfetto.protos.IonAllocBufferFailFtraceEvent"; } + + + using FieldMetadata_ClientName = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + IonAllocBufferFailFtraceEvent>; + + static constexpr FieldMetadata_ClientName kClientName{}; + void set_client_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_ClientName::kFieldId, data, size); + } + void set_client_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_ClientName::kFieldId, chars.data, chars.size); + } + void set_client_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_ClientName::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Error = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + IonAllocBufferFailFtraceEvent>; + + static constexpr FieldMetadata_Error kError{}; + void set_error(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Error::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Flags = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + IonAllocBufferFailFtraceEvent>; + + static constexpr FieldMetadata_Flags kFlags{}; + void set_flags(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_HeapName = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + IonAllocBufferFailFtraceEvent>; + + static constexpr FieldMetadata_HeapName kHeapName{}; + void set_heap_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_HeapName::kFieldId, data, size); + } + void set_heap_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_HeapName::kFieldId, chars.data, chars.size); + } + void set_heap_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_HeapName::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Len = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + IonAllocBufferFailFtraceEvent>; + + static constexpr FieldMetadata_Len kLen{}; + void set_len(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Mask = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + IonAllocBufferFailFtraceEvent>; + + static constexpr FieldMetadata_Mask kMask{}; + void set_mask(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Mask::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class IonAllocBufferEndFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + IonAllocBufferEndFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit IonAllocBufferEndFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit IonAllocBufferEndFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_client_name() const { return at<1>().valid(); } + ::protozero::ConstChars client_name() const { return at<1>().as_string(); } + bool has_flags() const { return at<2>().valid(); } + uint32_t flags() const { return at<2>().as_uint32(); } + bool has_heap_name() const { return at<3>().valid(); } + ::protozero::ConstChars heap_name() const { return at<3>().as_string(); } + bool has_len() const { return at<4>().valid(); } + uint64_t len() const { return at<4>().as_uint64(); } + bool has_mask() const { return at<5>().valid(); } + uint32_t mask() const { return at<5>().as_uint32(); } +}; + +class IonAllocBufferEndFtraceEvent : public ::protozero::Message { + public: + using Decoder = IonAllocBufferEndFtraceEvent_Decoder; + enum : int32_t { + kClientNameFieldNumber = 1, + kFlagsFieldNumber = 2, + kHeapNameFieldNumber = 3, + kLenFieldNumber = 4, + kMaskFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.IonAllocBufferEndFtraceEvent"; } + + + using FieldMetadata_ClientName = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + IonAllocBufferEndFtraceEvent>; + + static constexpr FieldMetadata_ClientName kClientName{}; + void set_client_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_ClientName::kFieldId, data, size); + } + void set_client_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_ClientName::kFieldId, chars.data, chars.size); + } + void set_client_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_ClientName::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Flags = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + IonAllocBufferEndFtraceEvent>; + + static constexpr FieldMetadata_Flags kFlags{}; + void set_flags(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_HeapName = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + IonAllocBufferEndFtraceEvent>; + + static constexpr FieldMetadata_HeapName kHeapName{}; + void set_heap_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_HeapName::kFieldId, data, size); + } + void set_heap_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_HeapName::kFieldId, chars.data, chars.size); + } + void set_heap_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_HeapName::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Len = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + IonAllocBufferEndFtraceEvent>; + + static constexpr FieldMetadata_Len kLen{}; + void set_len(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Mask = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + IonAllocBufferEndFtraceEvent>; + + static constexpr FieldMetadata_Mask kMask{}; + void set_mask(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Mask::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class IommuSecPtblMapRangeStartFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + IommuSecPtblMapRangeStartFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit IommuSecPtblMapRangeStartFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit IommuSecPtblMapRangeStartFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_len() const { return at<1>().valid(); } + uint64_t len() const { return at<1>().as_uint64(); } + bool has_num() const { return at<2>().valid(); } + int32_t num() const { return at<2>().as_int32(); } + bool has_pa() const { return at<3>().valid(); } + uint32_t pa() const { return at<3>().as_uint32(); } + bool has_sec_id() const { return at<4>().valid(); } + int32_t sec_id() const { return at<4>().as_int32(); } + bool has_va() const { return at<5>().valid(); } + uint64_t va() const { return at<5>().as_uint64(); } +}; + +class IommuSecPtblMapRangeStartFtraceEvent : public ::protozero::Message { + public: + using Decoder = IommuSecPtblMapRangeStartFtraceEvent_Decoder; + enum : int32_t { + kLenFieldNumber = 1, + kNumFieldNumber = 2, + kPaFieldNumber = 3, + kSecIdFieldNumber = 4, + kVaFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.IommuSecPtblMapRangeStartFtraceEvent"; } + + + using FieldMetadata_Len = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + IommuSecPtblMapRangeStartFtraceEvent>; + + static constexpr FieldMetadata_Len kLen{}; + void set_len(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Num = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + IommuSecPtblMapRangeStartFtraceEvent>; + + static constexpr FieldMetadata_Num kNum{}; + void set_num(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Num::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pa = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + IommuSecPtblMapRangeStartFtraceEvent>; + + static constexpr FieldMetadata_Pa kPa{}; + void set_pa(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pa::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SecId = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + IommuSecPtblMapRangeStartFtraceEvent>; + + static constexpr FieldMetadata_SecId kSecId{}; + void set_sec_id(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_SecId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Va = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + IommuSecPtblMapRangeStartFtraceEvent>; + + static constexpr FieldMetadata_Va kVa{}; + void set_va(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Va::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class IommuSecPtblMapRangeEndFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + IommuSecPtblMapRangeEndFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit IommuSecPtblMapRangeEndFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit IommuSecPtblMapRangeEndFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_len() const { return at<1>().valid(); } + uint64_t len() const { return at<1>().as_uint64(); } + bool has_num() const { return at<2>().valid(); } + int32_t num() const { return at<2>().as_int32(); } + bool has_pa() const { return at<3>().valid(); } + uint32_t pa() const { return at<3>().as_uint32(); } + bool has_sec_id() const { return at<4>().valid(); } + int32_t sec_id() const { return at<4>().as_int32(); } + bool has_va() const { return at<5>().valid(); } + uint64_t va() const { return at<5>().as_uint64(); } +}; + +class IommuSecPtblMapRangeEndFtraceEvent : public ::protozero::Message { + public: + using Decoder = IommuSecPtblMapRangeEndFtraceEvent_Decoder; + enum : int32_t { + kLenFieldNumber = 1, + kNumFieldNumber = 2, + kPaFieldNumber = 3, + kSecIdFieldNumber = 4, + kVaFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.IommuSecPtblMapRangeEndFtraceEvent"; } + + + using FieldMetadata_Len = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + IommuSecPtblMapRangeEndFtraceEvent>; + + static constexpr FieldMetadata_Len kLen{}; + void set_len(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Num = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + IommuSecPtblMapRangeEndFtraceEvent>; + + static constexpr FieldMetadata_Num kNum{}; + void set_num(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Num::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pa = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + IommuSecPtblMapRangeEndFtraceEvent>; + + static constexpr FieldMetadata_Pa kPa{}; + void set_pa(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pa::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SecId = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + IommuSecPtblMapRangeEndFtraceEvent>; + + static constexpr FieldMetadata_SecId kSecId{}; + void set_sec_id(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_SecId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Va = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + IommuSecPtblMapRangeEndFtraceEvent>; + + static constexpr FieldMetadata_Va kVa{}; + void set_va(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Va::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class IommuMapRangeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + IommuMapRangeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit IommuMapRangeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit IommuMapRangeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_chunk_size() const { return at<1>().valid(); } + uint64_t chunk_size() const { return at<1>().as_uint64(); } + bool has_len() const { return at<2>().valid(); } + uint64_t len() const { return at<2>().as_uint64(); } + bool has_pa() const { return at<3>().valid(); } + uint64_t pa() const { return at<3>().as_uint64(); } + bool has_va() const { return at<4>().valid(); } + uint64_t va() const { return at<4>().as_uint64(); } +}; + +class IommuMapRangeFtraceEvent : public ::protozero::Message { + public: + using Decoder = IommuMapRangeFtraceEvent_Decoder; + enum : int32_t { + kChunkSizeFieldNumber = 1, + kLenFieldNumber = 2, + kPaFieldNumber = 3, + kVaFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.IommuMapRangeFtraceEvent"; } + + + using FieldMetadata_ChunkSize = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + IommuMapRangeFtraceEvent>; + + static constexpr FieldMetadata_ChunkSize kChunkSize{}; + void set_chunk_size(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_ChunkSize::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Len = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + IommuMapRangeFtraceEvent>; + + static constexpr FieldMetadata_Len kLen{}; + void set_len(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pa = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + IommuMapRangeFtraceEvent>; + + static constexpr FieldMetadata_Pa kPa{}; + void set_pa(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pa::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Va = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + IommuMapRangeFtraceEvent>; + + static constexpr FieldMetadata_Va kVa{}; + void set_va(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Va::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class DmaAllocContiguousRetryFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + DmaAllocContiguousRetryFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit DmaAllocContiguousRetryFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit DmaAllocContiguousRetryFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_tries() const { return at<1>().valid(); } + int32_t tries() const { return at<1>().as_int32(); } +}; + +class DmaAllocContiguousRetryFtraceEvent : public ::protozero::Message { + public: + using Decoder = DmaAllocContiguousRetryFtraceEvent_Decoder; + enum : int32_t { + kTriesFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.DmaAllocContiguousRetryFtraceEvent"; } + + + using FieldMetadata_Tries = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + DmaAllocContiguousRetryFtraceEvent>; + + static constexpr FieldMetadata_Tries kTries{}; + void set_tries(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Tries::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class AllocPagesSysStartFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + AllocPagesSysStartFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit AllocPagesSysStartFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit AllocPagesSysStartFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_gfp_flags() const { return at<1>().valid(); } + uint32_t gfp_flags() const { return at<1>().as_uint32(); } + bool has_order() const { return at<2>().valid(); } + uint32_t order() const { return at<2>().as_uint32(); } +}; + +class AllocPagesSysStartFtraceEvent : public ::protozero::Message { + public: + using Decoder = AllocPagesSysStartFtraceEvent_Decoder; + enum : int32_t { + kGfpFlagsFieldNumber = 1, + kOrderFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.AllocPagesSysStartFtraceEvent"; } + + + using FieldMetadata_GfpFlags = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + AllocPagesSysStartFtraceEvent>; + + static constexpr FieldMetadata_GfpFlags kGfpFlags{}; + void set_gfp_flags(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_GfpFlags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Order = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + AllocPagesSysStartFtraceEvent>; + + static constexpr FieldMetadata_Order kOrder{}; + void set_order(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Order::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class AllocPagesSysFailFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + AllocPagesSysFailFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit AllocPagesSysFailFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit AllocPagesSysFailFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_gfp_flags() const { return at<1>().valid(); } + uint32_t gfp_flags() const { return at<1>().as_uint32(); } + bool has_order() const { return at<2>().valid(); } + uint32_t order() const { return at<2>().as_uint32(); } +}; + +class AllocPagesSysFailFtraceEvent : public ::protozero::Message { + public: + using Decoder = AllocPagesSysFailFtraceEvent_Decoder; + enum : int32_t { + kGfpFlagsFieldNumber = 1, + kOrderFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.AllocPagesSysFailFtraceEvent"; } + + + using FieldMetadata_GfpFlags = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + AllocPagesSysFailFtraceEvent>; + + static constexpr FieldMetadata_GfpFlags kGfpFlags{}; + void set_gfp_flags(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_GfpFlags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Order = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + AllocPagesSysFailFtraceEvent>; + + static constexpr FieldMetadata_Order kOrder{}; + void set_order(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Order::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class AllocPagesSysEndFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + AllocPagesSysEndFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit AllocPagesSysEndFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit AllocPagesSysEndFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_gfp_flags() const { return at<1>().valid(); } + uint32_t gfp_flags() const { return at<1>().as_uint32(); } + bool has_order() const { return at<2>().valid(); } + uint32_t order() const { return at<2>().as_uint32(); } +}; + +class AllocPagesSysEndFtraceEvent : public ::protozero::Message { + public: + using Decoder = AllocPagesSysEndFtraceEvent_Decoder; + enum : int32_t { + kGfpFlagsFieldNumber = 1, + kOrderFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.AllocPagesSysEndFtraceEvent"; } + + + using FieldMetadata_GfpFlags = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + AllocPagesSysEndFtraceEvent>; + + static constexpr FieldMetadata_GfpFlags kGfpFlags{}; + void set_gfp_flags(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_GfpFlags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Order = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + AllocPagesSysEndFtraceEvent>; + + static constexpr FieldMetadata_Order kOrder{}; + void set_order(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Order::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class AllocPagesIommuStartFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + AllocPagesIommuStartFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit AllocPagesIommuStartFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit AllocPagesIommuStartFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_gfp_flags() const { return at<1>().valid(); } + uint32_t gfp_flags() const { return at<1>().as_uint32(); } + bool has_order() const { return at<2>().valid(); } + uint32_t order() const { return at<2>().as_uint32(); } +}; + +class AllocPagesIommuStartFtraceEvent : public ::protozero::Message { + public: + using Decoder = AllocPagesIommuStartFtraceEvent_Decoder; + enum : int32_t { + kGfpFlagsFieldNumber = 1, + kOrderFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.AllocPagesIommuStartFtraceEvent"; } + + + using FieldMetadata_GfpFlags = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + AllocPagesIommuStartFtraceEvent>; + + static constexpr FieldMetadata_GfpFlags kGfpFlags{}; + void set_gfp_flags(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_GfpFlags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Order = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + AllocPagesIommuStartFtraceEvent>; + + static constexpr FieldMetadata_Order kOrder{}; + void set_order(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Order::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class AllocPagesIommuFailFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + AllocPagesIommuFailFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit AllocPagesIommuFailFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit AllocPagesIommuFailFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_gfp_flags() const { return at<1>().valid(); } + uint32_t gfp_flags() const { return at<1>().as_uint32(); } + bool has_order() const { return at<2>().valid(); } + uint32_t order() const { return at<2>().as_uint32(); } +}; + +class AllocPagesIommuFailFtraceEvent : public ::protozero::Message { + public: + using Decoder = AllocPagesIommuFailFtraceEvent_Decoder; + enum : int32_t { + kGfpFlagsFieldNumber = 1, + kOrderFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.AllocPagesIommuFailFtraceEvent"; } + + + using FieldMetadata_GfpFlags = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + AllocPagesIommuFailFtraceEvent>; + + static constexpr FieldMetadata_GfpFlags kGfpFlags{}; + void set_gfp_flags(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_GfpFlags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Order = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + AllocPagesIommuFailFtraceEvent>; + + static constexpr FieldMetadata_Order kOrder{}; + void set_order(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Order::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class AllocPagesIommuEndFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + AllocPagesIommuEndFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit AllocPagesIommuEndFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit AllocPagesIommuEndFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_gfp_flags() const { return at<1>().valid(); } + uint32_t gfp_flags() const { return at<1>().as_uint32(); } + bool has_order() const { return at<2>().valid(); } + uint32_t order() const { return at<2>().as_uint32(); } +}; + +class AllocPagesIommuEndFtraceEvent : public ::protozero::Message { + public: + using Decoder = AllocPagesIommuEndFtraceEvent_Decoder; + enum : int32_t { + kGfpFlagsFieldNumber = 1, + kOrderFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.AllocPagesIommuEndFtraceEvent"; } + + + using FieldMetadata_GfpFlags = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + AllocPagesIommuEndFtraceEvent>; + + static constexpr FieldMetadata_GfpFlags kGfpFlags{}; + void set_gfp_flags(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_GfpFlags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Order = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + AllocPagesIommuEndFtraceEvent>; + + static constexpr FieldMetadata_Order kOrder{}; + void set_order(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Order::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class IrqHandlerExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + IrqHandlerExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit IrqHandlerExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit IrqHandlerExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_irq() const { return at<1>().valid(); } + int32_t irq() const { return at<1>().as_int32(); } + bool has_ret() const { return at<2>().valid(); } + int32_t ret() const { return at<2>().as_int32(); } +}; + +class IrqHandlerExitFtraceEvent : public ::protozero::Message { + public: + using Decoder = IrqHandlerExitFtraceEvent_Decoder; + enum : int32_t { + kIrqFieldNumber = 1, + kRetFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.IrqHandlerExitFtraceEvent"; } + + + using FieldMetadata_Irq = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + IrqHandlerExitFtraceEvent>; + + static constexpr FieldMetadata_Irq kIrq{}; + void set_irq(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Irq::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ret = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + IrqHandlerExitFtraceEvent>; + + static constexpr FieldMetadata_Ret kRet{}; + void set_ret(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class IrqHandlerEntryFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + IrqHandlerEntryFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit IrqHandlerEntryFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit IrqHandlerEntryFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_irq() const { return at<1>().valid(); } + int32_t irq() const { return at<1>().as_int32(); } + bool has_name() const { return at<2>().valid(); } + ::protozero::ConstChars name() const { return at<2>().as_string(); } + bool has_handler() const { return at<3>().valid(); } + uint32_t handler() const { return at<3>().as_uint32(); } +}; + +class IrqHandlerEntryFtraceEvent : public ::protozero::Message { + public: + using Decoder = IrqHandlerEntryFtraceEvent_Decoder; + enum : int32_t { + kIrqFieldNumber = 1, + kNameFieldNumber = 2, + kHandlerFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.IrqHandlerEntryFtraceEvent"; } + + + using FieldMetadata_Irq = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + IrqHandlerEntryFtraceEvent>; + + static constexpr FieldMetadata_Irq kIrq{}; + void set_irq(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Irq::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + IrqHandlerEntryFtraceEvent>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Handler = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + IrqHandlerEntryFtraceEvent>; + + static constexpr FieldMetadata_Handler kHandler{}; + void set_handler(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Handler::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class SoftirqRaiseFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + SoftirqRaiseFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit SoftirqRaiseFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit SoftirqRaiseFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_vec() const { return at<1>().valid(); } + uint32_t vec() const { return at<1>().as_uint32(); } +}; + +class SoftirqRaiseFtraceEvent : public ::protozero::Message { + public: + using Decoder = SoftirqRaiseFtraceEvent_Decoder; + enum : int32_t { + kVecFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.SoftirqRaiseFtraceEvent"; } + + + using FieldMetadata_Vec = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SoftirqRaiseFtraceEvent>; + + static constexpr FieldMetadata_Vec kVec{}; + void set_vec(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Vec::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class SoftirqExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + SoftirqExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit SoftirqExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit SoftirqExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_vec() const { return at<1>().valid(); } + uint32_t vec() const { return at<1>().as_uint32(); } +}; + +class SoftirqExitFtraceEvent : public ::protozero::Message { + public: + using Decoder = SoftirqExitFtraceEvent_Decoder; + enum : int32_t { + kVecFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.SoftirqExitFtraceEvent"; } + + + using FieldMetadata_Vec = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SoftirqExitFtraceEvent>; + + static constexpr FieldMetadata_Vec kVec{}; + void set_vec(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Vec::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class SoftirqEntryFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + SoftirqEntryFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit SoftirqEntryFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit SoftirqEntryFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_vec() const { return at<1>().valid(); } + uint32_t vec() const { return at<1>().as_uint32(); } +}; + +class SoftirqEntryFtraceEvent : public ::protozero::Message { + public: + using Decoder = SoftirqEntryFtraceEvent_Decoder; + enum : int32_t { + kVecFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.SoftirqEntryFtraceEvent"; } + + + using FieldMetadata_Vec = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SoftirqEntryFtraceEvent>; + + static constexpr FieldMetadata_Vec kVec{}; + void set_vec(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Vec::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class IpiRaiseFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + IpiRaiseFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit IpiRaiseFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit IpiRaiseFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_target_cpus() const { return at<1>().valid(); } + uint32_t target_cpus() const { return at<1>().as_uint32(); } + bool has_reason() const { return at<2>().valid(); } + ::protozero::ConstChars reason() const { return at<2>().as_string(); } +}; + +class IpiRaiseFtraceEvent : public ::protozero::Message { + public: + using Decoder = IpiRaiseFtraceEvent_Decoder; + enum : int32_t { + kTargetCpusFieldNumber = 1, + kReasonFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.IpiRaiseFtraceEvent"; } + + + using FieldMetadata_TargetCpus = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + IpiRaiseFtraceEvent>; + + static constexpr FieldMetadata_TargetCpus kTargetCpus{}; + void set_target_cpus(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TargetCpus::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Reason = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + IpiRaiseFtraceEvent>; + + static constexpr FieldMetadata_Reason kReason{}; + void set_reason(const char* data, size_t size) { + AppendBytes(FieldMetadata_Reason::kFieldId, data, size); + } + void set_reason(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Reason::kFieldId, chars.data, chars.size); + } + void set_reason(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Reason::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class IpiExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + IpiExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit IpiExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit IpiExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_reason() const { return at<1>().valid(); } + ::protozero::ConstChars reason() const { return at<1>().as_string(); } +}; + +class IpiExitFtraceEvent : public ::protozero::Message { + public: + using Decoder = IpiExitFtraceEvent_Decoder; + enum : int32_t { + kReasonFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.IpiExitFtraceEvent"; } + + + using FieldMetadata_Reason = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + IpiExitFtraceEvent>; + + static constexpr FieldMetadata_Reason kReason{}; + void set_reason(const char* data, size_t size) { + AppendBytes(FieldMetadata_Reason::kFieldId, data, size); + } + void set_reason(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Reason::kFieldId, chars.data, chars.size); + } + void set_reason(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Reason::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class IpiEntryFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + IpiEntryFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit IpiEntryFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit IpiEntryFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_reason() const { return at<1>().valid(); } + ::protozero::ConstChars reason() const { return at<1>().as_string(); } +}; + +class IpiEntryFtraceEvent : public ::protozero::Message { + public: + using Decoder = IpiEntryFtraceEvent_Decoder; + enum : int32_t { + kReasonFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.IpiEntryFtraceEvent"; } + + + using FieldMetadata_Reason = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + IpiEntryFtraceEvent>; + + static constexpr FieldMetadata_Reason kReason{}; + void set_reason(const char* data, size_t size) { + AppendBytes(FieldMetadata_Reason::kFieldId, data, size); + } + void set_reason(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Reason::kFieldId, chars.data, chars.size); + } + void set_reason(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Reason::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class IonStatFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + IonStatFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit IonStatFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit IonStatFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_buffer_id() const { return at<1>().valid(); } + uint32_t buffer_id() const { return at<1>().as_uint32(); } + bool has_len() const { return at<2>().valid(); } + int64_t len() const { return at<2>().as_int64(); } + bool has_total_allocated() const { return at<3>().valid(); } + uint64_t total_allocated() const { return at<3>().as_uint64(); } +}; + +class IonStatFtraceEvent : public ::protozero::Message { + public: + using Decoder = IonStatFtraceEvent_Decoder; + enum : int32_t { + kBufferIdFieldNumber = 1, + kLenFieldNumber = 2, + kTotalAllocatedFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.IonStatFtraceEvent"; } + + + using FieldMetadata_BufferId = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + IonStatFtraceEvent>; + + static constexpr FieldMetadata_BufferId kBufferId{}; + void set_buffer_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_BufferId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Len = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + IonStatFtraceEvent>; + + static constexpr FieldMetadata_Len kLen{}; + void set_len(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TotalAllocated = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + IonStatFtraceEvent>; + + static constexpr FieldMetadata_TotalAllocated kTotalAllocated{}; + void set_total_allocated(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_TotalAllocated::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class SmbusReplyFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + SmbusReplyFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit SmbusReplyFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit SmbusReplyFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_adapter_nr() const { return at<1>().valid(); } + int32_t adapter_nr() const { return at<1>().as_int32(); } + bool has_addr() const { return at<2>().valid(); } + uint32_t addr() const { return at<2>().as_uint32(); } + bool has_flags() const { return at<3>().valid(); } + uint32_t flags() const { return at<3>().as_uint32(); } + bool has_command() const { return at<4>().valid(); } + uint32_t command() const { return at<4>().as_uint32(); } + bool has_len() const { return at<5>().valid(); } + uint32_t len() const { return at<5>().as_uint32(); } + bool has_protocol() const { return at<6>().valid(); } + uint32_t protocol() const { return at<6>().as_uint32(); } +}; + +class SmbusReplyFtraceEvent : public ::protozero::Message { + public: + using Decoder = SmbusReplyFtraceEvent_Decoder; + enum : int32_t { + kAdapterNrFieldNumber = 1, + kAddrFieldNumber = 2, + kFlagsFieldNumber = 3, + kCommandFieldNumber = 4, + kLenFieldNumber = 5, + kProtocolFieldNumber = 6, + }; + static constexpr const char* GetName() { return ".perfetto.protos.SmbusReplyFtraceEvent"; } + + + using FieldMetadata_AdapterNr = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + SmbusReplyFtraceEvent>; + + static constexpr FieldMetadata_AdapterNr kAdapterNr{}; + void set_adapter_nr(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_AdapterNr::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Addr = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SmbusReplyFtraceEvent>; + + static constexpr FieldMetadata_Addr kAddr{}; + void set_addr(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Addr::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Flags = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SmbusReplyFtraceEvent>; + + static constexpr FieldMetadata_Flags kFlags{}; + void set_flags(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Command = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SmbusReplyFtraceEvent>; + + static constexpr FieldMetadata_Command kCommand{}; + void set_command(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Command::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Len = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SmbusReplyFtraceEvent>; + + static constexpr FieldMetadata_Len kLen{}; + void set_len(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Protocol = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SmbusReplyFtraceEvent>; + + static constexpr FieldMetadata_Protocol kProtocol{}; + void set_protocol(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Protocol::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class SmbusResultFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + SmbusResultFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit SmbusResultFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit SmbusResultFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_adapter_nr() const { return at<1>().valid(); } + int32_t adapter_nr() const { return at<1>().as_int32(); } + bool has_addr() const { return at<2>().valid(); } + uint32_t addr() const { return at<2>().as_uint32(); } + bool has_flags() const { return at<3>().valid(); } + uint32_t flags() const { return at<3>().as_uint32(); } + bool has_read_write() const { return at<4>().valid(); } + uint32_t read_write() const { return at<4>().as_uint32(); } + bool has_command() const { return at<5>().valid(); } + uint32_t command() const { return at<5>().as_uint32(); } + bool has_res() const { return at<6>().valid(); } + int32_t res() const { return at<6>().as_int32(); } + bool has_protocol() const { return at<7>().valid(); } + uint32_t protocol() const { return at<7>().as_uint32(); } +}; + +class SmbusResultFtraceEvent : public ::protozero::Message { + public: + using Decoder = SmbusResultFtraceEvent_Decoder; + enum : int32_t { + kAdapterNrFieldNumber = 1, + kAddrFieldNumber = 2, + kFlagsFieldNumber = 3, + kReadWriteFieldNumber = 4, + kCommandFieldNumber = 5, + kResFieldNumber = 6, + kProtocolFieldNumber = 7, + }; + static constexpr const char* GetName() { return ".perfetto.protos.SmbusResultFtraceEvent"; } + + + using FieldMetadata_AdapterNr = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + SmbusResultFtraceEvent>; + + static constexpr FieldMetadata_AdapterNr kAdapterNr{}; + void set_adapter_nr(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_AdapterNr::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Addr = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SmbusResultFtraceEvent>; + + static constexpr FieldMetadata_Addr kAddr{}; + void set_addr(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Addr::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Flags = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SmbusResultFtraceEvent>; + + static constexpr FieldMetadata_Flags kFlags{}; + void set_flags(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ReadWrite = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SmbusResultFtraceEvent>; + + static constexpr FieldMetadata_ReadWrite kReadWrite{}; + void set_read_write(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ReadWrite::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Command = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SmbusResultFtraceEvent>; + + static constexpr FieldMetadata_Command kCommand{}; + void set_command(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Command::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Res = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + SmbusResultFtraceEvent>; + + static constexpr FieldMetadata_Res kRes{}; + void set_res(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Res::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Protocol = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SmbusResultFtraceEvent>; + + static constexpr FieldMetadata_Protocol kProtocol{}; + void set_protocol(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Protocol::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class SmbusWriteFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + SmbusWriteFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit SmbusWriteFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit SmbusWriteFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_adapter_nr() const { return at<1>().valid(); } + int32_t adapter_nr() const { return at<1>().as_int32(); } + bool has_addr() const { return at<2>().valid(); } + uint32_t addr() const { return at<2>().as_uint32(); } + bool has_flags() const { return at<3>().valid(); } + uint32_t flags() const { return at<3>().as_uint32(); } + bool has_command() const { return at<4>().valid(); } + uint32_t command() const { return at<4>().as_uint32(); } + bool has_len() const { return at<5>().valid(); } + uint32_t len() const { return at<5>().as_uint32(); } + bool has_protocol() const { return at<6>().valid(); } + uint32_t protocol() const { return at<6>().as_uint32(); } +}; + +class SmbusWriteFtraceEvent : public ::protozero::Message { + public: + using Decoder = SmbusWriteFtraceEvent_Decoder; + enum : int32_t { + kAdapterNrFieldNumber = 1, + kAddrFieldNumber = 2, + kFlagsFieldNumber = 3, + kCommandFieldNumber = 4, + kLenFieldNumber = 5, + kProtocolFieldNumber = 6, + }; + static constexpr const char* GetName() { return ".perfetto.protos.SmbusWriteFtraceEvent"; } + + + using FieldMetadata_AdapterNr = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + SmbusWriteFtraceEvent>; + + static constexpr FieldMetadata_AdapterNr kAdapterNr{}; + void set_adapter_nr(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_AdapterNr::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Addr = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SmbusWriteFtraceEvent>; + + static constexpr FieldMetadata_Addr kAddr{}; + void set_addr(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Addr::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Flags = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SmbusWriteFtraceEvent>; + + static constexpr FieldMetadata_Flags kFlags{}; + void set_flags(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Command = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SmbusWriteFtraceEvent>; + + static constexpr FieldMetadata_Command kCommand{}; + void set_command(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Command::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Len = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SmbusWriteFtraceEvent>; + + static constexpr FieldMetadata_Len kLen{}; + void set_len(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Protocol = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SmbusWriteFtraceEvent>; + + static constexpr FieldMetadata_Protocol kProtocol{}; + void set_protocol(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Protocol::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class SmbusReadFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + SmbusReadFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit SmbusReadFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit SmbusReadFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_adapter_nr() const { return at<1>().valid(); } + int32_t adapter_nr() const { return at<1>().as_int32(); } + bool has_flags() const { return at<2>().valid(); } + uint32_t flags() const { return at<2>().as_uint32(); } + bool has_addr() const { return at<3>().valid(); } + uint32_t addr() const { return at<3>().as_uint32(); } + bool has_command() const { return at<4>().valid(); } + uint32_t command() const { return at<4>().as_uint32(); } + bool has_protocol() const { return at<5>().valid(); } + uint32_t protocol() const { return at<5>().as_uint32(); } +}; + +class SmbusReadFtraceEvent : public ::protozero::Message { + public: + using Decoder = SmbusReadFtraceEvent_Decoder; + enum : int32_t { + kAdapterNrFieldNumber = 1, + kFlagsFieldNumber = 2, + kAddrFieldNumber = 3, + kCommandFieldNumber = 4, + kProtocolFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.SmbusReadFtraceEvent"; } + + + using FieldMetadata_AdapterNr = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + SmbusReadFtraceEvent>; + + static constexpr FieldMetadata_AdapterNr kAdapterNr{}; + void set_adapter_nr(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_AdapterNr::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Flags = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SmbusReadFtraceEvent>; + + static constexpr FieldMetadata_Flags kFlags{}; + void set_flags(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Addr = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SmbusReadFtraceEvent>; + + static constexpr FieldMetadata_Addr kAddr{}; + void set_addr(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Addr::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Command = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SmbusReadFtraceEvent>; + + static constexpr FieldMetadata_Command kCommand{}; + void set_command(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Command::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Protocol = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SmbusReadFtraceEvent>; + + static constexpr FieldMetadata_Protocol kProtocol{}; + void set_protocol(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Protocol::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class I2cReplyFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + I2cReplyFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit I2cReplyFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit I2cReplyFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_adapter_nr() const { return at<1>().valid(); } + int32_t adapter_nr() const { return at<1>().as_int32(); } + bool has_msg_nr() const { return at<2>().valid(); } + uint32_t msg_nr() const { return at<2>().as_uint32(); } + bool has_addr() const { return at<3>().valid(); } + uint32_t addr() const { return at<3>().as_uint32(); } + bool has_flags() const { return at<4>().valid(); } + uint32_t flags() const { return at<4>().as_uint32(); } + bool has_len() const { return at<5>().valid(); } + uint32_t len() const { return at<5>().as_uint32(); } + bool has_buf() const { return at<6>().valid(); } + uint32_t buf() const { return at<6>().as_uint32(); } +}; + +class I2cReplyFtraceEvent : public ::protozero::Message { + public: + using Decoder = I2cReplyFtraceEvent_Decoder; + enum : int32_t { + kAdapterNrFieldNumber = 1, + kMsgNrFieldNumber = 2, + kAddrFieldNumber = 3, + kFlagsFieldNumber = 4, + kLenFieldNumber = 5, + kBufFieldNumber = 6, + }; + static constexpr const char* GetName() { return ".perfetto.protos.I2cReplyFtraceEvent"; } + + + using FieldMetadata_AdapterNr = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + I2cReplyFtraceEvent>; + + static constexpr FieldMetadata_AdapterNr kAdapterNr{}; + void set_adapter_nr(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_AdapterNr::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_MsgNr = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + I2cReplyFtraceEvent>; + + static constexpr FieldMetadata_MsgNr kMsgNr{}; + void set_msg_nr(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_MsgNr::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Addr = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + I2cReplyFtraceEvent>; + + static constexpr FieldMetadata_Addr kAddr{}; + void set_addr(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Addr::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Flags = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + I2cReplyFtraceEvent>; + + static constexpr FieldMetadata_Flags kFlags{}; + void set_flags(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Len = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + I2cReplyFtraceEvent>; + + static constexpr FieldMetadata_Len kLen{}; + void set_len(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Buf = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + I2cReplyFtraceEvent>; + + static constexpr FieldMetadata_Buf kBuf{}; + void set_buf(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Buf::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class I2cResultFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + I2cResultFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit I2cResultFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit I2cResultFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_adapter_nr() const { return at<1>().valid(); } + int32_t adapter_nr() const { return at<1>().as_int32(); } + bool has_nr_msgs() const { return at<2>().valid(); } + uint32_t nr_msgs() const { return at<2>().as_uint32(); } + bool has_ret() const { return at<3>().valid(); } + int32_t ret() const { return at<3>().as_int32(); } +}; + +class I2cResultFtraceEvent : public ::protozero::Message { + public: + using Decoder = I2cResultFtraceEvent_Decoder; + enum : int32_t { + kAdapterNrFieldNumber = 1, + kNrMsgsFieldNumber = 2, + kRetFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.I2cResultFtraceEvent"; } + + + using FieldMetadata_AdapterNr = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + I2cResultFtraceEvent>; + + static constexpr FieldMetadata_AdapterNr kAdapterNr{}; + void set_adapter_nr(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_AdapterNr::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NrMsgs = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + I2cResultFtraceEvent>; + + static constexpr FieldMetadata_NrMsgs kNrMsgs{}; + void set_nr_msgs(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_NrMsgs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ret = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + I2cResultFtraceEvent>; + + static constexpr FieldMetadata_Ret kRet{}; + void set_ret(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class I2cWriteFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + I2cWriteFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit I2cWriteFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit I2cWriteFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_adapter_nr() const { return at<1>().valid(); } + int32_t adapter_nr() const { return at<1>().as_int32(); } + bool has_msg_nr() const { return at<2>().valid(); } + uint32_t msg_nr() const { return at<2>().as_uint32(); } + bool has_addr() const { return at<3>().valid(); } + uint32_t addr() const { return at<3>().as_uint32(); } + bool has_flags() const { return at<4>().valid(); } + uint32_t flags() const { return at<4>().as_uint32(); } + bool has_len() const { return at<5>().valid(); } + uint32_t len() const { return at<5>().as_uint32(); } + bool has_buf() const { return at<6>().valid(); } + uint32_t buf() const { return at<6>().as_uint32(); } +}; + +class I2cWriteFtraceEvent : public ::protozero::Message { + public: + using Decoder = I2cWriteFtraceEvent_Decoder; + enum : int32_t { + kAdapterNrFieldNumber = 1, + kMsgNrFieldNumber = 2, + kAddrFieldNumber = 3, + kFlagsFieldNumber = 4, + kLenFieldNumber = 5, + kBufFieldNumber = 6, + }; + static constexpr const char* GetName() { return ".perfetto.protos.I2cWriteFtraceEvent"; } + + + using FieldMetadata_AdapterNr = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + I2cWriteFtraceEvent>; + + static constexpr FieldMetadata_AdapterNr kAdapterNr{}; + void set_adapter_nr(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_AdapterNr::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_MsgNr = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + I2cWriteFtraceEvent>; + + static constexpr FieldMetadata_MsgNr kMsgNr{}; + void set_msg_nr(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_MsgNr::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Addr = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + I2cWriteFtraceEvent>; + + static constexpr FieldMetadata_Addr kAddr{}; + void set_addr(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Addr::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Flags = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + I2cWriteFtraceEvent>; + + static constexpr FieldMetadata_Flags kFlags{}; + void set_flags(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Len = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + I2cWriteFtraceEvent>; + + static constexpr FieldMetadata_Len kLen{}; + void set_len(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Buf = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + I2cWriteFtraceEvent>; + + static constexpr FieldMetadata_Buf kBuf{}; + void set_buf(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Buf::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class I2cReadFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + I2cReadFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit I2cReadFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit I2cReadFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_adapter_nr() const { return at<1>().valid(); } + int32_t adapter_nr() const { return at<1>().as_int32(); } + bool has_msg_nr() const { return at<2>().valid(); } + uint32_t msg_nr() const { return at<2>().as_uint32(); } + bool has_addr() const { return at<3>().valid(); } + uint32_t addr() const { return at<3>().as_uint32(); } + bool has_flags() const { return at<4>().valid(); } + uint32_t flags() const { return at<4>().as_uint32(); } + bool has_len() const { return at<5>().valid(); } + uint32_t len() const { return at<5>().as_uint32(); } +}; + +class I2cReadFtraceEvent : public ::protozero::Message { + public: + using Decoder = I2cReadFtraceEvent_Decoder; + enum : int32_t { + kAdapterNrFieldNumber = 1, + kMsgNrFieldNumber = 2, + kAddrFieldNumber = 3, + kFlagsFieldNumber = 4, + kLenFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.I2cReadFtraceEvent"; } + + + using FieldMetadata_AdapterNr = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + I2cReadFtraceEvent>; + + static constexpr FieldMetadata_AdapterNr kAdapterNr{}; + void set_adapter_nr(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_AdapterNr::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_MsgNr = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + I2cReadFtraceEvent>; + + static constexpr FieldMetadata_MsgNr kMsgNr{}; + void set_msg_nr(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_MsgNr::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Addr = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + I2cReadFtraceEvent>; + + static constexpr FieldMetadata_Addr kAddr{}; + void set_addr(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Addr::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Flags = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + I2cReadFtraceEvent>; + + static constexpr FieldMetadata_Flags kFlags{}; + void set_flags(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Len = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + I2cReadFtraceEvent>; + + static constexpr FieldMetadata_Len kLen{}; + void set_len(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class HostMemAbortFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + HostMemAbortFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit HostMemAbortFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit HostMemAbortFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_esr() const { return at<1>().valid(); } + uint64_t esr() const { return at<1>().as_uint64(); } + bool has_addr() const { return at<2>().valid(); } + uint64_t addr() const { return at<2>().as_uint64(); } +}; + +class HostMemAbortFtraceEvent : public ::protozero::Message { + public: + using Decoder = HostMemAbortFtraceEvent_Decoder; + enum : int32_t { + kEsrFieldNumber = 1, + kAddrFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.HostMemAbortFtraceEvent"; } + + + using FieldMetadata_Esr = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + HostMemAbortFtraceEvent>; + + static constexpr FieldMetadata_Esr kEsr{}; + void set_esr(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Esr::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Addr = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + HostMemAbortFtraceEvent>; + + static constexpr FieldMetadata_Addr kAddr{}; + void set_addr(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Addr::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class HostSmcFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + HostSmcFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit HostSmcFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit HostSmcFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_id() const { return at<1>().valid(); } + uint64_t id() const { return at<1>().as_uint64(); } + bool has_forwarded() const { return at<2>().valid(); } + uint32_t forwarded() const { return at<2>().as_uint32(); } +}; + +class HostSmcFtraceEvent : public ::protozero::Message { + public: + using Decoder = HostSmcFtraceEvent_Decoder; + enum : int32_t { + kIdFieldNumber = 1, + kForwardedFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.HostSmcFtraceEvent"; } + + + using FieldMetadata_Id = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + HostSmcFtraceEvent>; + + static constexpr FieldMetadata_Id kId{}; + void set_id(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Forwarded = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + HostSmcFtraceEvent>; + + static constexpr FieldMetadata_Forwarded kForwarded{}; + void set_forwarded(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Forwarded::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class HostHcallFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + HostHcallFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit HostHcallFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit HostHcallFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_id() const { return at<1>().valid(); } + uint32_t id() const { return at<1>().as_uint32(); } + bool has_invalid() const { return at<2>().valid(); } + uint32_t invalid() const { return at<2>().as_uint32(); } +}; + +class HostHcallFtraceEvent : public ::protozero::Message { + public: + using Decoder = HostHcallFtraceEvent_Decoder; + enum : int32_t { + kIdFieldNumber = 1, + kInvalidFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.HostHcallFtraceEvent"; } + + + using FieldMetadata_Id = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + HostHcallFtraceEvent>; + + static constexpr FieldMetadata_Id kId{}; + void set_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Invalid = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + HostHcallFtraceEvent>; + + static constexpr FieldMetadata_Invalid kInvalid{}; + void set_invalid(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Invalid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class HypExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + HypExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit HypExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit HypExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} +}; + +class HypExitFtraceEvent : public ::protozero::Message { + public: + using Decoder = HypExitFtraceEvent_Decoder; + static constexpr const char* GetName() { return ".perfetto.protos.HypExitFtraceEvent"; } + +}; + +class HypEnterFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + HypEnterFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit HypEnterFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit HypEnterFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} +}; + +class HypEnterFtraceEvent : public ::protozero::Message { + public: + using Decoder = HypEnterFtraceEvent_Decoder; + static constexpr const char* GetName() { return ".perfetto.protos.HypEnterFtraceEvent"; } + +}; + +class DrmSchedProcessJobFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + DrmSchedProcessJobFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit DrmSchedProcessJobFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit DrmSchedProcessJobFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_fence() const { return at<1>().valid(); } + uint64_t fence() const { return at<1>().as_uint64(); } +}; + +class DrmSchedProcessJobFtraceEvent : public ::protozero::Message { + public: + using Decoder = DrmSchedProcessJobFtraceEvent_Decoder; + enum : int32_t { + kFenceFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.DrmSchedProcessJobFtraceEvent"; } + + + using FieldMetadata_Fence = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + DrmSchedProcessJobFtraceEvent>; + + static constexpr FieldMetadata_Fence kFence{}; + void set_fence(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Fence::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class DrmRunJobFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + DrmRunJobFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit DrmRunJobFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit DrmRunJobFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_entity() const { return at<1>().valid(); } + uint64_t entity() const { return at<1>().as_uint64(); } + bool has_fence() const { return at<2>().valid(); } + uint64_t fence() const { return at<2>().as_uint64(); } + bool has_hw_job_count() const { return at<3>().valid(); } + int32_t hw_job_count() const { return at<3>().as_int32(); } + bool has_id() const { return at<4>().valid(); } + uint64_t id() const { return at<4>().as_uint64(); } + bool has_job_count() const { return at<5>().valid(); } + uint32_t job_count() const { return at<5>().as_uint32(); } + bool has_name() const { return at<6>().valid(); } + ::protozero::ConstChars name() const { return at<6>().as_string(); } +}; + +class DrmRunJobFtraceEvent : public ::protozero::Message { + public: + using Decoder = DrmRunJobFtraceEvent_Decoder; + enum : int32_t { + kEntityFieldNumber = 1, + kFenceFieldNumber = 2, + kHwJobCountFieldNumber = 3, + kIdFieldNumber = 4, + kJobCountFieldNumber = 5, + kNameFieldNumber = 6, + }; + static constexpr const char* GetName() { return ".perfetto.protos.DrmRunJobFtraceEvent"; } + + + using FieldMetadata_Entity = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + DrmRunJobFtraceEvent>; + + static constexpr FieldMetadata_Entity kEntity{}; + void set_entity(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Entity::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Fence = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + DrmRunJobFtraceEvent>; + + static constexpr FieldMetadata_Fence kFence{}; + void set_fence(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Fence::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_HwJobCount = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + DrmRunJobFtraceEvent>; + + static constexpr FieldMetadata_HwJobCount kHwJobCount{}; + void set_hw_job_count(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_HwJobCount::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Id = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + DrmRunJobFtraceEvent>; + + static constexpr FieldMetadata_Id kId{}; + void set_id(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_JobCount = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + DrmRunJobFtraceEvent>; + + static constexpr FieldMetadata_JobCount kJobCount{}; + void set_job_count(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_JobCount::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + DrmRunJobFtraceEvent>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class DrmSchedJobFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + DrmSchedJobFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit DrmSchedJobFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit DrmSchedJobFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_entity() const { return at<1>().valid(); } + uint64_t entity() const { return at<1>().as_uint64(); } + bool has_fence() const { return at<2>().valid(); } + uint64_t fence() const { return at<2>().as_uint64(); } + bool has_hw_job_count() const { return at<3>().valid(); } + int32_t hw_job_count() const { return at<3>().as_int32(); } + bool has_id() const { return at<4>().valid(); } + uint64_t id() const { return at<4>().as_uint64(); } + bool has_job_count() const { return at<5>().valid(); } + uint32_t job_count() const { return at<5>().as_uint32(); } + bool has_name() const { return at<6>().valid(); } + ::protozero::ConstChars name() const { return at<6>().as_string(); } +}; + +class DrmSchedJobFtraceEvent : public ::protozero::Message { + public: + using Decoder = DrmSchedJobFtraceEvent_Decoder; + enum : int32_t { + kEntityFieldNumber = 1, + kFenceFieldNumber = 2, + kHwJobCountFieldNumber = 3, + kIdFieldNumber = 4, + kJobCountFieldNumber = 5, + kNameFieldNumber = 6, + }; + static constexpr const char* GetName() { return ".perfetto.protos.DrmSchedJobFtraceEvent"; } + + + using FieldMetadata_Entity = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + DrmSchedJobFtraceEvent>; + + static constexpr FieldMetadata_Entity kEntity{}; + void set_entity(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Entity::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Fence = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + DrmSchedJobFtraceEvent>; + + static constexpr FieldMetadata_Fence kFence{}; + void set_fence(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Fence::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_HwJobCount = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + DrmSchedJobFtraceEvent>; + + static constexpr FieldMetadata_HwJobCount kHwJobCount{}; + void set_hw_job_count(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_HwJobCount::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Id = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + DrmSchedJobFtraceEvent>; + + static constexpr FieldMetadata_Id kId{}; + void set_id(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_JobCount = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + DrmSchedJobFtraceEvent>; + + static constexpr FieldMetadata_JobCount kJobCount{}; + void set_job_count(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_JobCount::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + DrmSchedJobFtraceEvent>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class GpuMemTotalFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + GpuMemTotalFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit GpuMemTotalFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit GpuMemTotalFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_gpu_id() const { return at<1>().valid(); } + uint32_t gpu_id() const { return at<1>().as_uint32(); } + bool has_pid() const { return at<2>().valid(); } + uint32_t pid() const { return at<2>().as_uint32(); } + bool has_size() const { return at<3>().valid(); } + uint64_t size() const { return at<3>().as_uint64(); } +}; + +class GpuMemTotalFtraceEvent : public ::protozero::Message { + public: + using Decoder = GpuMemTotalFtraceEvent_Decoder; + enum : int32_t { + kGpuIdFieldNumber = 1, + kPidFieldNumber = 2, + kSizeFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.GpuMemTotalFtraceEvent"; } + + + using FieldMetadata_GpuId = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + GpuMemTotalFtraceEvent>; + + static constexpr FieldMetadata_GpuId kGpuId{}; + void set_gpu_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_GpuId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pid = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + GpuMemTotalFtraceEvent>; + + static constexpr FieldMetadata_Pid kPid{}; + void set_pid(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Size = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + GpuMemTotalFtraceEvent>; + + static constexpr FieldMetadata_Size kSize{}; + void set_size(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Size::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class GenericFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + GenericFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit GenericFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit GenericFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_event_name() const { return at<1>().valid(); } + ::protozero::ConstChars event_name() const { return at<1>().as_string(); } + bool has_field() const { return at<2>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> field() const { return GetRepeated<::protozero::ConstBytes>(2); } +}; + +class GenericFtraceEvent : public ::protozero::Message { + public: + using Decoder = GenericFtraceEvent_Decoder; + enum : int32_t { + kEventNameFieldNumber = 1, + kFieldFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.GenericFtraceEvent"; } + + using Field = ::perfetto::protos::pbzero::GenericFtraceEvent_Field; + + using FieldMetadata_EventName = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + GenericFtraceEvent>; + + static constexpr FieldMetadata_EventName kEventName{}; + void set_event_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_EventName::kFieldId, data, size); + } + void set_event_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_EventName::kFieldId, chars.data, chars.size); + } + void set_event_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_EventName::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Field = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + GenericFtraceEvent_Field, + GenericFtraceEvent>; + + static constexpr FieldMetadata_Field kField{}; + template T* add_field() { + return BeginNestedMessage(2); + } + +}; + +class GenericFtraceEvent_Field_Decoder : public ::protozero::TypedProtoDecoder { + public: + GenericFtraceEvent_Field_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit GenericFtraceEvent_Field_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit GenericFtraceEvent_Field_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_name() const { return at<1>().valid(); } + ::protozero::ConstChars name() const { return at<1>().as_string(); } + bool has_str_value() const { return at<3>().valid(); } + ::protozero::ConstChars str_value() const { return at<3>().as_string(); } + bool has_int_value() const { return at<4>().valid(); } + int64_t int_value() const { return at<4>().as_int64(); } + bool has_uint_value() const { return at<5>().valid(); } + uint64_t uint_value() const { return at<5>().as_uint64(); } +}; + +class GenericFtraceEvent_Field : public ::protozero::Message { + public: + using Decoder = GenericFtraceEvent_Field_Decoder; + enum : int32_t { + kNameFieldNumber = 1, + kStrValueFieldNumber = 3, + kIntValueFieldNumber = 4, + kUintValueFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.GenericFtraceEvent.Field"; } + + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + GenericFtraceEvent_Field>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_StrValue = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + GenericFtraceEvent_Field>; + + static constexpr FieldMetadata_StrValue kStrValue{}; + void set_str_value(const char* data, size_t size) { + AppendBytes(FieldMetadata_StrValue::kFieldId, data, size); + } + void set_str_value(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_StrValue::kFieldId, chars.data, chars.size); + } + void set_str_value(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_StrValue::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_IntValue = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + GenericFtraceEvent_Field>; + + static constexpr FieldMetadata_IntValue kIntValue{}; + void set_int_value(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_IntValue::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_UintValue = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + GenericFtraceEvent_Field>; + + static constexpr FieldMetadata_UintValue kUintValue{}; + void set_uint_value(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_UintValue::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class G2dTracingMarkWriteFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + G2dTracingMarkWriteFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit G2dTracingMarkWriteFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit G2dTracingMarkWriteFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_pid() const { return at<1>().valid(); } + int32_t pid() const { return at<1>().as_int32(); } + bool has_name() const { return at<4>().valid(); } + ::protozero::ConstChars name() const { return at<4>().as_string(); } + bool has_type() const { return at<5>().valid(); } + uint32_t type() const { return at<5>().as_uint32(); } + bool has_value() const { return at<6>().valid(); } + int32_t value() const { return at<6>().as_int32(); } +}; + +class G2dTracingMarkWriteFtraceEvent : public ::protozero::Message { + public: + using Decoder = G2dTracingMarkWriteFtraceEvent_Decoder; + enum : int32_t { + kPidFieldNumber = 1, + kNameFieldNumber = 4, + kTypeFieldNumber = 5, + kValueFieldNumber = 6, + }; + static constexpr const char* GetName() { return ".perfetto.protos.G2dTracingMarkWriteFtraceEvent"; } + + + using FieldMetadata_Pid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + G2dTracingMarkWriteFtraceEvent>; + + static constexpr FieldMetadata_Pid kPid{}; + void set_pid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + G2dTracingMarkWriteFtraceEvent>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Type = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + G2dTracingMarkWriteFtraceEvent>; + + static constexpr FieldMetadata_Type kType{}; + void set_type(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Value = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + G2dTracingMarkWriteFtraceEvent>; + + static constexpr FieldMetadata_Value kValue{}; + void set_value(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class FuncgraphExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + FuncgraphExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit FuncgraphExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit FuncgraphExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_calltime() const { return at<1>().valid(); } + uint64_t calltime() const { return at<1>().as_uint64(); } + bool has_depth() const { return at<2>().valid(); } + int32_t depth() const { return at<2>().as_int32(); } + bool has_func() const { return at<3>().valid(); } + uint64_t func() const { return at<3>().as_uint64(); } + bool has_overrun() const { return at<4>().valid(); } + uint64_t overrun() const { return at<4>().as_uint64(); } + bool has_rettime() const { return at<5>().valid(); } + uint64_t rettime() const { return at<5>().as_uint64(); } +}; + +class FuncgraphExitFtraceEvent : public ::protozero::Message { + public: + using Decoder = FuncgraphExitFtraceEvent_Decoder; + enum : int32_t { + kCalltimeFieldNumber = 1, + kDepthFieldNumber = 2, + kFuncFieldNumber = 3, + kOverrunFieldNumber = 4, + kRettimeFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.FuncgraphExitFtraceEvent"; } + + + using FieldMetadata_Calltime = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + FuncgraphExitFtraceEvent>; + + static constexpr FieldMetadata_Calltime kCalltime{}; + void set_calltime(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Calltime::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Depth = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + FuncgraphExitFtraceEvent>; + + static constexpr FieldMetadata_Depth kDepth{}; + void set_depth(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Depth::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Func = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + FuncgraphExitFtraceEvent>; + + static constexpr FieldMetadata_Func kFunc{}; + void set_func(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Func::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Overrun = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + FuncgraphExitFtraceEvent>; + + static constexpr FieldMetadata_Overrun kOverrun{}; + void set_overrun(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Overrun::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Rettime = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + FuncgraphExitFtraceEvent>; + + static constexpr FieldMetadata_Rettime kRettime{}; + void set_rettime(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Rettime::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class FuncgraphEntryFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + FuncgraphEntryFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit FuncgraphEntryFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit FuncgraphEntryFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_depth() const { return at<1>().valid(); } + int32_t depth() const { return at<1>().as_int32(); } + bool has_func() const { return at<2>().valid(); } + uint64_t func() const { return at<2>().as_uint64(); } +}; + +class FuncgraphEntryFtraceEvent : public ::protozero::Message { + public: + using Decoder = FuncgraphEntryFtraceEvent_Decoder; + enum : int32_t { + kDepthFieldNumber = 1, + kFuncFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.FuncgraphEntryFtraceEvent"; } + + + using FieldMetadata_Depth = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + FuncgraphEntryFtraceEvent>; + + static constexpr FieldMetadata_Depth kDepth{}; + void set_depth(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Depth::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Func = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + FuncgraphEntryFtraceEvent>; + + static constexpr FieldMetadata_Func kFunc{}; + void set_func(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Func::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class PrintFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + PrintFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit PrintFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit PrintFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_ip() const { return at<1>().valid(); } + uint64_t ip() const { return at<1>().as_uint64(); } + bool has_buf() const { return at<2>().valid(); } + ::protozero::ConstChars buf() const { return at<2>().as_string(); } +}; + +class PrintFtraceEvent : public ::protozero::Message { + public: + using Decoder = PrintFtraceEvent_Decoder; + enum : int32_t { + kIpFieldNumber = 1, + kBufFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.PrintFtraceEvent"; } + + + using FieldMetadata_Ip = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + PrintFtraceEvent>; + + static constexpr FieldMetadata_Ip kIp{}; + void set_ip(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ip::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Buf = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + PrintFtraceEvent>; + + static constexpr FieldMetadata_Buf kBuf{}; + void set_buf(const char* data, size_t size) { + AppendBytes(FieldMetadata_Buf::kFieldId, data, size); + } + void set_buf(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Buf::kFieldId, chars.data, chars.size); + } + void set_buf(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Buf::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class MmFilemapDeleteFromPageCacheFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + MmFilemapDeleteFromPageCacheFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MmFilemapDeleteFromPageCacheFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MmFilemapDeleteFromPageCacheFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_pfn() const { return at<1>().valid(); } + uint64_t pfn() const { return at<1>().as_uint64(); } + bool has_i_ino() const { return at<2>().valid(); } + uint64_t i_ino() const { return at<2>().as_uint64(); } + bool has_index() const { return at<3>().valid(); } + uint64_t index() const { return at<3>().as_uint64(); } + bool has_s_dev() const { return at<4>().valid(); } + uint64_t s_dev() const { return at<4>().as_uint64(); } + bool has_page() const { return at<5>().valid(); } + uint64_t page() const { return at<5>().as_uint64(); } +}; + +class MmFilemapDeleteFromPageCacheFtraceEvent : public ::protozero::Message { + public: + using Decoder = MmFilemapDeleteFromPageCacheFtraceEvent_Decoder; + enum : int32_t { + kPfnFieldNumber = 1, + kIInoFieldNumber = 2, + kIndexFieldNumber = 3, + kSDevFieldNumber = 4, + kPageFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MmFilemapDeleteFromPageCacheFtraceEvent"; } + + + using FieldMetadata_Pfn = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MmFilemapDeleteFromPageCacheFtraceEvent>; + + static constexpr FieldMetadata_Pfn kPfn{}; + void set_pfn(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pfn::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_IIno = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MmFilemapDeleteFromPageCacheFtraceEvent>; + + static constexpr FieldMetadata_IIno kIIno{}; + void set_i_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_IIno::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Index = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MmFilemapDeleteFromPageCacheFtraceEvent>; + + static constexpr FieldMetadata_Index kIndex{}; + void set_index(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Index::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SDev = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MmFilemapDeleteFromPageCacheFtraceEvent>; + + static constexpr FieldMetadata_SDev kSDev{}; + void set_s_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_SDev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Page = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MmFilemapDeleteFromPageCacheFtraceEvent>; + + static constexpr FieldMetadata_Page kPage{}; + void set_page(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Page::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class MmFilemapAddToPageCacheFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + MmFilemapAddToPageCacheFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MmFilemapAddToPageCacheFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MmFilemapAddToPageCacheFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_pfn() const { return at<1>().valid(); } + uint64_t pfn() const { return at<1>().as_uint64(); } + bool has_i_ino() const { return at<2>().valid(); } + uint64_t i_ino() const { return at<2>().as_uint64(); } + bool has_index() const { return at<3>().valid(); } + uint64_t index() const { return at<3>().as_uint64(); } + bool has_s_dev() const { return at<4>().valid(); } + uint64_t s_dev() const { return at<4>().as_uint64(); } + bool has_page() const { return at<5>().valid(); } + uint64_t page() const { return at<5>().as_uint64(); } +}; + +class MmFilemapAddToPageCacheFtraceEvent : public ::protozero::Message { + public: + using Decoder = MmFilemapAddToPageCacheFtraceEvent_Decoder; + enum : int32_t { + kPfnFieldNumber = 1, + kIInoFieldNumber = 2, + kIndexFieldNumber = 3, + kSDevFieldNumber = 4, + kPageFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MmFilemapAddToPageCacheFtraceEvent"; } + + + using FieldMetadata_Pfn = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MmFilemapAddToPageCacheFtraceEvent>; + + static constexpr FieldMetadata_Pfn kPfn{}; + void set_pfn(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pfn::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_IIno = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MmFilemapAddToPageCacheFtraceEvent>; + + static constexpr FieldMetadata_IIno kIIno{}; + void set_i_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_IIno::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Index = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MmFilemapAddToPageCacheFtraceEvent>; + + static constexpr FieldMetadata_Index kIndex{}; + void set_index(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Index::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SDev = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MmFilemapAddToPageCacheFtraceEvent>; + + static constexpr FieldMetadata_SDev kSDev{}; + void set_s_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_SDev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Page = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MmFilemapAddToPageCacheFtraceEvent>; + + static constexpr FieldMetadata_Page kPage{}; + void set_page(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Page::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class FenceSignaledFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + FenceSignaledFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit FenceSignaledFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit FenceSignaledFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_context() const { return at<1>().valid(); } + uint32_t context() const { return at<1>().as_uint32(); } + bool has_driver() const { return at<2>().valid(); } + ::protozero::ConstChars driver() const { return at<2>().as_string(); } + bool has_seqno() const { return at<3>().valid(); } + uint32_t seqno() const { return at<3>().as_uint32(); } + bool has_timeline() const { return at<4>().valid(); } + ::protozero::ConstChars timeline() const { return at<4>().as_string(); } +}; + +class FenceSignaledFtraceEvent : public ::protozero::Message { + public: + using Decoder = FenceSignaledFtraceEvent_Decoder; + enum : int32_t { + kContextFieldNumber = 1, + kDriverFieldNumber = 2, + kSeqnoFieldNumber = 3, + kTimelineFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.FenceSignaledFtraceEvent"; } + + + using FieldMetadata_Context = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + FenceSignaledFtraceEvent>; + + static constexpr FieldMetadata_Context kContext{}; + void set_context(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Context::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Driver = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + FenceSignaledFtraceEvent>; + + static constexpr FieldMetadata_Driver kDriver{}; + void set_driver(const char* data, size_t size) { + AppendBytes(FieldMetadata_Driver::kFieldId, data, size); + } + void set_driver(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Driver::kFieldId, chars.data, chars.size); + } + void set_driver(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Driver::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Seqno = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + FenceSignaledFtraceEvent>; + + static constexpr FieldMetadata_Seqno kSeqno{}; + void set_seqno(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Seqno::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Timeline = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + FenceSignaledFtraceEvent>; + + static constexpr FieldMetadata_Timeline kTimeline{}; + void set_timeline(const char* data, size_t size) { + AppendBytes(FieldMetadata_Timeline::kFieldId, data, size); + } + void set_timeline(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Timeline::kFieldId, chars.data, chars.size); + } + void set_timeline(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Timeline::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class FenceEnableSignalFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + FenceEnableSignalFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit FenceEnableSignalFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit FenceEnableSignalFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_context() const { return at<1>().valid(); } + uint32_t context() const { return at<1>().as_uint32(); } + bool has_driver() const { return at<2>().valid(); } + ::protozero::ConstChars driver() const { return at<2>().as_string(); } + bool has_seqno() const { return at<3>().valid(); } + uint32_t seqno() const { return at<3>().as_uint32(); } + bool has_timeline() const { return at<4>().valid(); } + ::protozero::ConstChars timeline() const { return at<4>().as_string(); } +}; + +class FenceEnableSignalFtraceEvent : public ::protozero::Message { + public: + using Decoder = FenceEnableSignalFtraceEvent_Decoder; + enum : int32_t { + kContextFieldNumber = 1, + kDriverFieldNumber = 2, + kSeqnoFieldNumber = 3, + kTimelineFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.FenceEnableSignalFtraceEvent"; } + + + using FieldMetadata_Context = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + FenceEnableSignalFtraceEvent>; + + static constexpr FieldMetadata_Context kContext{}; + void set_context(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Context::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Driver = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + FenceEnableSignalFtraceEvent>; + + static constexpr FieldMetadata_Driver kDriver{}; + void set_driver(const char* data, size_t size) { + AppendBytes(FieldMetadata_Driver::kFieldId, data, size); + } + void set_driver(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Driver::kFieldId, chars.data, chars.size); + } + void set_driver(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Driver::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Seqno = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + FenceEnableSignalFtraceEvent>; + + static constexpr FieldMetadata_Seqno kSeqno{}; + void set_seqno(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Seqno::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Timeline = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + FenceEnableSignalFtraceEvent>; + + static constexpr FieldMetadata_Timeline kTimeline{}; + void set_timeline(const char* data, size_t size) { + AppendBytes(FieldMetadata_Timeline::kFieldId, data, size); + } + void set_timeline(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Timeline::kFieldId, chars.data, chars.size); + } + void set_timeline(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Timeline::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class FenceDestroyFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + FenceDestroyFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit FenceDestroyFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit FenceDestroyFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_context() const { return at<1>().valid(); } + uint32_t context() const { return at<1>().as_uint32(); } + bool has_driver() const { return at<2>().valid(); } + ::protozero::ConstChars driver() const { return at<2>().as_string(); } + bool has_seqno() const { return at<3>().valid(); } + uint32_t seqno() const { return at<3>().as_uint32(); } + bool has_timeline() const { return at<4>().valid(); } + ::protozero::ConstChars timeline() const { return at<4>().as_string(); } +}; + +class FenceDestroyFtraceEvent : public ::protozero::Message { + public: + using Decoder = FenceDestroyFtraceEvent_Decoder; + enum : int32_t { + kContextFieldNumber = 1, + kDriverFieldNumber = 2, + kSeqnoFieldNumber = 3, + kTimelineFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.FenceDestroyFtraceEvent"; } + + + using FieldMetadata_Context = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + FenceDestroyFtraceEvent>; + + static constexpr FieldMetadata_Context kContext{}; + void set_context(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Context::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Driver = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + FenceDestroyFtraceEvent>; + + static constexpr FieldMetadata_Driver kDriver{}; + void set_driver(const char* data, size_t size) { + AppendBytes(FieldMetadata_Driver::kFieldId, data, size); + } + void set_driver(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Driver::kFieldId, chars.data, chars.size); + } + void set_driver(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Driver::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Seqno = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + FenceDestroyFtraceEvent>; + + static constexpr FieldMetadata_Seqno kSeqno{}; + void set_seqno(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Seqno::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Timeline = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + FenceDestroyFtraceEvent>; + + static constexpr FieldMetadata_Timeline kTimeline{}; + void set_timeline(const char* data, size_t size) { + AppendBytes(FieldMetadata_Timeline::kFieldId, data, size); + } + void set_timeline(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Timeline::kFieldId, chars.data, chars.size); + } + void set_timeline(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Timeline::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class FenceInitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + FenceInitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit FenceInitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit FenceInitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_context() const { return at<1>().valid(); } + uint32_t context() const { return at<1>().as_uint32(); } + bool has_driver() const { return at<2>().valid(); } + ::protozero::ConstChars driver() const { return at<2>().as_string(); } + bool has_seqno() const { return at<3>().valid(); } + uint32_t seqno() const { return at<3>().as_uint32(); } + bool has_timeline() const { return at<4>().valid(); } + ::protozero::ConstChars timeline() const { return at<4>().as_string(); } +}; + +class FenceInitFtraceEvent : public ::protozero::Message { + public: + using Decoder = FenceInitFtraceEvent_Decoder; + enum : int32_t { + kContextFieldNumber = 1, + kDriverFieldNumber = 2, + kSeqnoFieldNumber = 3, + kTimelineFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.FenceInitFtraceEvent"; } + + + using FieldMetadata_Context = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + FenceInitFtraceEvent>; + + static constexpr FieldMetadata_Context kContext{}; + void set_context(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Context::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Driver = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + FenceInitFtraceEvent>; + + static constexpr FieldMetadata_Driver kDriver{}; + void set_driver(const char* data, size_t size) { + AppendBytes(FieldMetadata_Driver::kFieldId, data, size); + } + void set_driver(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Driver::kFieldId, chars.data, chars.size); + } + void set_driver(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Driver::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Seqno = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + FenceInitFtraceEvent>; + + static constexpr FieldMetadata_Seqno kSeqno{}; + void set_seqno(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Seqno::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Timeline = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + FenceInitFtraceEvent>; + + static constexpr FieldMetadata_Timeline kTimeline{}; + void set_timeline(const char* data, size_t size) { + AppendBytes(FieldMetadata_Timeline::kFieldId, data, size); + } + void set_timeline(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Timeline::kFieldId, chars.data, chars.size); + } + void set_timeline(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Timeline::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class FastrpcDmaMapFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + FastrpcDmaMapFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit FastrpcDmaMapFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit FastrpcDmaMapFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_cid() const { return at<1>().valid(); } + int32_t cid() const { return at<1>().as_int32(); } + bool has_fd() const { return at<2>().valid(); } + int32_t fd() const { return at<2>().as_int32(); } + bool has_phys() const { return at<3>().valid(); } + uint64_t phys() const { return at<3>().as_uint64(); } + bool has_size() const { return at<4>().valid(); } + uint64_t size() const { return at<4>().as_uint64(); } + bool has_len() const { return at<5>().valid(); } + uint64_t len() const { return at<5>().as_uint64(); } + bool has_attr() const { return at<6>().valid(); } + uint32_t attr() const { return at<6>().as_uint32(); } + bool has_mflags() const { return at<7>().valid(); } + int32_t mflags() const { return at<7>().as_int32(); } +}; + +class FastrpcDmaMapFtraceEvent : public ::protozero::Message { + public: + using Decoder = FastrpcDmaMapFtraceEvent_Decoder; + enum : int32_t { + kCidFieldNumber = 1, + kFdFieldNumber = 2, + kPhysFieldNumber = 3, + kSizeFieldNumber = 4, + kLenFieldNumber = 5, + kAttrFieldNumber = 6, + kMflagsFieldNumber = 7, + }; + static constexpr const char* GetName() { return ".perfetto.protos.FastrpcDmaMapFtraceEvent"; } + + + using FieldMetadata_Cid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + FastrpcDmaMapFtraceEvent>; + + static constexpr FieldMetadata_Cid kCid{}; + void set_cid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Cid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Fd = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + FastrpcDmaMapFtraceEvent>; + + static constexpr FieldMetadata_Fd kFd{}; + void set_fd(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Fd::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Phys = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + FastrpcDmaMapFtraceEvent>; + + static constexpr FieldMetadata_Phys kPhys{}; + void set_phys(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Phys::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Size = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + FastrpcDmaMapFtraceEvent>; + + static constexpr FieldMetadata_Size kSize{}; + void set_size(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Size::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Len = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + FastrpcDmaMapFtraceEvent>; + + static constexpr FieldMetadata_Len kLen{}; + void set_len(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Attr = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + FastrpcDmaMapFtraceEvent>; + + static constexpr FieldMetadata_Attr kAttr{}; + void set_attr(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Attr::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Mflags = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + FastrpcDmaMapFtraceEvent>; + + static constexpr FieldMetadata_Mflags kMflags{}; + void set_mflags(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Mflags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class FastrpcDmaUnmapFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + FastrpcDmaUnmapFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit FastrpcDmaUnmapFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit FastrpcDmaUnmapFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_cid() const { return at<1>().valid(); } + int32_t cid() const { return at<1>().as_int32(); } + bool has_phys() const { return at<2>().valid(); } + uint64_t phys() const { return at<2>().as_uint64(); } + bool has_size() const { return at<3>().valid(); } + uint64_t size() const { return at<3>().as_uint64(); } +}; + +class FastrpcDmaUnmapFtraceEvent : public ::protozero::Message { + public: + using Decoder = FastrpcDmaUnmapFtraceEvent_Decoder; + enum : int32_t { + kCidFieldNumber = 1, + kPhysFieldNumber = 2, + kSizeFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.FastrpcDmaUnmapFtraceEvent"; } + + + using FieldMetadata_Cid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + FastrpcDmaUnmapFtraceEvent>; + + static constexpr FieldMetadata_Cid kCid{}; + void set_cid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Cid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Phys = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + FastrpcDmaUnmapFtraceEvent>; + + static constexpr FieldMetadata_Phys kPhys{}; + void set_phys(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Phys::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Size = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + FastrpcDmaUnmapFtraceEvent>; + + static constexpr FieldMetadata_Size kSize{}; + void set_size(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Size::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class FastrpcDmaAllocFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + FastrpcDmaAllocFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit FastrpcDmaAllocFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit FastrpcDmaAllocFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_cid() const { return at<1>().valid(); } + int32_t cid() const { return at<1>().as_int32(); } + bool has_phys() const { return at<2>().valid(); } + uint64_t phys() const { return at<2>().as_uint64(); } + bool has_size() const { return at<3>().valid(); } + uint64_t size() const { return at<3>().as_uint64(); } + bool has_attr() const { return at<4>().valid(); } + uint64_t attr() const { return at<4>().as_uint64(); } + bool has_mflags() const { return at<5>().valid(); } + int32_t mflags() const { return at<5>().as_int32(); } +}; + +class FastrpcDmaAllocFtraceEvent : public ::protozero::Message { + public: + using Decoder = FastrpcDmaAllocFtraceEvent_Decoder; + enum : int32_t { + kCidFieldNumber = 1, + kPhysFieldNumber = 2, + kSizeFieldNumber = 3, + kAttrFieldNumber = 4, + kMflagsFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.FastrpcDmaAllocFtraceEvent"; } + + + using FieldMetadata_Cid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + FastrpcDmaAllocFtraceEvent>; + + static constexpr FieldMetadata_Cid kCid{}; + void set_cid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Cid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Phys = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + FastrpcDmaAllocFtraceEvent>; + + static constexpr FieldMetadata_Phys kPhys{}; + void set_phys(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Phys::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Size = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + FastrpcDmaAllocFtraceEvent>; + + static constexpr FieldMetadata_Size kSize{}; + void set_size(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Size::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Attr = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + FastrpcDmaAllocFtraceEvent>; + + static constexpr FieldMetadata_Attr kAttr{}; + void set_attr(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Attr::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Mflags = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + FastrpcDmaAllocFtraceEvent>; + + static constexpr FieldMetadata_Mflags kMflags{}; + void set_mflags(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Mflags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class FastrpcDmaFreeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + FastrpcDmaFreeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit FastrpcDmaFreeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit FastrpcDmaFreeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_cid() const { return at<1>().valid(); } + int32_t cid() const { return at<1>().as_int32(); } + bool has_phys() const { return at<2>().valid(); } + uint64_t phys() const { return at<2>().as_uint64(); } + bool has_size() const { return at<3>().valid(); } + uint64_t size() const { return at<3>().as_uint64(); } +}; + +class FastrpcDmaFreeFtraceEvent : public ::protozero::Message { + public: + using Decoder = FastrpcDmaFreeFtraceEvent_Decoder; + enum : int32_t { + kCidFieldNumber = 1, + kPhysFieldNumber = 2, + kSizeFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.FastrpcDmaFreeFtraceEvent"; } + + + using FieldMetadata_Cid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + FastrpcDmaFreeFtraceEvent>; + + static constexpr FieldMetadata_Cid kCid{}; + void set_cid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Cid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Phys = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + FastrpcDmaFreeFtraceEvent>; + + static constexpr FieldMetadata_Phys kPhys{}; + void set_phys(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Phys::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Size = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + FastrpcDmaFreeFtraceEvent>; + + static constexpr FieldMetadata_Size kSize{}; + void set_size(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Size::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class FastrpcDmaStatFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + FastrpcDmaStatFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit FastrpcDmaStatFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit FastrpcDmaStatFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_cid() const { return at<1>().valid(); } + int32_t cid() const { return at<1>().as_int32(); } + bool has_len() const { return at<2>().valid(); } + int64_t len() const { return at<2>().as_int64(); } + bool has_total_allocated() const { return at<3>().valid(); } + uint64_t total_allocated() const { return at<3>().as_uint64(); } +}; + +class FastrpcDmaStatFtraceEvent : public ::protozero::Message { + public: + using Decoder = FastrpcDmaStatFtraceEvent_Decoder; + enum : int32_t { + kCidFieldNumber = 1, + kLenFieldNumber = 2, + kTotalAllocatedFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.FastrpcDmaStatFtraceEvent"; } + + + using FieldMetadata_Cid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + FastrpcDmaStatFtraceEvent>; + + static constexpr FieldMetadata_Cid kCid{}; + void set_cid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Cid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Len = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + FastrpcDmaStatFtraceEvent>; + + static constexpr FieldMetadata_Len kLen{}; + void set_len(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TotalAllocated = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + FastrpcDmaStatFtraceEvent>; + + static constexpr FieldMetadata_TotalAllocated kTotalAllocated{}; + void set_total_allocated(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_TotalAllocated::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class F2fsGcEndFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + F2fsGcEndFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit F2fsGcEndFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit F2fsGcEndFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ret() const { return at<2>().valid(); } + int32_t ret() const { return at<2>().as_int32(); } + bool has_seg_freed() const { return at<3>().valid(); } + int32_t seg_freed() const { return at<3>().as_int32(); } + bool has_sec_freed() const { return at<4>().valid(); } + int32_t sec_freed() const { return at<4>().as_int32(); } + bool has_dirty_nodes() const { return at<5>().valid(); } + int64_t dirty_nodes() const { return at<5>().as_int64(); } + bool has_dirty_dents() const { return at<6>().valid(); } + int64_t dirty_dents() const { return at<6>().as_int64(); } + bool has_dirty_imeta() const { return at<7>().valid(); } + int64_t dirty_imeta() const { return at<7>().as_int64(); } + bool has_free_sec() const { return at<8>().valid(); } + uint32_t free_sec() const { return at<8>().as_uint32(); } + bool has_free_seg() const { return at<9>().valid(); } + uint32_t free_seg() const { return at<9>().as_uint32(); } + bool has_reserved_seg() const { return at<10>().valid(); } + int32_t reserved_seg() const { return at<10>().as_int32(); } + bool has_prefree_seg() const { return at<11>().valid(); } + uint32_t prefree_seg() const { return at<11>().as_uint32(); } +}; + +class F2fsGcEndFtraceEvent : public ::protozero::Message { + public: + using Decoder = F2fsGcEndFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kRetFieldNumber = 2, + kSegFreedFieldNumber = 3, + kSecFreedFieldNumber = 4, + kDirtyNodesFieldNumber = 5, + kDirtyDentsFieldNumber = 6, + kDirtyImetaFieldNumber = 7, + kFreeSecFieldNumber = 8, + kFreeSegFieldNumber = 9, + kReservedSegFieldNumber = 10, + kPrefreeSegFieldNumber = 11, + }; + static constexpr const char* GetName() { return ".perfetto.protos.F2fsGcEndFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsGcEndFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ret = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + F2fsGcEndFtraceEvent>; + + static constexpr FieldMetadata_Ret kRet{}; + void set_ret(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SegFreed = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + F2fsGcEndFtraceEvent>; + + static constexpr FieldMetadata_SegFreed kSegFreed{}; + void set_seg_freed(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_SegFreed::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SecFreed = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + F2fsGcEndFtraceEvent>; + + static constexpr FieldMetadata_SecFreed kSecFreed{}; + void set_sec_freed(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_SecFreed::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DirtyNodes = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + F2fsGcEndFtraceEvent>; + + static constexpr FieldMetadata_DirtyNodes kDirtyNodes{}; + void set_dirty_nodes(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_DirtyNodes::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DirtyDents = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + F2fsGcEndFtraceEvent>; + + static constexpr FieldMetadata_DirtyDents kDirtyDents{}; + void set_dirty_dents(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_DirtyDents::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DirtyImeta = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + F2fsGcEndFtraceEvent>; + + static constexpr FieldMetadata_DirtyImeta kDirtyImeta{}; + void set_dirty_imeta(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_DirtyImeta::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FreeSec = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + F2fsGcEndFtraceEvent>; + + static constexpr FieldMetadata_FreeSec kFreeSec{}; + void set_free_sec(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_FreeSec::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FreeSeg = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + F2fsGcEndFtraceEvent>; + + static constexpr FieldMetadata_FreeSeg kFreeSeg{}; + void set_free_seg(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_FreeSeg::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ReservedSeg = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + F2fsGcEndFtraceEvent>; + + static constexpr FieldMetadata_ReservedSeg kReservedSeg{}; + void set_reserved_seg(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ReservedSeg::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PrefreeSeg = + ::protozero::proto_utils::FieldMetadata< + 11, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + F2fsGcEndFtraceEvent>; + + static constexpr FieldMetadata_PrefreeSeg kPrefreeSeg{}; + void set_prefree_seg(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_PrefreeSeg::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class F2fsGcBeginFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + F2fsGcBeginFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit F2fsGcBeginFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit F2fsGcBeginFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_sync() const { return at<2>().valid(); } + uint32_t sync() const { return at<2>().as_uint32(); } + bool has_background() const { return at<3>().valid(); } + uint32_t background() const { return at<3>().as_uint32(); } + bool has_dirty_nodes() const { return at<4>().valid(); } + int64_t dirty_nodes() const { return at<4>().as_int64(); } + bool has_dirty_dents() const { return at<5>().valid(); } + int64_t dirty_dents() const { return at<5>().as_int64(); } + bool has_dirty_imeta() const { return at<6>().valid(); } + int64_t dirty_imeta() const { return at<6>().as_int64(); } + bool has_free_sec() const { return at<7>().valid(); } + uint32_t free_sec() const { return at<7>().as_uint32(); } + bool has_free_seg() const { return at<8>().valid(); } + uint32_t free_seg() const { return at<8>().as_uint32(); } + bool has_reserved_seg() const { return at<9>().valid(); } + int32_t reserved_seg() const { return at<9>().as_int32(); } + bool has_prefree_seg() const { return at<10>().valid(); } + uint32_t prefree_seg() const { return at<10>().as_uint32(); } + bool has_gc_type() const { return at<11>().valid(); } + int32_t gc_type() const { return at<11>().as_int32(); } + bool has_no_bg_gc() const { return at<12>().valid(); } + uint32_t no_bg_gc() const { return at<12>().as_uint32(); } + bool has_nr_free_secs() const { return at<13>().valid(); } + uint32_t nr_free_secs() const { return at<13>().as_uint32(); } +}; + +class F2fsGcBeginFtraceEvent : public ::protozero::Message { + public: + using Decoder = F2fsGcBeginFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kSyncFieldNumber = 2, + kBackgroundFieldNumber = 3, + kDirtyNodesFieldNumber = 4, + kDirtyDentsFieldNumber = 5, + kDirtyImetaFieldNumber = 6, + kFreeSecFieldNumber = 7, + kFreeSegFieldNumber = 8, + kReservedSegFieldNumber = 9, + kPrefreeSegFieldNumber = 10, + kGcTypeFieldNumber = 11, + kNoBgGcFieldNumber = 12, + kNrFreeSecsFieldNumber = 13, + }; + static constexpr const char* GetName() { return ".perfetto.protos.F2fsGcBeginFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsGcBeginFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Sync = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + F2fsGcBeginFtraceEvent>; + + static constexpr FieldMetadata_Sync kSync{}; + void set_sync(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Sync::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Background = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + F2fsGcBeginFtraceEvent>; + + static constexpr FieldMetadata_Background kBackground{}; + void set_background(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Background::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DirtyNodes = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + F2fsGcBeginFtraceEvent>; + + static constexpr FieldMetadata_DirtyNodes kDirtyNodes{}; + void set_dirty_nodes(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_DirtyNodes::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DirtyDents = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + F2fsGcBeginFtraceEvent>; + + static constexpr FieldMetadata_DirtyDents kDirtyDents{}; + void set_dirty_dents(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_DirtyDents::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DirtyImeta = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + F2fsGcBeginFtraceEvent>; + + static constexpr FieldMetadata_DirtyImeta kDirtyImeta{}; + void set_dirty_imeta(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_DirtyImeta::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FreeSec = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + F2fsGcBeginFtraceEvent>; + + static constexpr FieldMetadata_FreeSec kFreeSec{}; + void set_free_sec(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_FreeSec::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FreeSeg = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + F2fsGcBeginFtraceEvent>; + + static constexpr FieldMetadata_FreeSeg kFreeSeg{}; + void set_free_seg(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_FreeSeg::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ReservedSeg = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + F2fsGcBeginFtraceEvent>; + + static constexpr FieldMetadata_ReservedSeg kReservedSeg{}; + void set_reserved_seg(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ReservedSeg::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PrefreeSeg = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + F2fsGcBeginFtraceEvent>; + + static constexpr FieldMetadata_PrefreeSeg kPrefreeSeg{}; + void set_prefree_seg(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_PrefreeSeg::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_GcType = + ::protozero::proto_utils::FieldMetadata< + 11, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + F2fsGcBeginFtraceEvent>; + + static constexpr FieldMetadata_GcType kGcType{}; + void set_gc_type(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_GcType::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NoBgGc = + ::protozero::proto_utils::FieldMetadata< + 12, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + F2fsGcBeginFtraceEvent>; + + static constexpr FieldMetadata_NoBgGc kNoBgGc{}; + void set_no_bg_gc(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_NoBgGc::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NrFreeSecs = + ::protozero::proto_utils::FieldMetadata< + 13, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + F2fsGcBeginFtraceEvent>; + + static constexpr FieldMetadata_NrFreeSecs kNrFreeSecs{}; + void set_nr_free_secs(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_NrFreeSecs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class F2fsBackgroundGcFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + F2fsBackgroundGcFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit F2fsBackgroundGcFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit F2fsBackgroundGcFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_wait_ms() const { return at<2>().valid(); } + uint32_t wait_ms() const { return at<2>().as_uint32(); } + bool has_prefree() const { return at<3>().valid(); } + uint32_t prefree() const { return at<3>().as_uint32(); } + bool has_free() const { return at<4>().valid(); } + uint32_t free() const { return at<4>().as_uint32(); } +}; + +class F2fsBackgroundGcFtraceEvent : public ::protozero::Message { + public: + using Decoder = F2fsBackgroundGcFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kWaitMsFieldNumber = 2, + kPrefreeFieldNumber = 3, + kFreeFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.F2fsBackgroundGcFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsBackgroundGcFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_WaitMs = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + F2fsBackgroundGcFtraceEvent>; + + static constexpr FieldMetadata_WaitMs kWaitMs{}; + void set_wait_ms(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_WaitMs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Prefree = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + F2fsBackgroundGcFtraceEvent>; + + static constexpr FieldMetadata_Prefree kPrefree{}; + void set_prefree(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Prefree::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Free = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + F2fsBackgroundGcFtraceEvent>; + + static constexpr FieldMetadata_Free kFree{}; + void set_free(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Free::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class F2fsIostatLatencyFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + F2fsIostatLatencyFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit F2fsIostatLatencyFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit F2fsIostatLatencyFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_d_rd_avg() const { return at<1>().valid(); } + uint32_t d_rd_avg() const { return at<1>().as_uint32(); } + bool has_d_rd_cnt() const { return at<2>().valid(); } + uint32_t d_rd_cnt() const { return at<2>().as_uint32(); } + bool has_d_rd_peak() const { return at<3>().valid(); } + uint32_t d_rd_peak() const { return at<3>().as_uint32(); } + bool has_d_wr_as_avg() const { return at<4>().valid(); } + uint32_t d_wr_as_avg() const { return at<4>().as_uint32(); } + bool has_d_wr_as_cnt() const { return at<5>().valid(); } + uint32_t d_wr_as_cnt() const { return at<5>().as_uint32(); } + bool has_d_wr_as_peak() const { return at<6>().valid(); } + uint32_t d_wr_as_peak() const { return at<6>().as_uint32(); } + bool has_d_wr_s_avg() const { return at<7>().valid(); } + uint32_t d_wr_s_avg() const { return at<7>().as_uint32(); } + bool has_d_wr_s_cnt() const { return at<8>().valid(); } + uint32_t d_wr_s_cnt() const { return at<8>().as_uint32(); } + bool has_d_wr_s_peak() const { return at<9>().valid(); } + uint32_t d_wr_s_peak() const { return at<9>().as_uint32(); } + bool has_dev() const { return at<10>().valid(); } + uint64_t dev() const { return at<10>().as_uint64(); } + bool has_m_rd_avg() const { return at<11>().valid(); } + uint32_t m_rd_avg() const { return at<11>().as_uint32(); } + bool has_m_rd_cnt() const { return at<12>().valid(); } + uint32_t m_rd_cnt() const { return at<12>().as_uint32(); } + bool has_m_rd_peak() const { return at<13>().valid(); } + uint32_t m_rd_peak() const { return at<13>().as_uint32(); } + bool has_m_wr_as_avg() const { return at<14>().valid(); } + uint32_t m_wr_as_avg() const { return at<14>().as_uint32(); } + bool has_m_wr_as_cnt() const { return at<15>().valid(); } + uint32_t m_wr_as_cnt() const { return at<15>().as_uint32(); } + bool has_m_wr_as_peak() const { return at<16>().valid(); } + uint32_t m_wr_as_peak() const { return at<16>().as_uint32(); } + bool has_m_wr_s_avg() const { return at<17>().valid(); } + uint32_t m_wr_s_avg() const { return at<17>().as_uint32(); } + bool has_m_wr_s_cnt() const { return at<18>().valid(); } + uint32_t m_wr_s_cnt() const { return at<18>().as_uint32(); } + bool has_m_wr_s_peak() const { return at<19>().valid(); } + uint32_t m_wr_s_peak() const { return at<19>().as_uint32(); } + bool has_n_rd_avg() const { return at<20>().valid(); } + uint32_t n_rd_avg() const { return at<20>().as_uint32(); } + bool has_n_rd_cnt() const { return at<21>().valid(); } + uint32_t n_rd_cnt() const { return at<21>().as_uint32(); } + bool has_n_rd_peak() const { return at<22>().valid(); } + uint32_t n_rd_peak() const { return at<22>().as_uint32(); } + bool has_n_wr_as_avg() const { return at<23>().valid(); } + uint32_t n_wr_as_avg() const { return at<23>().as_uint32(); } + bool has_n_wr_as_cnt() const { return at<24>().valid(); } + uint32_t n_wr_as_cnt() const { return at<24>().as_uint32(); } + bool has_n_wr_as_peak() const { return at<25>().valid(); } + uint32_t n_wr_as_peak() const { return at<25>().as_uint32(); } + bool has_n_wr_s_avg() const { return at<26>().valid(); } + uint32_t n_wr_s_avg() const { return at<26>().as_uint32(); } + bool has_n_wr_s_cnt() const { return at<27>().valid(); } + uint32_t n_wr_s_cnt() const { return at<27>().as_uint32(); } + bool has_n_wr_s_peak() const { return at<28>().valid(); } + uint32_t n_wr_s_peak() const { return at<28>().as_uint32(); } +}; + +class F2fsIostatLatencyFtraceEvent : public ::protozero::Message { + public: + using Decoder = F2fsIostatLatencyFtraceEvent_Decoder; + enum : int32_t { + kDRdAvgFieldNumber = 1, + kDRdCntFieldNumber = 2, + kDRdPeakFieldNumber = 3, + kDWrAsAvgFieldNumber = 4, + kDWrAsCntFieldNumber = 5, + kDWrAsPeakFieldNumber = 6, + kDWrSAvgFieldNumber = 7, + kDWrSCntFieldNumber = 8, + kDWrSPeakFieldNumber = 9, + kDevFieldNumber = 10, + kMRdAvgFieldNumber = 11, + kMRdCntFieldNumber = 12, + kMRdPeakFieldNumber = 13, + kMWrAsAvgFieldNumber = 14, + kMWrAsCntFieldNumber = 15, + kMWrAsPeakFieldNumber = 16, + kMWrSAvgFieldNumber = 17, + kMWrSCntFieldNumber = 18, + kMWrSPeakFieldNumber = 19, + kNRdAvgFieldNumber = 20, + kNRdCntFieldNumber = 21, + kNRdPeakFieldNumber = 22, + kNWrAsAvgFieldNumber = 23, + kNWrAsCntFieldNumber = 24, + kNWrAsPeakFieldNumber = 25, + kNWrSAvgFieldNumber = 26, + kNWrSCntFieldNumber = 27, + kNWrSPeakFieldNumber = 28, + }; + static constexpr const char* GetName() { return ".perfetto.protos.F2fsIostatLatencyFtraceEvent"; } + + + using FieldMetadata_DRdAvg = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + F2fsIostatLatencyFtraceEvent>; + + static constexpr FieldMetadata_DRdAvg kDRdAvg{}; + void set_d_rd_avg(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_DRdAvg::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DRdCnt = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + F2fsIostatLatencyFtraceEvent>; + + static constexpr FieldMetadata_DRdCnt kDRdCnt{}; + void set_d_rd_cnt(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_DRdCnt::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DRdPeak = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + F2fsIostatLatencyFtraceEvent>; + + static constexpr FieldMetadata_DRdPeak kDRdPeak{}; + void set_d_rd_peak(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_DRdPeak::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DWrAsAvg = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + F2fsIostatLatencyFtraceEvent>; + + static constexpr FieldMetadata_DWrAsAvg kDWrAsAvg{}; + void set_d_wr_as_avg(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_DWrAsAvg::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DWrAsCnt = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + F2fsIostatLatencyFtraceEvent>; + + static constexpr FieldMetadata_DWrAsCnt kDWrAsCnt{}; + void set_d_wr_as_cnt(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_DWrAsCnt::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DWrAsPeak = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + F2fsIostatLatencyFtraceEvent>; + + static constexpr FieldMetadata_DWrAsPeak kDWrAsPeak{}; + void set_d_wr_as_peak(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_DWrAsPeak::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DWrSAvg = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + F2fsIostatLatencyFtraceEvent>; + + static constexpr FieldMetadata_DWrSAvg kDWrSAvg{}; + void set_d_wr_s_avg(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_DWrSAvg::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DWrSCnt = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + F2fsIostatLatencyFtraceEvent>; + + static constexpr FieldMetadata_DWrSCnt kDWrSCnt{}; + void set_d_wr_s_cnt(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_DWrSCnt::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DWrSPeak = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + F2fsIostatLatencyFtraceEvent>; + + static constexpr FieldMetadata_DWrSPeak kDWrSPeak{}; + void set_d_wr_s_peak(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_DWrSPeak::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsIostatLatencyFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_MRdAvg = + ::protozero::proto_utils::FieldMetadata< + 11, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + F2fsIostatLatencyFtraceEvent>; + + static constexpr FieldMetadata_MRdAvg kMRdAvg{}; + void set_m_rd_avg(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_MRdAvg::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_MRdCnt = + ::protozero::proto_utils::FieldMetadata< + 12, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + F2fsIostatLatencyFtraceEvent>; + + static constexpr FieldMetadata_MRdCnt kMRdCnt{}; + void set_m_rd_cnt(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_MRdCnt::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_MRdPeak = + ::protozero::proto_utils::FieldMetadata< + 13, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + F2fsIostatLatencyFtraceEvent>; + + static constexpr FieldMetadata_MRdPeak kMRdPeak{}; + void set_m_rd_peak(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_MRdPeak::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_MWrAsAvg = + ::protozero::proto_utils::FieldMetadata< + 14, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + F2fsIostatLatencyFtraceEvent>; + + static constexpr FieldMetadata_MWrAsAvg kMWrAsAvg{}; + void set_m_wr_as_avg(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_MWrAsAvg::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_MWrAsCnt = + ::protozero::proto_utils::FieldMetadata< + 15, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + F2fsIostatLatencyFtraceEvent>; + + static constexpr FieldMetadata_MWrAsCnt kMWrAsCnt{}; + void set_m_wr_as_cnt(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_MWrAsCnt::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_MWrAsPeak = + ::protozero::proto_utils::FieldMetadata< + 16, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + F2fsIostatLatencyFtraceEvent>; + + static constexpr FieldMetadata_MWrAsPeak kMWrAsPeak{}; + void set_m_wr_as_peak(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_MWrAsPeak::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_MWrSAvg = + ::protozero::proto_utils::FieldMetadata< + 17, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + F2fsIostatLatencyFtraceEvent>; + + static constexpr FieldMetadata_MWrSAvg kMWrSAvg{}; + void set_m_wr_s_avg(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_MWrSAvg::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_MWrSCnt = + ::protozero::proto_utils::FieldMetadata< + 18, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + F2fsIostatLatencyFtraceEvent>; + + static constexpr FieldMetadata_MWrSCnt kMWrSCnt{}; + void set_m_wr_s_cnt(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_MWrSCnt::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_MWrSPeak = + ::protozero::proto_utils::FieldMetadata< + 19, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + F2fsIostatLatencyFtraceEvent>; + + static constexpr FieldMetadata_MWrSPeak kMWrSPeak{}; + void set_m_wr_s_peak(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_MWrSPeak::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NRdAvg = + ::protozero::proto_utils::FieldMetadata< + 20, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + F2fsIostatLatencyFtraceEvent>; + + static constexpr FieldMetadata_NRdAvg kNRdAvg{}; + void set_n_rd_avg(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_NRdAvg::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NRdCnt = + ::protozero::proto_utils::FieldMetadata< + 21, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + F2fsIostatLatencyFtraceEvent>; + + static constexpr FieldMetadata_NRdCnt kNRdCnt{}; + void set_n_rd_cnt(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_NRdCnt::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NRdPeak = + ::protozero::proto_utils::FieldMetadata< + 22, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + F2fsIostatLatencyFtraceEvent>; + + static constexpr FieldMetadata_NRdPeak kNRdPeak{}; + void set_n_rd_peak(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_NRdPeak::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NWrAsAvg = + ::protozero::proto_utils::FieldMetadata< + 23, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + F2fsIostatLatencyFtraceEvent>; + + static constexpr FieldMetadata_NWrAsAvg kNWrAsAvg{}; + void set_n_wr_as_avg(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_NWrAsAvg::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NWrAsCnt = + ::protozero::proto_utils::FieldMetadata< + 24, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + F2fsIostatLatencyFtraceEvent>; + + static constexpr FieldMetadata_NWrAsCnt kNWrAsCnt{}; + void set_n_wr_as_cnt(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_NWrAsCnt::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NWrAsPeak = + ::protozero::proto_utils::FieldMetadata< + 25, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + F2fsIostatLatencyFtraceEvent>; + + static constexpr FieldMetadata_NWrAsPeak kNWrAsPeak{}; + void set_n_wr_as_peak(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_NWrAsPeak::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NWrSAvg = + ::protozero::proto_utils::FieldMetadata< + 26, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + F2fsIostatLatencyFtraceEvent>; + + static constexpr FieldMetadata_NWrSAvg kNWrSAvg{}; + void set_n_wr_s_avg(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_NWrSAvg::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NWrSCnt = + ::protozero::proto_utils::FieldMetadata< + 27, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + F2fsIostatLatencyFtraceEvent>; + + static constexpr FieldMetadata_NWrSCnt kNWrSCnt{}; + void set_n_wr_s_cnt(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_NWrSCnt::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NWrSPeak = + ::protozero::proto_utils::FieldMetadata< + 28, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + F2fsIostatLatencyFtraceEvent>; + + static constexpr FieldMetadata_NWrSPeak kNWrSPeak{}; + void set_n_wr_s_peak(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_NWrSPeak::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class F2fsIostatFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + F2fsIostatFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit F2fsIostatFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit F2fsIostatFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_app_bio() const { return at<1>().valid(); } + uint64_t app_bio() const { return at<1>().as_uint64(); } + bool has_app_brio() const { return at<2>().valid(); } + uint64_t app_brio() const { return at<2>().as_uint64(); } + bool has_app_dio() const { return at<3>().valid(); } + uint64_t app_dio() const { return at<3>().as_uint64(); } + bool has_app_drio() const { return at<4>().valid(); } + uint64_t app_drio() const { return at<4>().as_uint64(); } + bool has_app_mio() const { return at<5>().valid(); } + uint64_t app_mio() const { return at<5>().as_uint64(); } + bool has_app_mrio() const { return at<6>().valid(); } + uint64_t app_mrio() const { return at<6>().as_uint64(); } + bool has_app_rio() const { return at<7>().valid(); } + uint64_t app_rio() const { return at<7>().as_uint64(); } + bool has_app_wio() const { return at<8>().valid(); } + uint64_t app_wio() const { return at<8>().as_uint64(); } + bool has_dev() const { return at<9>().valid(); } + uint64_t dev() const { return at<9>().as_uint64(); } + bool has_fs_cdrio() const { return at<10>().valid(); } + uint64_t fs_cdrio() const { return at<10>().as_uint64(); } + bool has_fs_cp_dio() const { return at<11>().valid(); } + uint64_t fs_cp_dio() const { return at<11>().as_uint64(); } + bool has_fs_cp_mio() const { return at<12>().valid(); } + uint64_t fs_cp_mio() const { return at<12>().as_uint64(); } + bool has_fs_cp_nio() const { return at<13>().valid(); } + uint64_t fs_cp_nio() const { return at<13>().as_uint64(); } + bool has_fs_dio() const { return at<14>().valid(); } + uint64_t fs_dio() const { return at<14>().as_uint64(); } + bool has_fs_discard() const { return at<15>().valid(); } + uint64_t fs_discard() const { return at<15>().as_uint64(); } + bool has_fs_drio() const { return at<16>().valid(); } + uint64_t fs_drio() const { return at<16>().as_uint64(); } + bool has_fs_gc_dio() const { return at<17>().valid(); } + uint64_t fs_gc_dio() const { return at<17>().as_uint64(); } + bool has_fs_gc_nio() const { return at<18>().valid(); } + uint64_t fs_gc_nio() const { return at<18>().as_uint64(); } + bool has_fs_gdrio() const { return at<19>().valid(); } + uint64_t fs_gdrio() const { return at<19>().as_uint64(); } + bool has_fs_mio() const { return at<20>().valid(); } + uint64_t fs_mio() const { return at<20>().as_uint64(); } + bool has_fs_mrio() const { return at<21>().valid(); } + uint64_t fs_mrio() const { return at<21>().as_uint64(); } + bool has_fs_nio() const { return at<22>().valid(); } + uint64_t fs_nio() const { return at<22>().as_uint64(); } + bool has_fs_nrio() const { return at<23>().valid(); } + uint64_t fs_nrio() const { return at<23>().as_uint64(); } +}; + +class F2fsIostatFtraceEvent : public ::protozero::Message { + public: + using Decoder = F2fsIostatFtraceEvent_Decoder; + enum : int32_t { + kAppBioFieldNumber = 1, + kAppBrioFieldNumber = 2, + kAppDioFieldNumber = 3, + kAppDrioFieldNumber = 4, + kAppMioFieldNumber = 5, + kAppMrioFieldNumber = 6, + kAppRioFieldNumber = 7, + kAppWioFieldNumber = 8, + kDevFieldNumber = 9, + kFsCdrioFieldNumber = 10, + kFsCpDioFieldNumber = 11, + kFsCpMioFieldNumber = 12, + kFsCpNioFieldNumber = 13, + kFsDioFieldNumber = 14, + kFsDiscardFieldNumber = 15, + kFsDrioFieldNumber = 16, + kFsGcDioFieldNumber = 17, + kFsGcNioFieldNumber = 18, + kFsGdrioFieldNumber = 19, + kFsMioFieldNumber = 20, + kFsMrioFieldNumber = 21, + kFsNioFieldNumber = 22, + kFsNrioFieldNumber = 23, + }; + static constexpr const char* GetName() { return ".perfetto.protos.F2fsIostatFtraceEvent"; } + + + using FieldMetadata_AppBio = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsIostatFtraceEvent>; + + static constexpr FieldMetadata_AppBio kAppBio{}; + void set_app_bio(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_AppBio::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_AppBrio = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsIostatFtraceEvent>; + + static constexpr FieldMetadata_AppBrio kAppBrio{}; + void set_app_brio(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_AppBrio::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_AppDio = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsIostatFtraceEvent>; + + static constexpr FieldMetadata_AppDio kAppDio{}; + void set_app_dio(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_AppDio::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_AppDrio = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsIostatFtraceEvent>; + + static constexpr FieldMetadata_AppDrio kAppDrio{}; + void set_app_drio(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_AppDrio::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_AppMio = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsIostatFtraceEvent>; + + static constexpr FieldMetadata_AppMio kAppMio{}; + void set_app_mio(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_AppMio::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_AppMrio = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsIostatFtraceEvent>; + + static constexpr FieldMetadata_AppMrio kAppMrio{}; + void set_app_mrio(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_AppMrio::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_AppRio = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsIostatFtraceEvent>; + + static constexpr FieldMetadata_AppRio kAppRio{}; + void set_app_rio(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_AppRio::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_AppWio = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsIostatFtraceEvent>; + + static constexpr FieldMetadata_AppWio kAppWio{}; + void set_app_wio(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_AppWio::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsIostatFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FsCdrio = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsIostatFtraceEvent>; + + static constexpr FieldMetadata_FsCdrio kFsCdrio{}; + void set_fs_cdrio(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_FsCdrio::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FsCpDio = + ::protozero::proto_utils::FieldMetadata< + 11, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsIostatFtraceEvent>; + + static constexpr FieldMetadata_FsCpDio kFsCpDio{}; + void set_fs_cp_dio(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_FsCpDio::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FsCpMio = + ::protozero::proto_utils::FieldMetadata< + 12, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsIostatFtraceEvent>; + + static constexpr FieldMetadata_FsCpMio kFsCpMio{}; + void set_fs_cp_mio(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_FsCpMio::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FsCpNio = + ::protozero::proto_utils::FieldMetadata< + 13, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsIostatFtraceEvent>; + + static constexpr FieldMetadata_FsCpNio kFsCpNio{}; + void set_fs_cp_nio(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_FsCpNio::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FsDio = + ::protozero::proto_utils::FieldMetadata< + 14, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsIostatFtraceEvent>; + + static constexpr FieldMetadata_FsDio kFsDio{}; + void set_fs_dio(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_FsDio::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FsDiscard = + ::protozero::proto_utils::FieldMetadata< + 15, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsIostatFtraceEvent>; + + static constexpr FieldMetadata_FsDiscard kFsDiscard{}; + void set_fs_discard(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_FsDiscard::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FsDrio = + ::protozero::proto_utils::FieldMetadata< + 16, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsIostatFtraceEvent>; + + static constexpr FieldMetadata_FsDrio kFsDrio{}; + void set_fs_drio(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_FsDrio::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FsGcDio = + ::protozero::proto_utils::FieldMetadata< + 17, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsIostatFtraceEvent>; + + static constexpr FieldMetadata_FsGcDio kFsGcDio{}; + void set_fs_gc_dio(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_FsGcDio::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FsGcNio = + ::protozero::proto_utils::FieldMetadata< + 18, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsIostatFtraceEvent>; + + static constexpr FieldMetadata_FsGcNio kFsGcNio{}; + void set_fs_gc_nio(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_FsGcNio::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FsGdrio = + ::protozero::proto_utils::FieldMetadata< + 19, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsIostatFtraceEvent>; + + static constexpr FieldMetadata_FsGdrio kFsGdrio{}; + void set_fs_gdrio(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_FsGdrio::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FsMio = + ::protozero::proto_utils::FieldMetadata< + 20, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsIostatFtraceEvent>; + + static constexpr FieldMetadata_FsMio kFsMio{}; + void set_fs_mio(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_FsMio::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FsMrio = + ::protozero::proto_utils::FieldMetadata< + 21, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsIostatFtraceEvent>; + + static constexpr FieldMetadata_FsMrio kFsMrio{}; + void set_fs_mrio(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_FsMrio::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FsNio = + ::protozero::proto_utils::FieldMetadata< + 22, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsIostatFtraceEvent>; + + static constexpr FieldMetadata_FsNio kFsNio{}; + void set_fs_nio(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_FsNio::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FsNrio = + ::protozero::proto_utils::FieldMetadata< + 23, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsIostatFtraceEvent>; + + static constexpr FieldMetadata_FsNrio kFsNrio{}; + void set_fs_nrio(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_FsNrio::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class F2fsWriteEndFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + F2fsWriteEndFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit F2fsWriteEndFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit F2fsWriteEndFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_pos() const { return at<3>().valid(); } + int64_t pos() const { return at<3>().as_int64(); } + bool has_len() const { return at<4>().valid(); } + uint32_t len() const { return at<4>().as_uint32(); } + bool has_copied() const { return at<5>().valid(); } + uint32_t copied() const { return at<5>().as_uint32(); } +}; + +class F2fsWriteEndFtraceEvent : public ::protozero::Message { + public: + using Decoder = F2fsWriteEndFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kPosFieldNumber = 3, + kLenFieldNumber = 4, + kCopiedFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.F2fsWriteEndFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsWriteEndFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsWriteEndFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pos = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + F2fsWriteEndFtraceEvent>; + + static constexpr FieldMetadata_Pos kPos{}; + void set_pos(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pos::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Len = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + F2fsWriteEndFtraceEvent>; + + static constexpr FieldMetadata_Len kLen{}; + void set_len(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Copied = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + F2fsWriteEndFtraceEvent>; + + static constexpr FieldMetadata_Copied kCopied{}; + void set_copied(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Copied::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class F2fsWriteCheckpointFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + F2fsWriteCheckpointFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit F2fsWriteCheckpointFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit F2fsWriteCheckpointFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_is_umount() const { return at<2>().valid(); } + uint32_t is_umount() const { return at<2>().as_uint32(); } + bool has_msg() const { return at<3>().valid(); } + ::protozero::ConstChars msg() const { return at<3>().as_string(); } + bool has_reason() const { return at<4>().valid(); } + int32_t reason() const { return at<4>().as_int32(); } +}; + +class F2fsWriteCheckpointFtraceEvent : public ::protozero::Message { + public: + using Decoder = F2fsWriteCheckpointFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kIsUmountFieldNumber = 2, + kMsgFieldNumber = 3, + kReasonFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.F2fsWriteCheckpointFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsWriteCheckpointFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_IsUmount = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + F2fsWriteCheckpointFtraceEvent>; + + static constexpr FieldMetadata_IsUmount kIsUmount{}; + void set_is_umount(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_IsUmount::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Msg = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + F2fsWriteCheckpointFtraceEvent>; + + static constexpr FieldMetadata_Msg kMsg{}; + void set_msg(const char* data, size_t size) { + AppendBytes(FieldMetadata_Msg::kFieldId, data, size); + } + void set_msg(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Msg::kFieldId, chars.data, chars.size); + } + void set_msg(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Msg::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Reason = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + F2fsWriteCheckpointFtraceEvent>; + + static constexpr FieldMetadata_Reason kReason{}; + void set_reason(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Reason::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class F2fsWriteBeginFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + F2fsWriteBeginFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit F2fsWriteBeginFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit F2fsWriteBeginFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_pos() const { return at<3>().valid(); } + int64_t pos() const { return at<3>().as_int64(); } + bool has_len() const { return at<4>().valid(); } + uint32_t len() const { return at<4>().as_uint32(); } + bool has_flags() const { return at<5>().valid(); } + uint32_t flags() const { return at<5>().as_uint32(); } +}; + +class F2fsWriteBeginFtraceEvent : public ::protozero::Message { + public: + using Decoder = F2fsWriteBeginFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kPosFieldNumber = 3, + kLenFieldNumber = 4, + kFlagsFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.F2fsWriteBeginFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsWriteBeginFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsWriteBeginFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pos = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + F2fsWriteBeginFtraceEvent>; + + static constexpr FieldMetadata_Pos kPos{}; + void set_pos(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pos::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Len = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + F2fsWriteBeginFtraceEvent>; + + static constexpr FieldMetadata_Len kLen{}; + void set_len(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Flags = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + F2fsWriteBeginFtraceEvent>; + + static constexpr FieldMetadata_Flags kFlags{}; + void set_flags(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class F2fsVmPageMkwriteFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + F2fsVmPageMkwriteFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit F2fsVmPageMkwriteFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit F2fsVmPageMkwriteFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_type() const { return at<3>().valid(); } + int32_t type() const { return at<3>().as_int32(); } + bool has_dir() const { return at<4>().valid(); } + int32_t dir() const { return at<4>().as_int32(); } + bool has_index() const { return at<5>().valid(); } + uint64_t index() const { return at<5>().as_uint64(); } + bool has_dirty() const { return at<6>().valid(); } + int32_t dirty() const { return at<6>().as_int32(); } + bool has_uptodate() const { return at<7>().valid(); } + int32_t uptodate() const { return at<7>().as_int32(); } +}; + +class F2fsVmPageMkwriteFtraceEvent : public ::protozero::Message { + public: + using Decoder = F2fsVmPageMkwriteFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kTypeFieldNumber = 3, + kDirFieldNumber = 4, + kIndexFieldNumber = 5, + kDirtyFieldNumber = 6, + kUptodateFieldNumber = 7, + }; + static constexpr const char* GetName() { return ".perfetto.protos.F2fsVmPageMkwriteFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsVmPageMkwriteFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsVmPageMkwriteFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Type = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + F2fsVmPageMkwriteFtraceEvent>; + + static constexpr FieldMetadata_Type kType{}; + void set_type(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Dir = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + F2fsVmPageMkwriteFtraceEvent>; + + static constexpr FieldMetadata_Dir kDir{}; + void set_dir(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dir::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Index = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsVmPageMkwriteFtraceEvent>; + + static constexpr FieldMetadata_Index kIndex{}; + void set_index(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Index::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Dirty = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + F2fsVmPageMkwriteFtraceEvent>; + + static constexpr FieldMetadata_Dirty kDirty{}; + void set_dirty(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dirty::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Uptodate = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + F2fsVmPageMkwriteFtraceEvent>; + + static constexpr FieldMetadata_Uptodate kUptodate{}; + void set_uptodate(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Uptodate::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class F2fsUnlinkExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + F2fsUnlinkExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit F2fsUnlinkExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit F2fsUnlinkExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_ret() const { return at<3>().valid(); } + int32_t ret() const { return at<3>().as_int32(); } +}; + +class F2fsUnlinkExitFtraceEvent : public ::protozero::Message { + public: + using Decoder = F2fsUnlinkExitFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kRetFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.F2fsUnlinkExitFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsUnlinkExitFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsUnlinkExitFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ret = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + F2fsUnlinkExitFtraceEvent>; + + static constexpr FieldMetadata_Ret kRet{}; + void set_ret(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class F2fsUnlinkEnterFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + F2fsUnlinkEnterFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit F2fsUnlinkEnterFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit F2fsUnlinkEnterFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_size() const { return at<3>().valid(); } + int64_t size() const { return at<3>().as_int64(); } + bool has_blocks() const { return at<4>().valid(); } + uint64_t blocks() const { return at<4>().as_uint64(); } + bool has_name() const { return at<5>().valid(); } + ::protozero::ConstChars name() const { return at<5>().as_string(); } +}; + +class F2fsUnlinkEnterFtraceEvent : public ::protozero::Message { + public: + using Decoder = F2fsUnlinkEnterFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kSizeFieldNumber = 3, + kBlocksFieldNumber = 4, + kNameFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.F2fsUnlinkEnterFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsUnlinkEnterFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsUnlinkEnterFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Size = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + F2fsUnlinkEnterFtraceEvent>; + + static constexpr FieldMetadata_Size kSize{}; + void set_size(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Size::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Blocks = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsUnlinkEnterFtraceEvent>; + + static constexpr FieldMetadata_Blocks kBlocks{}; + void set_blocks(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Blocks::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + F2fsUnlinkEnterFtraceEvent>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class F2fsTruncatePartialNodesFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + F2fsTruncatePartialNodesFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit F2fsTruncatePartialNodesFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit F2fsTruncatePartialNodesFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_nid() const { return at<3>().valid(); } + uint32_t nid() const { return at<3>().as_uint32(); } + bool has_depth() const { return at<4>().valid(); } + int32_t depth() const { return at<4>().as_int32(); } + bool has_err() const { return at<5>().valid(); } + int32_t err() const { return at<5>().as_int32(); } +}; + +class F2fsTruncatePartialNodesFtraceEvent : public ::protozero::Message { + public: + using Decoder = F2fsTruncatePartialNodesFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kNidFieldNumber = 3, + kDepthFieldNumber = 4, + kErrFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.F2fsTruncatePartialNodesFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsTruncatePartialNodesFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsTruncatePartialNodesFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Nid = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + F2fsTruncatePartialNodesFtraceEvent>; + + static constexpr FieldMetadata_Nid kNid{}; + void set_nid(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Nid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Depth = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + F2fsTruncatePartialNodesFtraceEvent>; + + static constexpr FieldMetadata_Depth kDepth{}; + void set_depth(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Depth::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Err = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + F2fsTruncatePartialNodesFtraceEvent>; + + static constexpr FieldMetadata_Err kErr{}; + void set_err(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Err::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class F2fsTruncateNodesExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + F2fsTruncateNodesExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit F2fsTruncateNodesExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit F2fsTruncateNodesExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_ret() const { return at<3>().valid(); } + int32_t ret() const { return at<3>().as_int32(); } +}; + +class F2fsTruncateNodesExitFtraceEvent : public ::protozero::Message { + public: + using Decoder = F2fsTruncateNodesExitFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kRetFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.F2fsTruncateNodesExitFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsTruncateNodesExitFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsTruncateNodesExitFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ret = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + F2fsTruncateNodesExitFtraceEvent>; + + static constexpr FieldMetadata_Ret kRet{}; + void set_ret(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class F2fsTruncateNodesEnterFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + F2fsTruncateNodesEnterFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit F2fsTruncateNodesEnterFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit F2fsTruncateNodesEnterFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_nid() const { return at<3>().valid(); } + uint32_t nid() const { return at<3>().as_uint32(); } + bool has_blk_addr() const { return at<4>().valid(); } + uint32_t blk_addr() const { return at<4>().as_uint32(); } +}; + +class F2fsTruncateNodesEnterFtraceEvent : public ::protozero::Message { + public: + using Decoder = F2fsTruncateNodesEnterFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kNidFieldNumber = 3, + kBlkAddrFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.F2fsTruncateNodesEnterFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsTruncateNodesEnterFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsTruncateNodesEnterFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Nid = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + F2fsTruncateNodesEnterFtraceEvent>; + + static constexpr FieldMetadata_Nid kNid{}; + void set_nid(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Nid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_BlkAddr = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + F2fsTruncateNodesEnterFtraceEvent>; + + static constexpr FieldMetadata_BlkAddr kBlkAddr{}; + void set_blk_addr(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_BlkAddr::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class F2fsTruncateNodeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + F2fsTruncateNodeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit F2fsTruncateNodeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit F2fsTruncateNodeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_nid() const { return at<3>().valid(); } + uint32_t nid() const { return at<3>().as_uint32(); } + bool has_blk_addr() const { return at<4>().valid(); } + uint32_t blk_addr() const { return at<4>().as_uint32(); } +}; + +class F2fsTruncateNodeFtraceEvent : public ::protozero::Message { + public: + using Decoder = F2fsTruncateNodeFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kNidFieldNumber = 3, + kBlkAddrFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.F2fsTruncateNodeFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsTruncateNodeFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsTruncateNodeFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Nid = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + F2fsTruncateNodeFtraceEvent>; + + static constexpr FieldMetadata_Nid kNid{}; + void set_nid(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Nid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_BlkAddr = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + F2fsTruncateNodeFtraceEvent>; + + static constexpr FieldMetadata_BlkAddr kBlkAddr{}; + void set_blk_addr(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_BlkAddr::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class F2fsTruncateInodeBlocksExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + F2fsTruncateInodeBlocksExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit F2fsTruncateInodeBlocksExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit F2fsTruncateInodeBlocksExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_ret() const { return at<3>().valid(); } + int32_t ret() const { return at<3>().as_int32(); } +}; + +class F2fsTruncateInodeBlocksExitFtraceEvent : public ::protozero::Message { + public: + using Decoder = F2fsTruncateInodeBlocksExitFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kRetFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.F2fsTruncateInodeBlocksExitFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsTruncateInodeBlocksExitFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsTruncateInodeBlocksExitFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ret = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + F2fsTruncateInodeBlocksExitFtraceEvent>; + + static constexpr FieldMetadata_Ret kRet{}; + void set_ret(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class F2fsTruncateInodeBlocksEnterFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + F2fsTruncateInodeBlocksEnterFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit F2fsTruncateInodeBlocksEnterFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit F2fsTruncateInodeBlocksEnterFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_size() const { return at<3>().valid(); } + int64_t size() const { return at<3>().as_int64(); } + bool has_blocks() const { return at<4>().valid(); } + uint64_t blocks() const { return at<4>().as_uint64(); } + bool has_from() const { return at<5>().valid(); } + uint64_t from() const { return at<5>().as_uint64(); } +}; + +class F2fsTruncateInodeBlocksEnterFtraceEvent : public ::protozero::Message { + public: + using Decoder = F2fsTruncateInodeBlocksEnterFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kSizeFieldNumber = 3, + kBlocksFieldNumber = 4, + kFromFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.F2fsTruncateInodeBlocksEnterFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsTruncateInodeBlocksEnterFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsTruncateInodeBlocksEnterFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Size = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + F2fsTruncateInodeBlocksEnterFtraceEvent>; + + static constexpr FieldMetadata_Size kSize{}; + void set_size(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Size::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Blocks = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsTruncateInodeBlocksEnterFtraceEvent>; + + static constexpr FieldMetadata_Blocks kBlocks{}; + void set_blocks(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Blocks::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_From = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsTruncateInodeBlocksEnterFtraceEvent>; + + static constexpr FieldMetadata_From kFrom{}; + void set_from(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_From::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class F2fsTruncateDataBlocksRangeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + F2fsTruncateDataBlocksRangeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit F2fsTruncateDataBlocksRangeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit F2fsTruncateDataBlocksRangeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_nid() const { return at<3>().valid(); } + uint32_t nid() const { return at<3>().as_uint32(); } + bool has_ofs() const { return at<4>().valid(); } + uint32_t ofs() const { return at<4>().as_uint32(); } + bool has_free() const { return at<5>().valid(); } + int32_t free() const { return at<5>().as_int32(); } +}; + +class F2fsTruncateDataBlocksRangeFtraceEvent : public ::protozero::Message { + public: + using Decoder = F2fsTruncateDataBlocksRangeFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kNidFieldNumber = 3, + kOfsFieldNumber = 4, + kFreeFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.F2fsTruncateDataBlocksRangeFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsTruncateDataBlocksRangeFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsTruncateDataBlocksRangeFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Nid = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + F2fsTruncateDataBlocksRangeFtraceEvent>; + + static constexpr FieldMetadata_Nid kNid{}; + void set_nid(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Nid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ofs = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + F2fsTruncateDataBlocksRangeFtraceEvent>; + + static constexpr FieldMetadata_Ofs kOfs{}; + void set_ofs(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ofs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Free = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + F2fsTruncateDataBlocksRangeFtraceEvent>; + + static constexpr FieldMetadata_Free kFree{}; + void set_free(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Free::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class F2fsTruncateBlocksExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + F2fsTruncateBlocksExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit F2fsTruncateBlocksExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit F2fsTruncateBlocksExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_ret() const { return at<3>().valid(); } + int32_t ret() const { return at<3>().as_int32(); } +}; + +class F2fsTruncateBlocksExitFtraceEvent : public ::protozero::Message { + public: + using Decoder = F2fsTruncateBlocksExitFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kRetFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.F2fsTruncateBlocksExitFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsTruncateBlocksExitFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsTruncateBlocksExitFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ret = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + F2fsTruncateBlocksExitFtraceEvent>; + + static constexpr FieldMetadata_Ret kRet{}; + void set_ret(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class F2fsTruncateBlocksEnterFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + F2fsTruncateBlocksEnterFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit F2fsTruncateBlocksEnterFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit F2fsTruncateBlocksEnterFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_size() const { return at<3>().valid(); } + int64_t size() const { return at<3>().as_int64(); } + bool has_blocks() const { return at<4>().valid(); } + uint64_t blocks() const { return at<4>().as_uint64(); } + bool has_from() const { return at<5>().valid(); } + uint64_t from() const { return at<5>().as_uint64(); } +}; + +class F2fsTruncateBlocksEnterFtraceEvent : public ::protozero::Message { + public: + using Decoder = F2fsTruncateBlocksEnterFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kSizeFieldNumber = 3, + kBlocksFieldNumber = 4, + kFromFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.F2fsTruncateBlocksEnterFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsTruncateBlocksEnterFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsTruncateBlocksEnterFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Size = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + F2fsTruncateBlocksEnterFtraceEvent>; + + static constexpr FieldMetadata_Size kSize{}; + void set_size(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Size::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Blocks = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsTruncateBlocksEnterFtraceEvent>; + + static constexpr FieldMetadata_Blocks kBlocks{}; + void set_blocks(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Blocks::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_From = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsTruncateBlocksEnterFtraceEvent>; + + static constexpr FieldMetadata_From kFrom{}; + void set_from(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_From::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class F2fsTruncateFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + F2fsTruncateFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit F2fsTruncateFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit F2fsTruncateFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_pino() const { return at<3>().valid(); } + uint64_t pino() const { return at<3>().as_uint64(); } + bool has_mode() const { return at<4>().valid(); } + uint32_t mode() const { return at<4>().as_uint32(); } + bool has_size() const { return at<5>().valid(); } + int64_t size() const { return at<5>().as_int64(); } + bool has_nlink() const { return at<6>().valid(); } + uint32_t nlink() const { return at<6>().as_uint32(); } + bool has_blocks() const { return at<7>().valid(); } + uint64_t blocks() const { return at<7>().as_uint64(); } + bool has_advise() const { return at<8>().valid(); } + uint32_t advise() const { return at<8>().as_uint32(); } +}; + +class F2fsTruncateFtraceEvent : public ::protozero::Message { + public: + using Decoder = F2fsTruncateFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kPinoFieldNumber = 3, + kModeFieldNumber = 4, + kSizeFieldNumber = 5, + kNlinkFieldNumber = 6, + kBlocksFieldNumber = 7, + kAdviseFieldNumber = 8, + }; + static constexpr const char* GetName() { return ".perfetto.protos.F2fsTruncateFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsTruncateFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsTruncateFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pino = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsTruncateFtraceEvent>; + + static constexpr FieldMetadata_Pino kPino{}; + void set_pino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Mode = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + F2fsTruncateFtraceEvent>; + + static constexpr FieldMetadata_Mode kMode{}; + void set_mode(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Mode::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Size = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + F2fsTruncateFtraceEvent>; + + static constexpr FieldMetadata_Size kSize{}; + void set_size(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Size::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Nlink = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + F2fsTruncateFtraceEvent>; + + static constexpr FieldMetadata_Nlink kNlink{}; + void set_nlink(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Nlink::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Blocks = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsTruncateFtraceEvent>; + + static constexpr FieldMetadata_Blocks kBlocks{}; + void set_blocks(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Blocks::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Advise = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + F2fsTruncateFtraceEvent>; + + static constexpr FieldMetadata_Advise kAdvise{}; + void set_advise(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Advise::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class F2fsSyncFsFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + F2fsSyncFsFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit F2fsSyncFsFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit F2fsSyncFsFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_dirty() const { return at<2>().valid(); } + int32_t dirty() const { return at<2>().as_int32(); } + bool has_wait() const { return at<3>().valid(); } + int32_t wait() const { return at<3>().as_int32(); } +}; + +class F2fsSyncFsFtraceEvent : public ::protozero::Message { + public: + using Decoder = F2fsSyncFsFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kDirtyFieldNumber = 2, + kWaitFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.F2fsSyncFsFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsSyncFsFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Dirty = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + F2fsSyncFsFtraceEvent>; + + static constexpr FieldMetadata_Dirty kDirty{}; + void set_dirty(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dirty::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Wait = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + F2fsSyncFsFtraceEvent>; + + static constexpr FieldMetadata_Wait kWait{}; + void set_wait(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Wait::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class F2fsSyncFileExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + F2fsSyncFileExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit F2fsSyncFileExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit F2fsSyncFileExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_need_cp() const { return at<3>().valid(); } + uint32_t need_cp() const { return at<3>().as_uint32(); } + bool has_datasync() const { return at<4>().valid(); } + int32_t datasync() const { return at<4>().as_int32(); } + bool has_ret() const { return at<5>().valid(); } + int32_t ret() const { return at<5>().as_int32(); } + bool has_cp_reason() const { return at<6>().valid(); } + int32_t cp_reason() const { return at<6>().as_int32(); } +}; + +class F2fsSyncFileExitFtraceEvent : public ::protozero::Message { + public: + using Decoder = F2fsSyncFileExitFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kNeedCpFieldNumber = 3, + kDatasyncFieldNumber = 4, + kRetFieldNumber = 5, + kCpReasonFieldNumber = 6, + }; + static constexpr const char* GetName() { return ".perfetto.protos.F2fsSyncFileExitFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsSyncFileExitFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsSyncFileExitFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NeedCp = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + F2fsSyncFileExitFtraceEvent>; + + static constexpr FieldMetadata_NeedCp kNeedCp{}; + void set_need_cp(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_NeedCp::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Datasync = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + F2fsSyncFileExitFtraceEvent>; + + static constexpr FieldMetadata_Datasync kDatasync{}; + void set_datasync(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Datasync::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ret = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + F2fsSyncFileExitFtraceEvent>; + + static constexpr FieldMetadata_Ret kRet{}; + void set_ret(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CpReason = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + F2fsSyncFileExitFtraceEvent>; + + static constexpr FieldMetadata_CpReason kCpReason{}; + void set_cp_reason(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_CpReason::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class F2fsSyncFileEnterFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + F2fsSyncFileEnterFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit F2fsSyncFileEnterFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit F2fsSyncFileEnterFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_pino() const { return at<3>().valid(); } + uint64_t pino() const { return at<3>().as_uint64(); } + bool has_mode() const { return at<4>().valid(); } + uint32_t mode() const { return at<4>().as_uint32(); } + bool has_size() const { return at<5>().valid(); } + int64_t size() const { return at<5>().as_int64(); } + bool has_nlink() const { return at<6>().valid(); } + uint32_t nlink() const { return at<6>().as_uint32(); } + bool has_blocks() const { return at<7>().valid(); } + uint64_t blocks() const { return at<7>().as_uint64(); } + bool has_advise() const { return at<8>().valid(); } + uint32_t advise() const { return at<8>().as_uint32(); } +}; + +class F2fsSyncFileEnterFtraceEvent : public ::protozero::Message { + public: + using Decoder = F2fsSyncFileEnterFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kPinoFieldNumber = 3, + kModeFieldNumber = 4, + kSizeFieldNumber = 5, + kNlinkFieldNumber = 6, + kBlocksFieldNumber = 7, + kAdviseFieldNumber = 8, + }; + static constexpr const char* GetName() { return ".perfetto.protos.F2fsSyncFileEnterFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsSyncFileEnterFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsSyncFileEnterFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pino = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsSyncFileEnterFtraceEvent>; + + static constexpr FieldMetadata_Pino kPino{}; + void set_pino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Mode = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + F2fsSyncFileEnterFtraceEvent>; + + static constexpr FieldMetadata_Mode kMode{}; + void set_mode(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Mode::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Size = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + F2fsSyncFileEnterFtraceEvent>; + + static constexpr FieldMetadata_Size kSize{}; + void set_size(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Size::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Nlink = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + F2fsSyncFileEnterFtraceEvent>; + + static constexpr FieldMetadata_Nlink kNlink{}; + void set_nlink(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Nlink::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Blocks = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsSyncFileEnterFtraceEvent>; + + static constexpr FieldMetadata_Blocks kBlocks{}; + void set_blocks(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Blocks::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Advise = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + F2fsSyncFileEnterFtraceEvent>; + + static constexpr FieldMetadata_Advise kAdvise{}; + void set_advise(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Advise::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class F2fsSubmitWritePageFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + F2fsSubmitWritePageFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit F2fsSubmitWritePageFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit F2fsSubmitWritePageFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_type() const { return at<3>().valid(); } + int32_t type() const { return at<3>().as_int32(); } + bool has_index() const { return at<4>().valid(); } + uint64_t index() const { return at<4>().as_uint64(); } + bool has_block() const { return at<5>().valid(); } + uint32_t block() const { return at<5>().as_uint32(); } +}; + +class F2fsSubmitWritePageFtraceEvent : public ::protozero::Message { + public: + using Decoder = F2fsSubmitWritePageFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kTypeFieldNumber = 3, + kIndexFieldNumber = 4, + kBlockFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.F2fsSubmitWritePageFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsSubmitWritePageFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsSubmitWritePageFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Type = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + F2fsSubmitWritePageFtraceEvent>; + + static constexpr FieldMetadata_Type kType{}; + void set_type(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Index = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsSubmitWritePageFtraceEvent>; + + static constexpr FieldMetadata_Index kIndex{}; + void set_index(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Index::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Block = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + F2fsSubmitWritePageFtraceEvent>; + + static constexpr FieldMetadata_Block kBlock{}; + void set_block(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Block::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class F2fsSetPageDirtyFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + F2fsSetPageDirtyFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit F2fsSetPageDirtyFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit F2fsSetPageDirtyFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_type() const { return at<3>().valid(); } + int32_t type() const { return at<3>().as_int32(); } + bool has_dir() const { return at<4>().valid(); } + int32_t dir() const { return at<4>().as_int32(); } + bool has_index() const { return at<5>().valid(); } + uint64_t index() const { return at<5>().as_uint64(); } + bool has_dirty() const { return at<6>().valid(); } + int32_t dirty() const { return at<6>().as_int32(); } + bool has_uptodate() const { return at<7>().valid(); } + int32_t uptodate() const { return at<7>().as_int32(); } +}; + +class F2fsSetPageDirtyFtraceEvent : public ::protozero::Message { + public: + using Decoder = F2fsSetPageDirtyFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kTypeFieldNumber = 3, + kDirFieldNumber = 4, + kIndexFieldNumber = 5, + kDirtyFieldNumber = 6, + kUptodateFieldNumber = 7, + }; + static constexpr const char* GetName() { return ".perfetto.protos.F2fsSetPageDirtyFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsSetPageDirtyFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsSetPageDirtyFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Type = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + F2fsSetPageDirtyFtraceEvent>; + + static constexpr FieldMetadata_Type kType{}; + void set_type(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Dir = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + F2fsSetPageDirtyFtraceEvent>; + + static constexpr FieldMetadata_Dir kDir{}; + void set_dir(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dir::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Index = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsSetPageDirtyFtraceEvent>; + + static constexpr FieldMetadata_Index kIndex{}; + void set_index(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Index::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Dirty = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + F2fsSetPageDirtyFtraceEvent>; + + static constexpr FieldMetadata_Dirty kDirty{}; + void set_dirty(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dirty::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Uptodate = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + F2fsSetPageDirtyFtraceEvent>; + + static constexpr FieldMetadata_Uptodate kUptodate{}; + void set_uptodate(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Uptodate::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class F2fsReserveNewBlockFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + F2fsReserveNewBlockFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit F2fsReserveNewBlockFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit F2fsReserveNewBlockFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_nid() const { return at<2>().valid(); } + uint32_t nid() const { return at<2>().as_uint32(); } + bool has_ofs_in_node() const { return at<3>().valid(); } + uint32_t ofs_in_node() const { return at<3>().as_uint32(); } +}; + +class F2fsReserveNewBlockFtraceEvent : public ::protozero::Message { + public: + using Decoder = F2fsReserveNewBlockFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kNidFieldNumber = 2, + kOfsInNodeFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.F2fsReserveNewBlockFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsReserveNewBlockFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Nid = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + F2fsReserveNewBlockFtraceEvent>; + + static constexpr FieldMetadata_Nid kNid{}; + void set_nid(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Nid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_OfsInNode = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + F2fsReserveNewBlockFtraceEvent>; + + static constexpr FieldMetadata_OfsInNode kOfsInNode{}; + void set_ofs_in_node(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_OfsInNode::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class F2fsReadpageFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + F2fsReadpageFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit F2fsReadpageFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit F2fsReadpageFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_index() const { return at<3>().valid(); } + uint64_t index() const { return at<3>().as_uint64(); } + bool has_blkaddr() const { return at<4>().valid(); } + uint64_t blkaddr() const { return at<4>().as_uint64(); } + bool has_type() const { return at<5>().valid(); } + int32_t type() const { return at<5>().as_int32(); } + bool has_dir() const { return at<6>().valid(); } + int32_t dir() const { return at<6>().as_int32(); } + bool has_dirty() const { return at<7>().valid(); } + int32_t dirty() const { return at<7>().as_int32(); } + bool has_uptodate() const { return at<8>().valid(); } + int32_t uptodate() const { return at<8>().as_int32(); } +}; + +class F2fsReadpageFtraceEvent : public ::protozero::Message { + public: + using Decoder = F2fsReadpageFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kIndexFieldNumber = 3, + kBlkaddrFieldNumber = 4, + kTypeFieldNumber = 5, + kDirFieldNumber = 6, + kDirtyFieldNumber = 7, + kUptodateFieldNumber = 8, + }; + static constexpr const char* GetName() { return ".perfetto.protos.F2fsReadpageFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsReadpageFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsReadpageFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Index = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsReadpageFtraceEvent>; + + static constexpr FieldMetadata_Index kIndex{}; + void set_index(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Index::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Blkaddr = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsReadpageFtraceEvent>; + + static constexpr FieldMetadata_Blkaddr kBlkaddr{}; + void set_blkaddr(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Blkaddr::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Type = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + F2fsReadpageFtraceEvent>; + + static constexpr FieldMetadata_Type kType{}; + void set_type(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Dir = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + F2fsReadpageFtraceEvent>; + + static constexpr FieldMetadata_Dir kDir{}; + void set_dir(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dir::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Dirty = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + F2fsReadpageFtraceEvent>; + + static constexpr FieldMetadata_Dirty kDirty{}; + void set_dirty(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dirty::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Uptodate = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + F2fsReadpageFtraceEvent>; + + static constexpr FieldMetadata_Uptodate kUptodate{}; + void set_uptodate(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Uptodate::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class F2fsNewInodeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + F2fsNewInodeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit F2fsNewInodeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit F2fsNewInodeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_ret() const { return at<3>().valid(); } + int32_t ret() const { return at<3>().as_int32(); } +}; + +class F2fsNewInodeFtraceEvent : public ::protozero::Message { + public: + using Decoder = F2fsNewInodeFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kRetFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.F2fsNewInodeFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsNewInodeFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsNewInodeFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ret = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + F2fsNewInodeFtraceEvent>; + + static constexpr FieldMetadata_Ret kRet{}; + void set_ret(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class F2fsIgetExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + F2fsIgetExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit F2fsIgetExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit F2fsIgetExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_ret() const { return at<3>().valid(); } + int32_t ret() const { return at<3>().as_int32(); } +}; + +class F2fsIgetExitFtraceEvent : public ::protozero::Message { + public: + using Decoder = F2fsIgetExitFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kRetFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.F2fsIgetExitFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsIgetExitFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsIgetExitFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ret = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + F2fsIgetExitFtraceEvent>; + + static constexpr FieldMetadata_Ret kRet{}; + void set_ret(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class F2fsIgetFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + F2fsIgetFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit F2fsIgetFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit F2fsIgetFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_pino() const { return at<3>().valid(); } + uint64_t pino() const { return at<3>().as_uint64(); } + bool has_mode() const { return at<4>().valid(); } + uint32_t mode() const { return at<4>().as_uint32(); } + bool has_size() const { return at<5>().valid(); } + int64_t size() const { return at<5>().as_int64(); } + bool has_nlink() const { return at<6>().valid(); } + uint32_t nlink() const { return at<6>().as_uint32(); } + bool has_blocks() const { return at<7>().valid(); } + uint64_t blocks() const { return at<7>().as_uint64(); } + bool has_advise() const { return at<8>().valid(); } + uint32_t advise() const { return at<8>().as_uint32(); } +}; + +class F2fsIgetFtraceEvent : public ::protozero::Message { + public: + using Decoder = F2fsIgetFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kPinoFieldNumber = 3, + kModeFieldNumber = 4, + kSizeFieldNumber = 5, + kNlinkFieldNumber = 6, + kBlocksFieldNumber = 7, + kAdviseFieldNumber = 8, + }; + static constexpr const char* GetName() { return ".perfetto.protos.F2fsIgetFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsIgetFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsIgetFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pino = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsIgetFtraceEvent>; + + static constexpr FieldMetadata_Pino kPino{}; + void set_pino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Mode = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + F2fsIgetFtraceEvent>; + + static constexpr FieldMetadata_Mode kMode{}; + void set_mode(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Mode::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Size = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + F2fsIgetFtraceEvent>; + + static constexpr FieldMetadata_Size kSize{}; + void set_size(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Size::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Nlink = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + F2fsIgetFtraceEvent>; + + static constexpr FieldMetadata_Nlink kNlink{}; + void set_nlink(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Nlink::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Blocks = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsIgetFtraceEvent>; + + static constexpr FieldMetadata_Blocks kBlocks{}; + void set_blocks(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Blocks::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Advise = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + F2fsIgetFtraceEvent>; + + static constexpr FieldMetadata_Advise kAdvise{}; + void set_advise(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Advise::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class F2fsGetVictimFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + F2fsGetVictimFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit F2fsGetVictimFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit F2fsGetVictimFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_type() const { return at<2>().valid(); } + int32_t type() const { return at<2>().as_int32(); } + bool has_gc_type() const { return at<3>().valid(); } + int32_t gc_type() const { return at<3>().as_int32(); } + bool has_alloc_mode() const { return at<4>().valid(); } + int32_t alloc_mode() const { return at<4>().as_int32(); } + bool has_gc_mode() const { return at<5>().valid(); } + int32_t gc_mode() const { return at<5>().as_int32(); } + bool has_victim() const { return at<6>().valid(); } + uint32_t victim() const { return at<6>().as_uint32(); } + bool has_ofs_unit() const { return at<7>().valid(); } + uint32_t ofs_unit() const { return at<7>().as_uint32(); } + bool has_pre_victim() const { return at<8>().valid(); } + uint32_t pre_victim() const { return at<8>().as_uint32(); } + bool has_prefree() const { return at<9>().valid(); } + uint32_t prefree() const { return at<9>().as_uint32(); } + bool has_free() const { return at<10>().valid(); } + uint32_t free() const { return at<10>().as_uint32(); } + bool has_cost() const { return at<11>().valid(); } + uint32_t cost() const { return at<11>().as_uint32(); } +}; + +class F2fsGetVictimFtraceEvent : public ::protozero::Message { + public: + using Decoder = F2fsGetVictimFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kTypeFieldNumber = 2, + kGcTypeFieldNumber = 3, + kAllocModeFieldNumber = 4, + kGcModeFieldNumber = 5, + kVictimFieldNumber = 6, + kOfsUnitFieldNumber = 7, + kPreVictimFieldNumber = 8, + kPrefreeFieldNumber = 9, + kFreeFieldNumber = 10, + kCostFieldNumber = 11, + }; + static constexpr const char* GetName() { return ".perfetto.protos.F2fsGetVictimFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsGetVictimFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Type = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + F2fsGetVictimFtraceEvent>; + + static constexpr FieldMetadata_Type kType{}; + void set_type(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_GcType = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + F2fsGetVictimFtraceEvent>; + + static constexpr FieldMetadata_GcType kGcType{}; + void set_gc_type(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_GcType::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_AllocMode = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + F2fsGetVictimFtraceEvent>; + + static constexpr FieldMetadata_AllocMode kAllocMode{}; + void set_alloc_mode(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_AllocMode::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_GcMode = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + F2fsGetVictimFtraceEvent>; + + static constexpr FieldMetadata_GcMode kGcMode{}; + void set_gc_mode(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_GcMode::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Victim = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + F2fsGetVictimFtraceEvent>; + + static constexpr FieldMetadata_Victim kVictim{}; + void set_victim(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Victim::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_OfsUnit = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + F2fsGetVictimFtraceEvent>; + + static constexpr FieldMetadata_OfsUnit kOfsUnit{}; + void set_ofs_unit(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_OfsUnit::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PreVictim = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + F2fsGetVictimFtraceEvent>; + + static constexpr FieldMetadata_PreVictim kPreVictim{}; + void set_pre_victim(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_PreVictim::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Prefree = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + F2fsGetVictimFtraceEvent>; + + static constexpr FieldMetadata_Prefree kPrefree{}; + void set_prefree(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Prefree::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Free = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + F2fsGetVictimFtraceEvent>; + + static constexpr FieldMetadata_Free kFree{}; + void set_free(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Free::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Cost = + ::protozero::proto_utils::FieldMetadata< + 11, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + F2fsGetVictimFtraceEvent>; + + static constexpr FieldMetadata_Cost kCost{}; + void set_cost(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Cost::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class F2fsGetDataBlockFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + F2fsGetDataBlockFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit F2fsGetDataBlockFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit F2fsGetDataBlockFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_iblock() const { return at<3>().valid(); } + uint64_t iblock() const { return at<3>().as_uint64(); } + bool has_bh_start() const { return at<4>().valid(); } + uint64_t bh_start() const { return at<4>().as_uint64(); } + bool has_bh_size() const { return at<5>().valid(); } + uint64_t bh_size() const { return at<5>().as_uint64(); } + bool has_ret() const { return at<6>().valid(); } + int32_t ret() const { return at<6>().as_int32(); } +}; + +class F2fsGetDataBlockFtraceEvent : public ::protozero::Message { + public: + using Decoder = F2fsGetDataBlockFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kIblockFieldNumber = 3, + kBhStartFieldNumber = 4, + kBhSizeFieldNumber = 5, + kRetFieldNumber = 6, + }; + static constexpr const char* GetName() { return ".perfetto.protos.F2fsGetDataBlockFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsGetDataBlockFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsGetDataBlockFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Iblock = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsGetDataBlockFtraceEvent>; + + static constexpr FieldMetadata_Iblock kIblock{}; + void set_iblock(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Iblock::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_BhStart = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsGetDataBlockFtraceEvent>; + + static constexpr FieldMetadata_BhStart kBhStart{}; + void set_bh_start(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_BhStart::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_BhSize = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsGetDataBlockFtraceEvent>; + + static constexpr FieldMetadata_BhSize kBhSize{}; + void set_bh_size(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_BhSize::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ret = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + F2fsGetDataBlockFtraceEvent>; + + static constexpr FieldMetadata_Ret kRet{}; + void set_ret(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class F2fsFallocateFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + F2fsFallocateFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit F2fsFallocateFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit F2fsFallocateFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_mode() const { return at<3>().valid(); } + int32_t mode() const { return at<3>().as_int32(); } + bool has_offset() const { return at<4>().valid(); } + int64_t offset() const { return at<4>().as_int64(); } + bool has_len() const { return at<5>().valid(); } + int64_t len() const { return at<5>().as_int64(); } + bool has_size() const { return at<6>().valid(); } + int64_t size() const { return at<6>().as_int64(); } + bool has_blocks() const { return at<7>().valid(); } + uint64_t blocks() const { return at<7>().as_uint64(); } + bool has_ret() const { return at<8>().valid(); } + int32_t ret() const { return at<8>().as_int32(); } +}; + +class F2fsFallocateFtraceEvent : public ::protozero::Message { + public: + using Decoder = F2fsFallocateFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kModeFieldNumber = 3, + kOffsetFieldNumber = 4, + kLenFieldNumber = 5, + kSizeFieldNumber = 6, + kBlocksFieldNumber = 7, + kRetFieldNumber = 8, + }; + static constexpr const char* GetName() { return ".perfetto.protos.F2fsFallocateFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsFallocateFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsFallocateFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Mode = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + F2fsFallocateFtraceEvent>; + + static constexpr FieldMetadata_Mode kMode{}; + void set_mode(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Mode::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Offset = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + F2fsFallocateFtraceEvent>; + + static constexpr FieldMetadata_Offset kOffset{}; + void set_offset(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Offset::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Len = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + F2fsFallocateFtraceEvent>; + + static constexpr FieldMetadata_Len kLen{}; + void set_len(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Size = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + F2fsFallocateFtraceEvent>; + + static constexpr FieldMetadata_Size kSize{}; + void set_size(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Size::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Blocks = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsFallocateFtraceEvent>; + + static constexpr FieldMetadata_Blocks kBlocks{}; + void set_blocks(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Blocks::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ret = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + F2fsFallocateFtraceEvent>; + + static constexpr FieldMetadata_Ret kRet{}; + void set_ret(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class F2fsEvictInodeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + F2fsEvictInodeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit F2fsEvictInodeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit F2fsEvictInodeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_pino() const { return at<3>().valid(); } + uint64_t pino() const { return at<3>().as_uint64(); } + bool has_mode() const { return at<4>().valid(); } + uint32_t mode() const { return at<4>().as_uint32(); } + bool has_size() const { return at<5>().valid(); } + int64_t size() const { return at<5>().as_int64(); } + bool has_nlink() const { return at<6>().valid(); } + uint32_t nlink() const { return at<6>().as_uint32(); } + bool has_blocks() const { return at<7>().valid(); } + uint64_t blocks() const { return at<7>().as_uint64(); } + bool has_advise() const { return at<8>().valid(); } + uint32_t advise() const { return at<8>().as_uint32(); } +}; + +class F2fsEvictInodeFtraceEvent : public ::protozero::Message { + public: + using Decoder = F2fsEvictInodeFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kPinoFieldNumber = 3, + kModeFieldNumber = 4, + kSizeFieldNumber = 5, + kNlinkFieldNumber = 6, + kBlocksFieldNumber = 7, + kAdviseFieldNumber = 8, + }; + static constexpr const char* GetName() { return ".perfetto.protos.F2fsEvictInodeFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsEvictInodeFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsEvictInodeFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pino = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsEvictInodeFtraceEvent>; + + static constexpr FieldMetadata_Pino kPino{}; + void set_pino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Mode = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + F2fsEvictInodeFtraceEvent>; + + static constexpr FieldMetadata_Mode kMode{}; + void set_mode(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Mode::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Size = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + F2fsEvictInodeFtraceEvent>; + + static constexpr FieldMetadata_Size kSize{}; + void set_size(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Size::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Nlink = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + F2fsEvictInodeFtraceEvent>; + + static constexpr FieldMetadata_Nlink kNlink{}; + void set_nlink(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Nlink::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Blocks = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsEvictInodeFtraceEvent>; + + static constexpr FieldMetadata_Blocks kBlocks{}; + void set_blocks(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Blocks::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Advise = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + F2fsEvictInodeFtraceEvent>; + + static constexpr FieldMetadata_Advise kAdvise{}; + void set_advise(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Advise::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class F2fsDoSubmitBioFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + F2fsDoSubmitBioFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit F2fsDoSubmitBioFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit F2fsDoSubmitBioFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_btype() const { return at<2>().valid(); } + int32_t btype() const { return at<2>().as_int32(); } + bool has_sync() const { return at<3>().valid(); } + uint32_t sync() const { return at<3>().as_uint32(); } + bool has_sector() const { return at<4>().valid(); } + uint64_t sector() const { return at<4>().as_uint64(); } + bool has_size() const { return at<5>().valid(); } + uint32_t size() const { return at<5>().as_uint32(); } +}; + +class F2fsDoSubmitBioFtraceEvent : public ::protozero::Message { + public: + using Decoder = F2fsDoSubmitBioFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kBtypeFieldNumber = 2, + kSyncFieldNumber = 3, + kSectorFieldNumber = 4, + kSizeFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.F2fsDoSubmitBioFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsDoSubmitBioFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Btype = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + F2fsDoSubmitBioFtraceEvent>; + + static constexpr FieldMetadata_Btype kBtype{}; + void set_btype(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Btype::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Sync = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + F2fsDoSubmitBioFtraceEvent>; + + static constexpr FieldMetadata_Sync kSync{}; + void set_sync(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Sync::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Sector = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + F2fsDoSubmitBioFtraceEvent>; + + static constexpr FieldMetadata_Sector kSector{}; + void set_sector(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Sector::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Size = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + F2fsDoSubmitBioFtraceEvent>; + + static constexpr FieldMetadata_Size kSize{}; + void set_size(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Size::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class Ext4ZeroRangeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4ZeroRangeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4ZeroRangeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4ZeroRangeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_offset() const { return at<3>().valid(); } + int64_t offset() const { return at<3>().as_int64(); } + bool has_len() const { return at<4>().valid(); } + int64_t len() const { return at<4>().as_int64(); } + bool has_mode() const { return at<5>().valid(); } + int32_t mode() const { return at<5>().as_int32(); } +}; + +class Ext4ZeroRangeFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4ZeroRangeFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kOffsetFieldNumber = 3, + kLenFieldNumber = 4, + kModeFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4ZeroRangeFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4ZeroRangeFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4ZeroRangeFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Offset = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + Ext4ZeroRangeFtraceEvent>; + + static constexpr FieldMetadata_Offset kOffset{}; + void set_offset(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Offset::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Len = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + Ext4ZeroRangeFtraceEvent>; + + static constexpr FieldMetadata_Len kLen{}; + void set_len(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Mode = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4ZeroRangeFtraceEvent>; + + static constexpr FieldMetadata_Mode kMode{}; + void set_mode(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Mode::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class Ext4WritepagesResultFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4WritepagesResultFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4WritepagesResultFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4WritepagesResultFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_ret() const { return at<3>().valid(); } + int32_t ret() const { return at<3>().as_int32(); } + bool has_pages_written() const { return at<4>().valid(); } + int32_t pages_written() const { return at<4>().as_int32(); } + bool has_pages_skipped() const { return at<5>().valid(); } + int64_t pages_skipped() const { return at<5>().as_int64(); } + bool has_writeback_index() const { return at<6>().valid(); } + uint64_t writeback_index() const { return at<6>().as_uint64(); } + bool has_sync_mode() const { return at<7>().valid(); } + int32_t sync_mode() const { return at<7>().as_int32(); } +}; + +class Ext4WritepagesResultFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4WritepagesResultFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kRetFieldNumber = 3, + kPagesWrittenFieldNumber = 4, + kPagesSkippedFieldNumber = 5, + kWritebackIndexFieldNumber = 6, + kSyncModeFieldNumber = 7, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4WritepagesResultFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4WritepagesResultFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4WritepagesResultFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ret = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4WritepagesResultFtraceEvent>; + + static constexpr FieldMetadata_Ret kRet{}; + void set_ret(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PagesWritten = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4WritepagesResultFtraceEvent>; + + static constexpr FieldMetadata_PagesWritten kPagesWritten{}; + void set_pages_written(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_PagesWritten::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PagesSkipped = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + Ext4WritepagesResultFtraceEvent>; + + static constexpr FieldMetadata_PagesSkipped kPagesSkipped{}; + void set_pages_skipped(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_PagesSkipped::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_WritebackIndex = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4WritepagesResultFtraceEvent>; + + static constexpr FieldMetadata_WritebackIndex kWritebackIndex{}; + void set_writeback_index(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_WritebackIndex::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SyncMode = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4WritepagesResultFtraceEvent>; + + static constexpr FieldMetadata_SyncMode kSyncMode{}; + void set_sync_mode(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_SyncMode::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class Ext4WritepagesFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4WritepagesFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4WritepagesFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4WritepagesFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_nr_to_write() const { return at<3>().valid(); } + int64_t nr_to_write() const { return at<3>().as_int64(); } + bool has_pages_skipped() const { return at<4>().valid(); } + int64_t pages_skipped() const { return at<4>().as_int64(); } + bool has_range_start() const { return at<5>().valid(); } + int64_t range_start() const { return at<5>().as_int64(); } + bool has_range_end() const { return at<6>().valid(); } + int64_t range_end() const { return at<6>().as_int64(); } + bool has_writeback_index() const { return at<7>().valid(); } + uint64_t writeback_index() const { return at<7>().as_uint64(); } + bool has_sync_mode() const { return at<8>().valid(); } + int32_t sync_mode() const { return at<8>().as_int32(); } + bool has_for_kupdate() const { return at<9>().valid(); } + uint32_t for_kupdate() const { return at<9>().as_uint32(); } + bool has_range_cyclic() const { return at<10>().valid(); } + uint32_t range_cyclic() const { return at<10>().as_uint32(); } +}; + +class Ext4WritepagesFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4WritepagesFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kNrToWriteFieldNumber = 3, + kPagesSkippedFieldNumber = 4, + kRangeStartFieldNumber = 5, + kRangeEndFieldNumber = 6, + kWritebackIndexFieldNumber = 7, + kSyncModeFieldNumber = 8, + kForKupdateFieldNumber = 9, + kRangeCyclicFieldNumber = 10, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4WritepagesFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4WritepagesFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4WritepagesFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NrToWrite = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + Ext4WritepagesFtraceEvent>; + + static constexpr FieldMetadata_NrToWrite kNrToWrite{}; + void set_nr_to_write(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_NrToWrite::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PagesSkipped = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + Ext4WritepagesFtraceEvent>; + + static constexpr FieldMetadata_PagesSkipped kPagesSkipped{}; + void set_pages_skipped(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_PagesSkipped::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_RangeStart = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + Ext4WritepagesFtraceEvent>; + + static constexpr FieldMetadata_RangeStart kRangeStart{}; + void set_range_start(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_RangeStart::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_RangeEnd = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + Ext4WritepagesFtraceEvent>; + + static constexpr FieldMetadata_RangeEnd kRangeEnd{}; + void set_range_end(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_RangeEnd::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_WritebackIndex = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4WritepagesFtraceEvent>; + + static constexpr FieldMetadata_WritebackIndex kWritebackIndex{}; + void set_writeback_index(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_WritebackIndex::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SyncMode = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4WritepagesFtraceEvent>; + + static constexpr FieldMetadata_SyncMode kSyncMode{}; + void set_sync_mode(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_SyncMode::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ForKupdate = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4WritepagesFtraceEvent>; + + static constexpr FieldMetadata_ForKupdate kForKupdate{}; + void set_for_kupdate(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ForKupdate::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_RangeCyclic = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4WritepagesFtraceEvent>; + + static constexpr FieldMetadata_RangeCyclic kRangeCyclic{}; + void set_range_cyclic(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_RangeCyclic::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class Ext4WritepageFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4WritepageFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4WritepageFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4WritepageFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_index() const { return at<3>().valid(); } + uint64_t index() const { return at<3>().as_uint64(); } +}; + +class Ext4WritepageFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4WritepageFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kIndexFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4WritepageFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4WritepageFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4WritepageFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Index = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4WritepageFtraceEvent>; + + static constexpr FieldMetadata_Index kIndex{}; + void set_index(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Index::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class Ext4WriteEndFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4WriteEndFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4WriteEndFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4WriteEndFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_pos() const { return at<3>().valid(); } + int64_t pos() const { return at<3>().as_int64(); } + bool has_len() const { return at<4>().valid(); } + uint32_t len() const { return at<4>().as_uint32(); } + bool has_copied() const { return at<5>().valid(); } + uint32_t copied() const { return at<5>().as_uint32(); } +}; + +class Ext4WriteEndFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4WriteEndFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kPosFieldNumber = 3, + kLenFieldNumber = 4, + kCopiedFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4WriteEndFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4WriteEndFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4WriteEndFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pos = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + Ext4WriteEndFtraceEvent>; + + static constexpr FieldMetadata_Pos kPos{}; + void set_pos(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pos::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Len = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4WriteEndFtraceEvent>; + + static constexpr FieldMetadata_Len kLen{}; + void set_len(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Copied = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4WriteEndFtraceEvent>; + + static constexpr FieldMetadata_Copied kCopied{}; + void set_copied(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Copied::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class Ext4WriteBeginFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4WriteBeginFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4WriteBeginFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4WriteBeginFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_pos() const { return at<3>().valid(); } + int64_t pos() const { return at<3>().as_int64(); } + bool has_len() const { return at<4>().valid(); } + uint32_t len() const { return at<4>().as_uint32(); } + bool has_flags() const { return at<5>().valid(); } + uint32_t flags() const { return at<5>().as_uint32(); } +}; + +class Ext4WriteBeginFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4WriteBeginFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kPosFieldNumber = 3, + kLenFieldNumber = 4, + kFlagsFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4WriteBeginFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4WriteBeginFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4WriteBeginFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pos = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + Ext4WriteBeginFtraceEvent>; + + static constexpr FieldMetadata_Pos kPos{}; + void set_pos(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pos::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Len = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4WriteBeginFtraceEvent>; + + static constexpr FieldMetadata_Len kLen{}; + void set_len(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Flags = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4WriteBeginFtraceEvent>; + + static constexpr FieldMetadata_Flags kFlags{}; + void set_flags(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class Ext4UnlinkExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4UnlinkExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4UnlinkExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4UnlinkExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_ret() const { return at<3>().valid(); } + int32_t ret() const { return at<3>().as_int32(); } +}; + +class Ext4UnlinkExitFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4UnlinkExitFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kRetFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4UnlinkExitFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4UnlinkExitFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4UnlinkExitFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ret = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4UnlinkExitFtraceEvent>; + + static constexpr FieldMetadata_Ret kRet{}; + void set_ret(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class Ext4UnlinkEnterFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4UnlinkEnterFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4UnlinkEnterFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4UnlinkEnterFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_parent() const { return at<3>().valid(); } + uint64_t parent() const { return at<3>().as_uint64(); } + bool has_size() const { return at<4>().valid(); } + int64_t size() const { return at<4>().as_int64(); } +}; + +class Ext4UnlinkEnterFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4UnlinkEnterFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kParentFieldNumber = 3, + kSizeFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4UnlinkEnterFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4UnlinkEnterFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4UnlinkEnterFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Parent = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4UnlinkEnterFtraceEvent>; + + static constexpr FieldMetadata_Parent kParent{}; + void set_parent(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Parent::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Size = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + Ext4UnlinkEnterFtraceEvent>; + + static constexpr FieldMetadata_Size kSize{}; + void set_size(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Size::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } +}; + +class Ext4TruncateExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4TruncateExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4TruncateExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4TruncateExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_blocks() const { return at<3>().valid(); } + uint64_t blocks() const { return at<3>().as_uint64(); } +}; + +class Ext4TruncateExitFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4TruncateExitFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kBlocksFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4TruncateExitFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4TruncateExitFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4TruncateExitFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Blocks = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4TruncateExitFtraceEvent>; + + static constexpr FieldMetadata_Blocks kBlocks{}; + void set_blocks(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Blocks::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class Ext4TruncateEnterFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4TruncateEnterFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4TruncateEnterFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4TruncateEnterFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_blocks() const { return at<3>().valid(); } + uint64_t blocks() const { return at<3>().as_uint64(); } +}; + +class Ext4TruncateEnterFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4TruncateEnterFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kBlocksFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4TruncateEnterFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4TruncateEnterFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4TruncateEnterFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Blocks = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4TruncateEnterFtraceEvent>; + + static constexpr FieldMetadata_Blocks kBlocks{}; + void set_blocks(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Blocks::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class Ext4TrimExtentFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4TrimExtentFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4TrimExtentFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4TrimExtentFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev_major() const { return at<1>().valid(); } + int32_t dev_major() const { return at<1>().as_int32(); } + bool has_dev_minor() const { return at<2>().valid(); } + int32_t dev_minor() const { return at<2>().as_int32(); } + bool has_group() const { return at<3>().valid(); } + uint32_t group() const { return at<3>().as_uint32(); } + bool has_start() const { return at<4>().valid(); } + int32_t start() const { return at<4>().as_int32(); } + bool has_len() const { return at<5>().valid(); } + int32_t len() const { return at<5>().as_int32(); } +}; + +class Ext4TrimExtentFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4TrimExtentFtraceEvent_Decoder; + enum : int32_t { + kDevMajorFieldNumber = 1, + kDevMinorFieldNumber = 2, + kGroupFieldNumber = 3, + kStartFieldNumber = 4, + kLenFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4TrimExtentFtraceEvent"; } + + + using FieldMetadata_DevMajor = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4TrimExtentFtraceEvent>; + + static constexpr FieldMetadata_DevMajor kDevMajor{}; + void set_dev_major(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_DevMajor::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DevMinor = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4TrimExtentFtraceEvent>; + + static constexpr FieldMetadata_DevMinor kDevMinor{}; + void set_dev_minor(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_DevMinor::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Group = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4TrimExtentFtraceEvent>; + + static constexpr FieldMetadata_Group kGroup{}; + void set_group(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Group::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Start = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4TrimExtentFtraceEvent>; + + static constexpr FieldMetadata_Start kStart{}; + void set_start(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Start::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Len = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4TrimExtentFtraceEvent>; + + static constexpr FieldMetadata_Len kLen{}; + void set_len(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class Ext4TrimAllFreeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4TrimAllFreeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4TrimAllFreeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4TrimAllFreeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev_major() const { return at<1>().valid(); } + int32_t dev_major() const { return at<1>().as_int32(); } + bool has_dev_minor() const { return at<2>().valid(); } + int32_t dev_minor() const { return at<2>().as_int32(); } + bool has_group() const { return at<3>().valid(); } + uint32_t group() const { return at<3>().as_uint32(); } + bool has_start() const { return at<4>().valid(); } + int32_t start() const { return at<4>().as_int32(); } + bool has_len() const { return at<5>().valid(); } + int32_t len() const { return at<5>().as_int32(); } +}; + +class Ext4TrimAllFreeFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4TrimAllFreeFtraceEvent_Decoder; + enum : int32_t { + kDevMajorFieldNumber = 1, + kDevMinorFieldNumber = 2, + kGroupFieldNumber = 3, + kStartFieldNumber = 4, + kLenFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4TrimAllFreeFtraceEvent"; } + + + using FieldMetadata_DevMajor = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4TrimAllFreeFtraceEvent>; + + static constexpr FieldMetadata_DevMajor kDevMajor{}; + void set_dev_major(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_DevMajor::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DevMinor = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4TrimAllFreeFtraceEvent>; + + static constexpr FieldMetadata_DevMinor kDevMinor{}; + void set_dev_minor(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_DevMinor::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Group = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4TrimAllFreeFtraceEvent>; + + static constexpr FieldMetadata_Group kGroup{}; + void set_group(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Group::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Start = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4TrimAllFreeFtraceEvent>; + + static constexpr FieldMetadata_Start kStart{}; + void set_start(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Start::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Len = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4TrimAllFreeFtraceEvent>; + + static constexpr FieldMetadata_Len kLen{}; + void set_len(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class Ext4SyncFsFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4SyncFsFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4SyncFsFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4SyncFsFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_wait() const { return at<2>().valid(); } + int32_t wait() const { return at<2>().as_int32(); } +}; + +class Ext4SyncFsFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4SyncFsFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kWaitFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4SyncFsFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4SyncFsFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Wait = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4SyncFsFtraceEvent>; + + static constexpr FieldMetadata_Wait kWait{}; + void set_wait(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Wait::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class Ext4RequestInodeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4RequestInodeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4RequestInodeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4RequestInodeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_dir() const { return at<2>().valid(); } + uint64_t dir() const { return at<2>().as_uint64(); } + bool has_mode() const { return at<3>().valid(); } + uint32_t mode() const { return at<3>().as_uint32(); } +}; + +class Ext4RequestInodeFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4RequestInodeFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kDirFieldNumber = 2, + kModeFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4RequestInodeFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4RequestInodeFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Dir = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4RequestInodeFtraceEvent>; + + static constexpr FieldMetadata_Dir kDir{}; + void set_dir(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dir::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Mode = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4RequestInodeFtraceEvent>; + + static constexpr FieldMetadata_Mode kMode{}; + void set_mode(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Mode::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class Ext4RequestBlocksFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4RequestBlocksFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4RequestBlocksFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4RequestBlocksFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_len() const { return at<3>().valid(); } + uint32_t len() const { return at<3>().as_uint32(); } + bool has_logical() const { return at<4>().valid(); } + uint32_t logical() const { return at<4>().as_uint32(); } + bool has_lleft() const { return at<5>().valid(); } + uint32_t lleft() const { return at<5>().as_uint32(); } + bool has_lright() const { return at<6>().valid(); } + uint32_t lright() const { return at<6>().as_uint32(); } + bool has_goal() const { return at<7>().valid(); } + uint64_t goal() const { return at<7>().as_uint64(); } + bool has_pleft() const { return at<8>().valid(); } + uint64_t pleft() const { return at<8>().as_uint64(); } + bool has_pright() const { return at<9>().valid(); } + uint64_t pright() const { return at<9>().as_uint64(); } + bool has_flags() const { return at<10>().valid(); } + uint32_t flags() const { return at<10>().as_uint32(); } +}; + +class Ext4RequestBlocksFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4RequestBlocksFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kLenFieldNumber = 3, + kLogicalFieldNumber = 4, + kLleftFieldNumber = 5, + kLrightFieldNumber = 6, + kGoalFieldNumber = 7, + kPleftFieldNumber = 8, + kPrightFieldNumber = 9, + kFlagsFieldNumber = 10, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4RequestBlocksFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4RequestBlocksFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4RequestBlocksFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Len = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4RequestBlocksFtraceEvent>; + + static constexpr FieldMetadata_Len kLen{}; + void set_len(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Logical = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4RequestBlocksFtraceEvent>; + + static constexpr FieldMetadata_Logical kLogical{}; + void set_logical(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Logical::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Lleft = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4RequestBlocksFtraceEvent>; + + static constexpr FieldMetadata_Lleft kLleft{}; + void set_lleft(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Lleft::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Lright = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4RequestBlocksFtraceEvent>; + + static constexpr FieldMetadata_Lright kLright{}; + void set_lright(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Lright::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Goal = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4RequestBlocksFtraceEvent>; + + static constexpr FieldMetadata_Goal kGoal{}; + void set_goal(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Goal::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pleft = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4RequestBlocksFtraceEvent>; + + static constexpr FieldMetadata_Pleft kPleft{}; + void set_pleft(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pleft::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pright = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4RequestBlocksFtraceEvent>; + + static constexpr FieldMetadata_Pright kPright{}; + void set_pright(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pright::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Flags = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4RequestBlocksFtraceEvent>; + + static constexpr FieldMetadata_Flags kFlags{}; + void set_flags(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class Ext4RemoveBlocksFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4RemoveBlocksFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4RemoveBlocksFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4RemoveBlocksFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_from() const { return at<3>().valid(); } + uint32_t from() const { return at<3>().as_uint32(); } + bool has_to() const { return at<4>().valid(); } + uint32_t to() const { return at<4>().as_uint32(); } + bool has_partial() const { return at<5>().valid(); } + int64_t partial() const { return at<5>().as_int64(); } + bool has_ee_pblk() const { return at<6>().valid(); } + uint64_t ee_pblk() const { return at<6>().as_uint64(); } + bool has_ee_lblk() const { return at<7>().valid(); } + uint32_t ee_lblk() const { return at<7>().as_uint32(); } + bool has_ee_len() const { return at<8>().valid(); } + uint32_t ee_len() const { return at<8>().as_uint32(); } + bool has_pc_lblk() const { return at<9>().valid(); } + uint32_t pc_lblk() const { return at<9>().as_uint32(); } + bool has_pc_pclu() const { return at<10>().valid(); } + uint64_t pc_pclu() const { return at<10>().as_uint64(); } + bool has_pc_state() const { return at<11>().valid(); } + int32_t pc_state() const { return at<11>().as_int32(); } +}; + +class Ext4RemoveBlocksFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4RemoveBlocksFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kFromFieldNumber = 3, + kToFieldNumber = 4, + kPartialFieldNumber = 5, + kEePblkFieldNumber = 6, + kEeLblkFieldNumber = 7, + kEeLenFieldNumber = 8, + kPcLblkFieldNumber = 9, + kPcPcluFieldNumber = 10, + kPcStateFieldNumber = 11, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4RemoveBlocksFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4RemoveBlocksFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4RemoveBlocksFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_From = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4RemoveBlocksFtraceEvent>; + + static constexpr FieldMetadata_From kFrom{}; + void set_from(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_From::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_To = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4RemoveBlocksFtraceEvent>; + + static constexpr FieldMetadata_To kTo{}; + void set_to(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_To::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Partial = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + Ext4RemoveBlocksFtraceEvent>; + + static constexpr FieldMetadata_Partial kPartial{}; + void set_partial(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Partial::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_EePblk = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4RemoveBlocksFtraceEvent>; + + static constexpr FieldMetadata_EePblk kEePblk{}; + void set_ee_pblk(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_EePblk::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_EeLblk = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4RemoveBlocksFtraceEvent>; + + static constexpr FieldMetadata_EeLblk kEeLblk{}; + void set_ee_lblk(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_EeLblk::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_EeLen = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4RemoveBlocksFtraceEvent>; + + static constexpr FieldMetadata_EeLen kEeLen{}; + void set_ee_len(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_EeLen::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PcLblk = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4RemoveBlocksFtraceEvent>; + + static constexpr FieldMetadata_PcLblk kPcLblk{}; + void set_pc_lblk(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_PcLblk::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PcPclu = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4RemoveBlocksFtraceEvent>; + + static constexpr FieldMetadata_PcPclu kPcPclu{}; + void set_pc_pclu(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_PcPclu::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PcState = + ::protozero::proto_utils::FieldMetadata< + 11, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4RemoveBlocksFtraceEvent>; + + static constexpr FieldMetadata_PcState kPcState{}; + void set_pc_state(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_PcState::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class Ext4ReleasepageFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4ReleasepageFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4ReleasepageFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4ReleasepageFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_index() const { return at<3>().valid(); } + uint64_t index() const { return at<3>().as_uint64(); } +}; + +class Ext4ReleasepageFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4ReleasepageFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kIndexFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4ReleasepageFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4ReleasepageFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4ReleasepageFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Index = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4ReleasepageFtraceEvent>; + + static constexpr FieldMetadata_Index kIndex{}; + void set_index(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Index::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class Ext4ReadpageFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4ReadpageFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4ReadpageFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4ReadpageFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_index() const { return at<3>().valid(); } + uint64_t index() const { return at<3>().as_uint64(); } +}; + +class Ext4ReadpageFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4ReadpageFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kIndexFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4ReadpageFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4ReadpageFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4ReadpageFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Index = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4ReadpageFtraceEvent>; + + static constexpr FieldMetadata_Index kIndex{}; + void set_index(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Index::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class Ext4ReadBlockBitmapLoadFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4ReadBlockBitmapLoadFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4ReadBlockBitmapLoadFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4ReadBlockBitmapLoadFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_group() const { return at<2>().valid(); } + uint32_t group() const { return at<2>().as_uint32(); } + bool has_prefetch() const { return at<3>().valid(); } + uint32_t prefetch() const { return at<3>().as_uint32(); } +}; + +class Ext4ReadBlockBitmapLoadFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4ReadBlockBitmapLoadFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kGroupFieldNumber = 2, + kPrefetchFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4ReadBlockBitmapLoadFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4ReadBlockBitmapLoadFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Group = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4ReadBlockBitmapLoadFtraceEvent>; + + static constexpr FieldMetadata_Group kGroup{}; + void set_group(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Group::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Prefetch = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4ReadBlockBitmapLoadFtraceEvent>; + + static constexpr FieldMetadata_Prefetch kPrefetch{}; + void set_prefetch(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Prefetch::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class Ext4PunchHoleFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4PunchHoleFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4PunchHoleFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4PunchHoleFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_offset() const { return at<3>().valid(); } + int64_t offset() const { return at<3>().as_int64(); } + bool has_len() const { return at<4>().valid(); } + int64_t len() const { return at<4>().as_int64(); } + bool has_mode() const { return at<5>().valid(); } + int32_t mode() const { return at<5>().as_int32(); } +}; + +class Ext4PunchHoleFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4PunchHoleFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kOffsetFieldNumber = 3, + kLenFieldNumber = 4, + kModeFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4PunchHoleFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4PunchHoleFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4PunchHoleFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Offset = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + Ext4PunchHoleFtraceEvent>; + + static constexpr FieldMetadata_Offset kOffset{}; + void set_offset(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Offset::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Len = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + Ext4PunchHoleFtraceEvent>; + + static constexpr FieldMetadata_Len kLen{}; + void set_len(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Mode = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4PunchHoleFtraceEvent>; + + static constexpr FieldMetadata_Mode kMode{}; + void set_mode(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Mode::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class Ext4OtherInodeUpdateTimeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4OtherInodeUpdateTimeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4OtherInodeUpdateTimeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4OtherInodeUpdateTimeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_orig_ino() const { return at<3>().valid(); } + uint64_t orig_ino() const { return at<3>().as_uint64(); } + bool has_uid() const { return at<4>().valid(); } + uint32_t uid() const { return at<4>().as_uint32(); } + bool has_gid() const { return at<5>().valid(); } + uint32_t gid() const { return at<5>().as_uint32(); } + bool has_mode() const { return at<6>().valid(); } + uint32_t mode() const { return at<6>().as_uint32(); } +}; + +class Ext4OtherInodeUpdateTimeFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4OtherInodeUpdateTimeFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kOrigInoFieldNumber = 3, + kUidFieldNumber = 4, + kGidFieldNumber = 5, + kModeFieldNumber = 6, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4OtherInodeUpdateTimeFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4OtherInodeUpdateTimeFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4OtherInodeUpdateTimeFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_OrigIno = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4OtherInodeUpdateTimeFtraceEvent>; + + static constexpr FieldMetadata_OrigIno kOrigIno{}; + void set_orig_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_OrigIno::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Uid = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4OtherInodeUpdateTimeFtraceEvent>; + + static constexpr FieldMetadata_Uid kUid{}; + void set_uid(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Uid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Gid = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4OtherInodeUpdateTimeFtraceEvent>; + + static constexpr FieldMetadata_Gid kGid{}; + void set_gid(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Gid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Mode = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4OtherInodeUpdateTimeFtraceEvent>; + + static constexpr FieldMetadata_Mode kMode{}; + void set_mode(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Mode::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class Ext4MballocPreallocFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4MballocPreallocFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4MballocPreallocFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4MballocPreallocFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_orig_logical() const { return at<3>().valid(); } + uint32_t orig_logical() const { return at<3>().as_uint32(); } + bool has_orig_start() const { return at<4>().valid(); } + int32_t orig_start() const { return at<4>().as_int32(); } + bool has_orig_group() const { return at<5>().valid(); } + uint32_t orig_group() const { return at<5>().as_uint32(); } + bool has_orig_len() const { return at<6>().valid(); } + int32_t orig_len() const { return at<6>().as_int32(); } + bool has_result_logical() const { return at<7>().valid(); } + uint32_t result_logical() const { return at<7>().as_uint32(); } + bool has_result_start() const { return at<8>().valid(); } + int32_t result_start() const { return at<8>().as_int32(); } + bool has_result_group() const { return at<9>().valid(); } + uint32_t result_group() const { return at<9>().as_uint32(); } + bool has_result_len() const { return at<10>().valid(); } + int32_t result_len() const { return at<10>().as_int32(); } +}; + +class Ext4MballocPreallocFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4MballocPreallocFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kOrigLogicalFieldNumber = 3, + kOrigStartFieldNumber = 4, + kOrigGroupFieldNumber = 5, + kOrigLenFieldNumber = 6, + kResultLogicalFieldNumber = 7, + kResultStartFieldNumber = 8, + kResultGroupFieldNumber = 9, + kResultLenFieldNumber = 10, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4MballocPreallocFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4MballocPreallocFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4MballocPreallocFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_OrigLogical = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4MballocPreallocFtraceEvent>; + + static constexpr FieldMetadata_OrigLogical kOrigLogical{}; + void set_orig_logical(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_OrigLogical::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_OrigStart = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4MballocPreallocFtraceEvent>; + + static constexpr FieldMetadata_OrigStart kOrigStart{}; + void set_orig_start(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_OrigStart::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_OrigGroup = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4MballocPreallocFtraceEvent>; + + static constexpr FieldMetadata_OrigGroup kOrigGroup{}; + void set_orig_group(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_OrigGroup::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_OrigLen = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4MballocPreallocFtraceEvent>; + + static constexpr FieldMetadata_OrigLen kOrigLen{}; + void set_orig_len(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_OrigLen::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ResultLogical = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4MballocPreallocFtraceEvent>; + + static constexpr FieldMetadata_ResultLogical kResultLogical{}; + void set_result_logical(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ResultLogical::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ResultStart = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4MballocPreallocFtraceEvent>; + + static constexpr FieldMetadata_ResultStart kResultStart{}; + void set_result_start(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ResultStart::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ResultGroup = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4MballocPreallocFtraceEvent>; + + static constexpr FieldMetadata_ResultGroup kResultGroup{}; + void set_result_group(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ResultGroup::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ResultLen = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4MballocPreallocFtraceEvent>; + + static constexpr FieldMetadata_ResultLen kResultLen{}; + void set_result_len(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ResultLen::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class Ext4MballocFreeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4MballocFreeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4MballocFreeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4MballocFreeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_result_start() const { return at<3>().valid(); } + int32_t result_start() const { return at<3>().as_int32(); } + bool has_result_group() const { return at<4>().valid(); } + uint32_t result_group() const { return at<4>().as_uint32(); } + bool has_result_len() const { return at<5>().valid(); } + int32_t result_len() const { return at<5>().as_int32(); } +}; + +class Ext4MballocFreeFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4MballocFreeFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kResultStartFieldNumber = 3, + kResultGroupFieldNumber = 4, + kResultLenFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4MballocFreeFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4MballocFreeFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4MballocFreeFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ResultStart = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4MballocFreeFtraceEvent>; + + static constexpr FieldMetadata_ResultStart kResultStart{}; + void set_result_start(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ResultStart::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ResultGroup = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4MballocFreeFtraceEvent>; + + static constexpr FieldMetadata_ResultGroup kResultGroup{}; + void set_result_group(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ResultGroup::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ResultLen = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4MballocFreeFtraceEvent>; + + static constexpr FieldMetadata_ResultLen kResultLen{}; + void set_result_len(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ResultLen::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class Ext4MballocDiscardFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4MballocDiscardFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4MballocDiscardFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4MballocDiscardFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_result_start() const { return at<3>().valid(); } + int32_t result_start() const { return at<3>().as_int32(); } + bool has_result_group() const { return at<4>().valid(); } + uint32_t result_group() const { return at<4>().as_uint32(); } + bool has_result_len() const { return at<5>().valid(); } + int32_t result_len() const { return at<5>().as_int32(); } +}; + +class Ext4MballocDiscardFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4MballocDiscardFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kResultStartFieldNumber = 3, + kResultGroupFieldNumber = 4, + kResultLenFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4MballocDiscardFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4MballocDiscardFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4MballocDiscardFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ResultStart = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4MballocDiscardFtraceEvent>; + + static constexpr FieldMetadata_ResultStart kResultStart{}; + void set_result_start(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ResultStart::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ResultGroup = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4MballocDiscardFtraceEvent>; + + static constexpr FieldMetadata_ResultGroup kResultGroup{}; + void set_result_group(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ResultGroup::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ResultLen = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4MballocDiscardFtraceEvent>; + + static constexpr FieldMetadata_ResultLen kResultLen{}; + void set_result_len(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ResultLen::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class Ext4MballocAllocFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4MballocAllocFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4MballocAllocFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4MballocAllocFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_orig_logical() const { return at<3>().valid(); } + uint32_t orig_logical() const { return at<3>().as_uint32(); } + bool has_orig_start() const { return at<4>().valid(); } + int32_t orig_start() const { return at<4>().as_int32(); } + bool has_orig_group() const { return at<5>().valid(); } + uint32_t orig_group() const { return at<5>().as_uint32(); } + bool has_orig_len() const { return at<6>().valid(); } + int32_t orig_len() const { return at<6>().as_int32(); } + bool has_goal_logical() const { return at<7>().valid(); } + uint32_t goal_logical() const { return at<7>().as_uint32(); } + bool has_goal_start() const { return at<8>().valid(); } + int32_t goal_start() const { return at<8>().as_int32(); } + bool has_goal_group() const { return at<9>().valid(); } + uint32_t goal_group() const { return at<9>().as_uint32(); } + bool has_goal_len() const { return at<10>().valid(); } + int32_t goal_len() const { return at<10>().as_int32(); } + bool has_result_logical() const { return at<11>().valid(); } + uint32_t result_logical() const { return at<11>().as_uint32(); } + bool has_result_start() const { return at<12>().valid(); } + int32_t result_start() const { return at<12>().as_int32(); } + bool has_result_group() const { return at<13>().valid(); } + uint32_t result_group() const { return at<13>().as_uint32(); } + bool has_result_len() const { return at<14>().valid(); } + int32_t result_len() const { return at<14>().as_int32(); } + bool has_found() const { return at<15>().valid(); } + uint32_t found() const { return at<15>().as_uint32(); } + bool has_groups() const { return at<16>().valid(); } + uint32_t groups() const { return at<16>().as_uint32(); } + bool has_buddy() const { return at<17>().valid(); } + uint32_t buddy() const { return at<17>().as_uint32(); } + bool has_flags() const { return at<18>().valid(); } + uint32_t flags() const { return at<18>().as_uint32(); } + bool has_tail() const { return at<19>().valid(); } + uint32_t tail() const { return at<19>().as_uint32(); } + bool has_cr() const { return at<20>().valid(); } + uint32_t cr() const { return at<20>().as_uint32(); } +}; + +class Ext4MballocAllocFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4MballocAllocFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kOrigLogicalFieldNumber = 3, + kOrigStartFieldNumber = 4, + kOrigGroupFieldNumber = 5, + kOrigLenFieldNumber = 6, + kGoalLogicalFieldNumber = 7, + kGoalStartFieldNumber = 8, + kGoalGroupFieldNumber = 9, + kGoalLenFieldNumber = 10, + kResultLogicalFieldNumber = 11, + kResultStartFieldNumber = 12, + kResultGroupFieldNumber = 13, + kResultLenFieldNumber = 14, + kFoundFieldNumber = 15, + kGroupsFieldNumber = 16, + kBuddyFieldNumber = 17, + kFlagsFieldNumber = 18, + kTailFieldNumber = 19, + kCrFieldNumber = 20, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4MballocAllocFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4MballocAllocFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4MballocAllocFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_OrigLogical = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4MballocAllocFtraceEvent>; + + static constexpr FieldMetadata_OrigLogical kOrigLogical{}; + void set_orig_logical(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_OrigLogical::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_OrigStart = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4MballocAllocFtraceEvent>; + + static constexpr FieldMetadata_OrigStart kOrigStart{}; + void set_orig_start(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_OrigStart::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_OrigGroup = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4MballocAllocFtraceEvent>; + + static constexpr FieldMetadata_OrigGroup kOrigGroup{}; + void set_orig_group(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_OrigGroup::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_OrigLen = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4MballocAllocFtraceEvent>; + + static constexpr FieldMetadata_OrigLen kOrigLen{}; + void set_orig_len(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_OrigLen::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_GoalLogical = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4MballocAllocFtraceEvent>; + + static constexpr FieldMetadata_GoalLogical kGoalLogical{}; + void set_goal_logical(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_GoalLogical::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_GoalStart = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4MballocAllocFtraceEvent>; + + static constexpr FieldMetadata_GoalStart kGoalStart{}; + void set_goal_start(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_GoalStart::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_GoalGroup = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4MballocAllocFtraceEvent>; + + static constexpr FieldMetadata_GoalGroup kGoalGroup{}; + void set_goal_group(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_GoalGroup::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_GoalLen = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4MballocAllocFtraceEvent>; + + static constexpr FieldMetadata_GoalLen kGoalLen{}; + void set_goal_len(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_GoalLen::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ResultLogical = + ::protozero::proto_utils::FieldMetadata< + 11, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4MballocAllocFtraceEvent>; + + static constexpr FieldMetadata_ResultLogical kResultLogical{}; + void set_result_logical(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ResultLogical::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ResultStart = + ::protozero::proto_utils::FieldMetadata< + 12, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4MballocAllocFtraceEvent>; + + static constexpr FieldMetadata_ResultStart kResultStart{}; + void set_result_start(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ResultStart::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ResultGroup = + ::protozero::proto_utils::FieldMetadata< + 13, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4MballocAllocFtraceEvent>; + + static constexpr FieldMetadata_ResultGroup kResultGroup{}; + void set_result_group(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ResultGroup::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ResultLen = + ::protozero::proto_utils::FieldMetadata< + 14, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4MballocAllocFtraceEvent>; + + static constexpr FieldMetadata_ResultLen kResultLen{}; + void set_result_len(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ResultLen::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Found = + ::protozero::proto_utils::FieldMetadata< + 15, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4MballocAllocFtraceEvent>; + + static constexpr FieldMetadata_Found kFound{}; + void set_found(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Found::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Groups = + ::protozero::proto_utils::FieldMetadata< + 16, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4MballocAllocFtraceEvent>; + + static constexpr FieldMetadata_Groups kGroups{}; + void set_groups(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Groups::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Buddy = + ::protozero::proto_utils::FieldMetadata< + 17, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4MballocAllocFtraceEvent>; + + static constexpr FieldMetadata_Buddy kBuddy{}; + void set_buddy(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Buddy::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Flags = + ::protozero::proto_utils::FieldMetadata< + 18, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4MballocAllocFtraceEvent>; + + static constexpr FieldMetadata_Flags kFlags{}; + void set_flags(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Tail = + ::protozero::proto_utils::FieldMetadata< + 19, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4MballocAllocFtraceEvent>; + + static constexpr FieldMetadata_Tail kTail{}; + void set_tail(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Tail::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Cr = + ::protozero::proto_utils::FieldMetadata< + 20, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4MballocAllocFtraceEvent>; + + static constexpr FieldMetadata_Cr kCr{}; + void set_cr(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Cr::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class Ext4MbReleaseInodePaFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4MbReleaseInodePaFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4MbReleaseInodePaFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4MbReleaseInodePaFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_block() const { return at<3>().valid(); } + uint64_t block() const { return at<3>().as_uint64(); } + bool has_count() const { return at<4>().valid(); } + uint32_t count() const { return at<4>().as_uint32(); } +}; + +class Ext4MbReleaseInodePaFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4MbReleaseInodePaFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kBlockFieldNumber = 3, + kCountFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4MbReleaseInodePaFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4MbReleaseInodePaFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4MbReleaseInodePaFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Block = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4MbReleaseInodePaFtraceEvent>; + + static constexpr FieldMetadata_Block kBlock{}; + void set_block(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Block::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Count = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4MbReleaseInodePaFtraceEvent>; + + static constexpr FieldMetadata_Count kCount{}; + void set_count(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Count::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class Ext4MbReleaseGroupPaFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4MbReleaseGroupPaFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4MbReleaseGroupPaFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4MbReleaseGroupPaFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_pa_pstart() const { return at<2>().valid(); } + uint64_t pa_pstart() const { return at<2>().as_uint64(); } + bool has_pa_len() const { return at<3>().valid(); } + uint32_t pa_len() const { return at<3>().as_uint32(); } +}; + +class Ext4MbReleaseGroupPaFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4MbReleaseGroupPaFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kPaPstartFieldNumber = 2, + kPaLenFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4MbReleaseGroupPaFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4MbReleaseGroupPaFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PaPstart = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4MbReleaseGroupPaFtraceEvent>; + + static constexpr FieldMetadata_PaPstart kPaPstart{}; + void set_pa_pstart(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_PaPstart::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PaLen = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4MbReleaseGroupPaFtraceEvent>; + + static constexpr FieldMetadata_PaLen kPaLen{}; + void set_pa_len(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_PaLen::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class Ext4MbNewInodePaFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4MbNewInodePaFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4MbNewInodePaFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4MbNewInodePaFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_pa_pstart() const { return at<3>().valid(); } + uint64_t pa_pstart() const { return at<3>().as_uint64(); } + bool has_pa_lstart() const { return at<4>().valid(); } + uint64_t pa_lstart() const { return at<4>().as_uint64(); } + bool has_pa_len() const { return at<5>().valid(); } + uint32_t pa_len() const { return at<5>().as_uint32(); } +}; + +class Ext4MbNewInodePaFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4MbNewInodePaFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kPaPstartFieldNumber = 3, + kPaLstartFieldNumber = 4, + kPaLenFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4MbNewInodePaFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4MbNewInodePaFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4MbNewInodePaFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PaPstart = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4MbNewInodePaFtraceEvent>; + + static constexpr FieldMetadata_PaPstart kPaPstart{}; + void set_pa_pstart(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_PaPstart::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PaLstart = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4MbNewInodePaFtraceEvent>; + + static constexpr FieldMetadata_PaLstart kPaLstart{}; + void set_pa_lstart(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_PaLstart::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PaLen = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4MbNewInodePaFtraceEvent>; + + static constexpr FieldMetadata_PaLen kPaLen{}; + void set_pa_len(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_PaLen::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class Ext4MbNewGroupPaFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4MbNewGroupPaFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4MbNewGroupPaFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4MbNewGroupPaFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_pa_pstart() const { return at<3>().valid(); } + uint64_t pa_pstart() const { return at<3>().as_uint64(); } + bool has_pa_lstart() const { return at<4>().valid(); } + uint64_t pa_lstart() const { return at<4>().as_uint64(); } + bool has_pa_len() const { return at<5>().valid(); } + uint32_t pa_len() const { return at<5>().as_uint32(); } +}; + +class Ext4MbNewGroupPaFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4MbNewGroupPaFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kPaPstartFieldNumber = 3, + kPaLstartFieldNumber = 4, + kPaLenFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4MbNewGroupPaFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4MbNewGroupPaFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4MbNewGroupPaFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PaPstart = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4MbNewGroupPaFtraceEvent>; + + static constexpr FieldMetadata_PaPstart kPaPstart{}; + void set_pa_pstart(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_PaPstart::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PaLstart = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4MbNewGroupPaFtraceEvent>; + + static constexpr FieldMetadata_PaLstart kPaLstart{}; + void set_pa_lstart(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_PaLstart::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PaLen = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4MbNewGroupPaFtraceEvent>; + + static constexpr FieldMetadata_PaLen kPaLen{}; + void set_pa_len(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_PaLen::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class Ext4MbDiscardPreallocationsFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4MbDiscardPreallocationsFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4MbDiscardPreallocationsFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4MbDiscardPreallocationsFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_needed() const { return at<2>().valid(); } + int32_t needed() const { return at<2>().as_int32(); } +}; + +class Ext4MbDiscardPreallocationsFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4MbDiscardPreallocationsFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kNeededFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4MbDiscardPreallocationsFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4MbDiscardPreallocationsFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Needed = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4MbDiscardPreallocationsFtraceEvent>; + + static constexpr FieldMetadata_Needed kNeeded{}; + void set_needed(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Needed::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class Ext4MbBuddyBitmapLoadFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4MbBuddyBitmapLoadFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4MbBuddyBitmapLoadFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4MbBuddyBitmapLoadFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_group() const { return at<2>().valid(); } + uint32_t group() const { return at<2>().as_uint32(); } +}; + +class Ext4MbBuddyBitmapLoadFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4MbBuddyBitmapLoadFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kGroupFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4MbBuddyBitmapLoadFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4MbBuddyBitmapLoadFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Group = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4MbBuddyBitmapLoadFtraceEvent>; + + static constexpr FieldMetadata_Group kGroup{}; + void set_group(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Group::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class Ext4MbBitmapLoadFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4MbBitmapLoadFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4MbBitmapLoadFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4MbBitmapLoadFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_group() const { return at<2>().valid(); } + uint32_t group() const { return at<2>().as_uint32(); } +}; + +class Ext4MbBitmapLoadFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4MbBitmapLoadFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kGroupFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4MbBitmapLoadFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4MbBitmapLoadFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Group = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4MbBitmapLoadFtraceEvent>; + + static constexpr FieldMetadata_Group kGroup{}; + void set_group(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Group::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class Ext4MarkInodeDirtyFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4MarkInodeDirtyFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4MarkInodeDirtyFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4MarkInodeDirtyFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_ip() const { return at<3>().valid(); } + uint64_t ip() const { return at<3>().as_uint64(); } +}; + +class Ext4MarkInodeDirtyFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4MarkInodeDirtyFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kIpFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4MarkInodeDirtyFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4MarkInodeDirtyFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4MarkInodeDirtyFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ip = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4MarkInodeDirtyFtraceEvent>; + + static constexpr FieldMetadata_Ip kIp{}; + void set_ip(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ip::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class Ext4LoadInodeBitmapFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4LoadInodeBitmapFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4LoadInodeBitmapFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4LoadInodeBitmapFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_group() const { return at<2>().valid(); } + uint32_t group() const { return at<2>().as_uint32(); } +}; + +class Ext4LoadInodeBitmapFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4LoadInodeBitmapFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kGroupFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4LoadInodeBitmapFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4LoadInodeBitmapFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Group = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4LoadInodeBitmapFtraceEvent>; + + static constexpr FieldMetadata_Group kGroup{}; + void set_group(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Group::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class Ext4LoadInodeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4LoadInodeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4LoadInodeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4LoadInodeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } +}; + +class Ext4LoadInodeFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4LoadInodeFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4LoadInodeFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4LoadInodeFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4LoadInodeFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class Ext4JournalledWriteEndFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4JournalledWriteEndFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4JournalledWriteEndFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4JournalledWriteEndFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_pos() const { return at<3>().valid(); } + int64_t pos() const { return at<3>().as_int64(); } + bool has_len() const { return at<4>().valid(); } + uint32_t len() const { return at<4>().as_uint32(); } + bool has_copied() const { return at<5>().valid(); } + uint32_t copied() const { return at<5>().as_uint32(); } +}; + +class Ext4JournalledWriteEndFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4JournalledWriteEndFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kPosFieldNumber = 3, + kLenFieldNumber = 4, + kCopiedFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4JournalledWriteEndFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4JournalledWriteEndFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4JournalledWriteEndFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pos = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + Ext4JournalledWriteEndFtraceEvent>; + + static constexpr FieldMetadata_Pos kPos{}; + void set_pos(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pos::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Len = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4JournalledWriteEndFtraceEvent>; + + static constexpr FieldMetadata_Len kLen{}; + void set_len(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Copied = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4JournalledWriteEndFtraceEvent>; + + static constexpr FieldMetadata_Copied kCopied{}; + void set_copied(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Copied::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class Ext4JournalledInvalidatepageFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4JournalledInvalidatepageFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4JournalledInvalidatepageFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4JournalledInvalidatepageFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_index() const { return at<3>().valid(); } + uint64_t index() const { return at<3>().as_uint64(); } + bool has_offset() const { return at<4>().valid(); } + uint64_t offset() const { return at<4>().as_uint64(); } + bool has_length() const { return at<5>().valid(); } + uint32_t length() const { return at<5>().as_uint32(); } +}; + +class Ext4JournalledInvalidatepageFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4JournalledInvalidatepageFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kIndexFieldNumber = 3, + kOffsetFieldNumber = 4, + kLengthFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4JournalledInvalidatepageFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4JournalledInvalidatepageFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4JournalledInvalidatepageFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Index = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4JournalledInvalidatepageFtraceEvent>; + + static constexpr FieldMetadata_Index kIndex{}; + void set_index(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Index::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Offset = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4JournalledInvalidatepageFtraceEvent>; + + static constexpr FieldMetadata_Offset kOffset{}; + void set_offset(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Offset::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Length = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4JournalledInvalidatepageFtraceEvent>; + + static constexpr FieldMetadata_Length kLength{}; + void set_length(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Length::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class Ext4JournalStartReservedFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4JournalStartReservedFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4JournalStartReservedFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4JournalStartReservedFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ip() const { return at<2>().valid(); } + uint64_t ip() const { return at<2>().as_uint64(); } + bool has_blocks() const { return at<3>().valid(); } + int32_t blocks() const { return at<3>().as_int32(); } +}; + +class Ext4JournalStartReservedFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4JournalStartReservedFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kIpFieldNumber = 2, + kBlocksFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4JournalStartReservedFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4JournalStartReservedFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ip = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4JournalStartReservedFtraceEvent>; + + static constexpr FieldMetadata_Ip kIp{}; + void set_ip(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ip::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Blocks = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4JournalStartReservedFtraceEvent>; + + static constexpr FieldMetadata_Blocks kBlocks{}; + void set_blocks(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Blocks::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class Ext4JournalStartFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4JournalStartFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4JournalStartFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4JournalStartFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ip() const { return at<2>().valid(); } + uint64_t ip() const { return at<2>().as_uint64(); } + bool has_blocks() const { return at<3>().valid(); } + int32_t blocks() const { return at<3>().as_int32(); } + bool has_rsv_blocks() const { return at<4>().valid(); } + int32_t rsv_blocks() const { return at<4>().as_int32(); } + bool has_nblocks() const { return at<5>().valid(); } + int32_t nblocks() const { return at<5>().as_int32(); } + bool has_revoke_creds() const { return at<6>().valid(); } + int32_t revoke_creds() const { return at<6>().as_int32(); } +}; + +class Ext4JournalStartFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4JournalStartFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kIpFieldNumber = 2, + kBlocksFieldNumber = 3, + kRsvBlocksFieldNumber = 4, + kNblocksFieldNumber = 5, + kRevokeCredsFieldNumber = 6, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4JournalStartFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4JournalStartFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ip = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4JournalStartFtraceEvent>; + + static constexpr FieldMetadata_Ip kIp{}; + void set_ip(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ip::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Blocks = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4JournalStartFtraceEvent>; + + static constexpr FieldMetadata_Blocks kBlocks{}; + void set_blocks(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Blocks::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_RsvBlocks = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4JournalStartFtraceEvent>; + + static constexpr FieldMetadata_RsvBlocks kRsvBlocks{}; + void set_rsv_blocks(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_RsvBlocks::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Nblocks = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4JournalStartFtraceEvent>; + + static constexpr FieldMetadata_Nblocks kNblocks{}; + void set_nblocks(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Nblocks::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_RevokeCreds = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4JournalStartFtraceEvent>; + + static constexpr FieldMetadata_RevokeCreds kRevokeCreds{}; + void set_revoke_creds(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_RevokeCreds::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class Ext4InvalidatepageFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4InvalidatepageFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4InvalidatepageFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4InvalidatepageFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_index() const { return at<3>().valid(); } + uint64_t index() const { return at<3>().as_uint64(); } + bool has_offset() const { return at<4>().valid(); } + uint64_t offset() const { return at<4>().as_uint64(); } + bool has_length() const { return at<5>().valid(); } + uint32_t length() const { return at<5>().as_uint32(); } +}; + +class Ext4InvalidatepageFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4InvalidatepageFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kIndexFieldNumber = 3, + kOffsetFieldNumber = 4, + kLengthFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4InvalidatepageFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4InvalidatepageFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4InvalidatepageFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Index = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4InvalidatepageFtraceEvent>; + + static constexpr FieldMetadata_Index kIndex{}; + void set_index(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Index::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Offset = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4InvalidatepageFtraceEvent>; + + static constexpr FieldMetadata_Offset kOffset{}; + void set_offset(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Offset::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Length = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4InvalidatepageFtraceEvent>; + + static constexpr FieldMetadata_Length kLength{}; + void set_length(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Length::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class Ext4InsertRangeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4InsertRangeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4InsertRangeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4InsertRangeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_offset() const { return at<3>().valid(); } + int64_t offset() const { return at<3>().as_int64(); } + bool has_len() const { return at<4>().valid(); } + int64_t len() const { return at<4>().as_int64(); } +}; + +class Ext4InsertRangeFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4InsertRangeFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kOffsetFieldNumber = 3, + kLenFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4InsertRangeFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4InsertRangeFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4InsertRangeFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Offset = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + Ext4InsertRangeFtraceEvent>; + + static constexpr FieldMetadata_Offset kOffset{}; + void set_offset(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Offset::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Len = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + Ext4InsertRangeFtraceEvent>; + + static constexpr FieldMetadata_Len kLen{}; + void set_len(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } +}; + +class Ext4IndMapBlocksExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4IndMapBlocksExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4IndMapBlocksExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4IndMapBlocksExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_flags() const { return at<3>().valid(); } + uint32_t flags() const { return at<3>().as_uint32(); } + bool has_pblk() const { return at<4>().valid(); } + uint64_t pblk() const { return at<4>().as_uint64(); } + bool has_lblk() const { return at<5>().valid(); } + uint32_t lblk() const { return at<5>().as_uint32(); } + bool has_len() const { return at<6>().valid(); } + uint32_t len() const { return at<6>().as_uint32(); } + bool has_mflags() const { return at<7>().valid(); } + uint32_t mflags() const { return at<7>().as_uint32(); } + bool has_ret() const { return at<8>().valid(); } + int32_t ret() const { return at<8>().as_int32(); } +}; + +class Ext4IndMapBlocksExitFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4IndMapBlocksExitFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kFlagsFieldNumber = 3, + kPblkFieldNumber = 4, + kLblkFieldNumber = 5, + kLenFieldNumber = 6, + kMflagsFieldNumber = 7, + kRetFieldNumber = 8, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4IndMapBlocksExitFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4IndMapBlocksExitFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4IndMapBlocksExitFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Flags = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4IndMapBlocksExitFtraceEvent>; + + static constexpr FieldMetadata_Flags kFlags{}; + void set_flags(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pblk = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4IndMapBlocksExitFtraceEvent>; + + static constexpr FieldMetadata_Pblk kPblk{}; + void set_pblk(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pblk::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Lblk = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4IndMapBlocksExitFtraceEvent>; + + static constexpr FieldMetadata_Lblk kLblk{}; + void set_lblk(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Lblk::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Len = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4IndMapBlocksExitFtraceEvent>; + + static constexpr FieldMetadata_Len kLen{}; + void set_len(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Mflags = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4IndMapBlocksExitFtraceEvent>; + + static constexpr FieldMetadata_Mflags kMflags{}; + void set_mflags(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Mflags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ret = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4IndMapBlocksExitFtraceEvent>; + + static constexpr FieldMetadata_Ret kRet{}; + void set_ret(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class Ext4IndMapBlocksEnterFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4IndMapBlocksEnterFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4IndMapBlocksEnterFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4IndMapBlocksEnterFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_lblk() const { return at<3>().valid(); } + uint32_t lblk() const { return at<3>().as_uint32(); } + bool has_len() const { return at<4>().valid(); } + uint32_t len() const { return at<4>().as_uint32(); } + bool has_flags() const { return at<5>().valid(); } + uint32_t flags() const { return at<5>().as_uint32(); } +}; + +class Ext4IndMapBlocksEnterFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4IndMapBlocksEnterFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kLblkFieldNumber = 3, + kLenFieldNumber = 4, + kFlagsFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4IndMapBlocksEnterFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4IndMapBlocksEnterFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4IndMapBlocksEnterFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Lblk = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4IndMapBlocksEnterFtraceEvent>; + + static constexpr FieldMetadata_Lblk kLblk{}; + void set_lblk(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Lblk::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Len = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4IndMapBlocksEnterFtraceEvent>; + + static constexpr FieldMetadata_Len kLen{}; + void set_len(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Flags = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4IndMapBlocksEnterFtraceEvent>; + + static constexpr FieldMetadata_Flags kFlags{}; + void set_flags(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class Ext4GetReservedClusterAllocFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4GetReservedClusterAllocFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4GetReservedClusterAllocFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4GetReservedClusterAllocFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_lblk() const { return at<3>().valid(); } + uint32_t lblk() const { return at<3>().as_uint32(); } + bool has_len() const { return at<4>().valid(); } + uint32_t len() const { return at<4>().as_uint32(); } +}; + +class Ext4GetReservedClusterAllocFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4GetReservedClusterAllocFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kLblkFieldNumber = 3, + kLenFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4GetReservedClusterAllocFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4GetReservedClusterAllocFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4GetReservedClusterAllocFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Lblk = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4GetReservedClusterAllocFtraceEvent>; + + static constexpr FieldMetadata_Lblk kLblk{}; + void set_lblk(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Lblk::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Len = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4GetReservedClusterAllocFtraceEvent>; + + static constexpr FieldMetadata_Len kLen{}; + void set_len(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class Ext4GetImpliedClusterAllocExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4GetImpliedClusterAllocExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4GetImpliedClusterAllocExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4GetImpliedClusterAllocExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_flags() const { return at<2>().valid(); } + uint32_t flags() const { return at<2>().as_uint32(); } + bool has_lblk() const { return at<3>().valid(); } + uint32_t lblk() const { return at<3>().as_uint32(); } + bool has_pblk() const { return at<4>().valid(); } + uint64_t pblk() const { return at<4>().as_uint64(); } + bool has_len() const { return at<5>().valid(); } + uint32_t len() const { return at<5>().as_uint32(); } + bool has_ret() const { return at<6>().valid(); } + int32_t ret() const { return at<6>().as_int32(); } +}; + +class Ext4GetImpliedClusterAllocExitFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4GetImpliedClusterAllocExitFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kFlagsFieldNumber = 2, + kLblkFieldNumber = 3, + kPblkFieldNumber = 4, + kLenFieldNumber = 5, + kRetFieldNumber = 6, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4GetImpliedClusterAllocExitFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4GetImpliedClusterAllocExitFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Flags = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4GetImpliedClusterAllocExitFtraceEvent>; + + static constexpr FieldMetadata_Flags kFlags{}; + void set_flags(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Lblk = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4GetImpliedClusterAllocExitFtraceEvent>; + + static constexpr FieldMetadata_Lblk kLblk{}; + void set_lblk(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Lblk::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pblk = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4GetImpliedClusterAllocExitFtraceEvent>; + + static constexpr FieldMetadata_Pblk kPblk{}; + void set_pblk(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pblk::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Len = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4GetImpliedClusterAllocExitFtraceEvent>; + + static constexpr FieldMetadata_Len kLen{}; + void set_len(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ret = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4GetImpliedClusterAllocExitFtraceEvent>; + + static constexpr FieldMetadata_Ret kRet{}; + void set_ret(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class Ext4FreeInodeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4FreeInodeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4FreeInodeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4FreeInodeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_uid() const { return at<3>().valid(); } + uint32_t uid() const { return at<3>().as_uint32(); } + bool has_gid() const { return at<4>().valid(); } + uint32_t gid() const { return at<4>().as_uint32(); } + bool has_blocks() const { return at<5>().valid(); } + uint64_t blocks() const { return at<5>().as_uint64(); } + bool has_mode() const { return at<6>().valid(); } + uint32_t mode() const { return at<6>().as_uint32(); } +}; + +class Ext4FreeInodeFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4FreeInodeFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kUidFieldNumber = 3, + kGidFieldNumber = 4, + kBlocksFieldNumber = 5, + kModeFieldNumber = 6, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4FreeInodeFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4FreeInodeFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4FreeInodeFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Uid = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4FreeInodeFtraceEvent>; + + static constexpr FieldMetadata_Uid kUid{}; + void set_uid(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Uid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Gid = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4FreeInodeFtraceEvent>; + + static constexpr FieldMetadata_Gid kGid{}; + void set_gid(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Gid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Blocks = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4FreeInodeFtraceEvent>; + + static constexpr FieldMetadata_Blocks kBlocks{}; + void set_blocks(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Blocks::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Mode = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4FreeInodeFtraceEvent>; + + static constexpr FieldMetadata_Mode kMode{}; + void set_mode(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Mode::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class Ext4FreeBlocksFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4FreeBlocksFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4FreeBlocksFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4FreeBlocksFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_block() const { return at<3>().valid(); } + uint64_t block() const { return at<3>().as_uint64(); } + bool has_count() const { return at<4>().valid(); } + uint64_t count() const { return at<4>().as_uint64(); } + bool has_flags() const { return at<5>().valid(); } + int32_t flags() const { return at<5>().as_int32(); } + bool has_mode() const { return at<6>().valid(); } + uint32_t mode() const { return at<6>().as_uint32(); } +}; + +class Ext4FreeBlocksFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4FreeBlocksFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kBlockFieldNumber = 3, + kCountFieldNumber = 4, + kFlagsFieldNumber = 5, + kModeFieldNumber = 6, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4FreeBlocksFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4FreeBlocksFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4FreeBlocksFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Block = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4FreeBlocksFtraceEvent>; + + static constexpr FieldMetadata_Block kBlock{}; + void set_block(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Block::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Count = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4FreeBlocksFtraceEvent>; + + static constexpr FieldMetadata_Count kCount{}; + void set_count(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Count::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Flags = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4FreeBlocksFtraceEvent>; + + static constexpr FieldMetadata_Flags kFlags{}; + void set_flags(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Mode = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4FreeBlocksFtraceEvent>; + + static constexpr FieldMetadata_Mode kMode{}; + void set_mode(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Mode::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class Ext4ForgetFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4ForgetFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4ForgetFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4ForgetFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_block() const { return at<3>().valid(); } + uint64_t block() const { return at<3>().as_uint64(); } + bool has_is_metadata() const { return at<4>().valid(); } + int32_t is_metadata() const { return at<4>().as_int32(); } + bool has_mode() const { return at<5>().valid(); } + uint32_t mode() const { return at<5>().as_uint32(); } +}; + +class Ext4ForgetFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4ForgetFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kBlockFieldNumber = 3, + kIsMetadataFieldNumber = 4, + kModeFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4ForgetFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4ForgetFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4ForgetFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Block = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4ForgetFtraceEvent>; + + static constexpr FieldMetadata_Block kBlock{}; + void set_block(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Block::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_IsMetadata = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4ForgetFtraceEvent>; + + static constexpr FieldMetadata_IsMetadata kIsMetadata{}; + void set_is_metadata(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_IsMetadata::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Mode = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4ForgetFtraceEvent>; + + static constexpr FieldMetadata_Mode kMode{}; + void set_mode(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Mode::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class Ext4FindDelallocRangeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4FindDelallocRangeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4FindDelallocRangeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4FindDelallocRangeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_from() const { return at<3>().valid(); } + uint32_t from() const { return at<3>().as_uint32(); } + bool has_to() const { return at<4>().valid(); } + uint32_t to() const { return at<4>().as_uint32(); } + bool has_reverse() const { return at<5>().valid(); } + int32_t reverse() const { return at<5>().as_int32(); } + bool has_found() const { return at<6>().valid(); } + int32_t found() const { return at<6>().as_int32(); } + bool has_found_blk() const { return at<7>().valid(); } + uint32_t found_blk() const { return at<7>().as_uint32(); } +}; + +class Ext4FindDelallocRangeFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4FindDelallocRangeFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kFromFieldNumber = 3, + kToFieldNumber = 4, + kReverseFieldNumber = 5, + kFoundFieldNumber = 6, + kFoundBlkFieldNumber = 7, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4FindDelallocRangeFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4FindDelallocRangeFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4FindDelallocRangeFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_From = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4FindDelallocRangeFtraceEvent>; + + static constexpr FieldMetadata_From kFrom{}; + void set_from(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_From::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_To = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4FindDelallocRangeFtraceEvent>; + + static constexpr FieldMetadata_To kTo{}; + void set_to(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_To::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Reverse = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4FindDelallocRangeFtraceEvent>; + + static constexpr FieldMetadata_Reverse kReverse{}; + void set_reverse(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Reverse::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Found = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4FindDelallocRangeFtraceEvent>; + + static constexpr FieldMetadata_Found kFound{}; + void set_found(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Found::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FoundBlk = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4FindDelallocRangeFtraceEvent>; + + static constexpr FieldMetadata_FoundBlk kFoundBlk{}; + void set_found_blk(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_FoundBlk::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class Ext4FallocateExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4FallocateExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4FallocateExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4FallocateExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_pos() const { return at<3>().valid(); } + int64_t pos() const { return at<3>().as_int64(); } + bool has_blocks() const { return at<4>().valid(); } + uint32_t blocks() const { return at<4>().as_uint32(); } + bool has_ret() const { return at<5>().valid(); } + int32_t ret() const { return at<5>().as_int32(); } +}; + +class Ext4FallocateExitFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4FallocateExitFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kPosFieldNumber = 3, + kBlocksFieldNumber = 4, + kRetFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4FallocateExitFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4FallocateExitFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4FallocateExitFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pos = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + Ext4FallocateExitFtraceEvent>; + + static constexpr FieldMetadata_Pos kPos{}; + void set_pos(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pos::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Blocks = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4FallocateExitFtraceEvent>; + + static constexpr FieldMetadata_Blocks kBlocks{}; + void set_blocks(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Blocks::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ret = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4FallocateExitFtraceEvent>; + + static constexpr FieldMetadata_Ret kRet{}; + void set_ret(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class Ext4FallocateEnterFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4FallocateEnterFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4FallocateEnterFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4FallocateEnterFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_offset() const { return at<3>().valid(); } + int64_t offset() const { return at<3>().as_int64(); } + bool has_len() const { return at<4>().valid(); } + int64_t len() const { return at<4>().as_int64(); } + bool has_mode() const { return at<5>().valid(); } + int32_t mode() const { return at<5>().as_int32(); } + bool has_pos() const { return at<6>().valid(); } + int64_t pos() const { return at<6>().as_int64(); } +}; + +class Ext4FallocateEnterFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4FallocateEnterFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kOffsetFieldNumber = 3, + kLenFieldNumber = 4, + kModeFieldNumber = 5, + kPosFieldNumber = 6, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4FallocateEnterFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4FallocateEnterFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4FallocateEnterFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Offset = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + Ext4FallocateEnterFtraceEvent>; + + static constexpr FieldMetadata_Offset kOffset{}; + void set_offset(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Offset::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Len = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + Ext4FallocateEnterFtraceEvent>; + + static constexpr FieldMetadata_Len kLen{}; + void set_len(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Mode = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4FallocateEnterFtraceEvent>; + + static constexpr FieldMetadata_Mode kMode{}; + void set_mode(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Mode::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pos = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + Ext4FallocateEnterFtraceEvent>; + + static constexpr FieldMetadata_Pos kPos{}; + void set_pos(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pos::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } +}; + +class Ext4ExtShowExtentFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4ExtShowExtentFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4ExtShowExtentFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4ExtShowExtentFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_pblk() const { return at<3>().valid(); } + uint64_t pblk() const { return at<3>().as_uint64(); } + bool has_lblk() const { return at<4>().valid(); } + uint32_t lblk() const { return at<4>().as_uint32(); } + bool has_len() const { return at<5>().valid(); } + uint32_t len() const { return at<5>().as_uint32(); } +}; + +class Ext4ExtShowExtentFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4ExtShowExtentFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kPblkFieldNumber = 3, + kLblkFieldNumber = 4, + kLenFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4ExtShowExtentFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4ExtShowExtentFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4ExtShowExtentFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pblk = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4ExtShowExtentFtraceEvent>; + + static constexpr FieldMetadata_Pblk kPblk{}; + void set_pblk(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pblk::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Lblk = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4ExtShowExtentFtraceEvent>; + + static constexpr FieldMetadata_Lblk kLblk{}; + void set_lblk(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Lblk::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Len = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4ExtShowExtentFtraceEvent>; + + static constexpr FieldMetadata_Len kLen{}; + void set_len(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class Ext4ExtRmLeafFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4ExtRmLeafFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4ExtRmLeafFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4ExtRmLeafFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_partial() const { return at<3>().valid(); } + int64_t partial() const { return at<3>().as_int64(); } + bool has_start() const { return at<4>().valid(); } + uint32_t start() const { return at<4>().as_uint32(); } + bool has_ee_lblk() const { return at<5>().valid(); } + uint32_t ee_lblk() const { return at<5>().as_uint32(); } + bool has_ee_pblk() const { return at<6>().valid(); } + uint64_t ee_pblk() const { return at<6>().as_uint64(); } + bool has_ee_len() const { return at<7>().valid(); } + int32_t ee_len() const { return at<7>().as_int32(); } + bool has_pc_lblk() const { return at<8>().valid(); } + uint32_t pc_lblk() const { return at<8>().as_uint32(); } + bool has_pc_pclu() const { return at<9>().valid(); } + uint64_t pc_pclu() const { return at<9>().as_uint64(); } + bool has_pc_state() const { return at<10>().valid(); } + int32_t pc_state() const { return at<10>().as_int32(); } +}; + +class Ext4ExtRmLeafFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4ExtRmLeafFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kPartialFieldNumber = 3, + kStartFieldNumber = 4, + kEeLblkFieldNumber = 5, + kEePblkFieldNumber = 6, + kEeLenFieldNumber = 7, + kPcLblkFieldNumber = 8, + kPcPcluFieldNumber = 9, + kPcStateFieldNumber = 10, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4ExtRmLeafFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4ExtRmLeafFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4ExtRmLeafFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Partial = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + Ext4ExtRmLeafFtraceEvent>; + + static constexpr FieldMetadata_Partial kPartial{}; + void set_partial(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Partial::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Start = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4ExtRmLeafFtraceEvent>; + + static constexpr FieldMetadata_Start kStart{}; + void set_start(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Start::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_EeLblk = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4ExtRmLeafFtraceEvent>; + + static constexpr FieldMetadata_EeLblk kEeLblk{}; + void set_ee_lblk(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_EeLblk::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_EePblk = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4ExtRmLeafFtraceEvent>; + + static constexpr FieldMetadata_EePblk kEePblk{}; + void set_ee_pblk(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_EePblk::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_EeLen = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4ExtRmLeafFtraceEvent>; + + static constexpr FieldMetadata_EeLen kEeLen{}; + void set_ee_len(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_EeLen::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PcLblk = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4ExtRmLeafFtraceEvent>; + + static constexpr FieldMetadata_PcLblk kPcLblk{}; + void set_pc_lblk(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_PcLblk::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PcPclu = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4ExtRmLeafFtraceEvent>; + + static constexpr FieldMetadata_PcPclu kPcPclu{}; + void set_pc_pclu(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_PcPclu::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PcState = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4ExtRmLeafFtraceEvent>; + + static constexpr FieldMetadata_PcState kPcState{}; + void set_pc_state(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_PcState::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class Ext4ExtRmIdxFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4ExtRmIdxFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4ExtRmIdxFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4ExtRmIdxFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_pblk() const { return at<3>().valid(); } + uint64_t pblk() const { return at<3>().as_uint64(); } +}; + +class Ext4ExtRmIdxFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4ExtRmIdxFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kPblkFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4ExtRmIdxFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4ExtRmIdxFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4ExtRmIdxFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pblk = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4ExtRmIdxFtraceEvent>; + + static constexpr FieldMetadata_Pblk kPblk{}; + void set_pblk(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pblk::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class Ext4ExtRemoveSpaceDoneFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4ExtRemoveSpaceDoneFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4ExtRemoveSpaceDoneFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4ExtRemoveSpaceDoneFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_start() const { return at<3>().valid(); } + uint32_t start() const { return at<3>().as_uint32(); } + bool has_end() const { return at<4>().valid(); } + uint32_t end() const { return at<4>().as_uint32(); } + bool has_depth() const { return at<5>().valid(); } + int32_t depth() const { return at<5>().as_int32(); } + bool has_partial() const { return at<6>().valid(); } + int64_t partial() const { return at<6>().as_int64(); } + bool has_eh_entries() const { return at<7>().valid(); } + uint32_t eh_entries() const { return at<7>().as_uint32(); } + bool has_pc_lblk() const { return at<8>().valid(); } + uint32_t pc_lblk() const { return at<8>().as_uint32(); } + bool has_pc_pclu() const { return at<9>().valid(); } + uint64_t pc_pclu() const { return at<9>().as_uint64(); } + bool has_pc_state() const { return at<10>().valid(); } + int32_t pc_state() const { return at<10>().as_int32(); } +}; + +class Ext4ExtRemoveSpaceDoneFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4ExtRemoveSpaceDoneFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kStartFieldNumber = 3, + kEndFieldNumber = 4, + kDepthFieldNumber = 5, + kPartialFieldNumber = 6, + kEhEntriesFieldNumber = 7, + kPcLblkFieldNumber = 8, + kPcPcluFieldNumber = 9, + kPcStateFieldNumber = 10, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4ExtRemoveSpaceDoneFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4ExtRemoveSpaceDoneFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4ExtRemoveSpaceDoneFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Start = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4ExtRemoveSpaceDoneFtraceEvent>; + + static constexpr FieldMetadata_Start kStart{}; + void set_start(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Start::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_End = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4ExtRemoveSpaceDoneFtraceEvent>; + + static constexpr FieldMetadata_End kEnd{}; + void set_end(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_End::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Depth = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4ExtRemoveSpaceDoneFtraceEvent>; + + static constexpr FieldMetadata_Depth kDepth{}; + void set_depth(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Depth::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Partial = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + Ext4ExtRemoveSpaceDoneFtraceEvent>; + + static constexpr FieldMetadata_Partial kPartial{}; + void set_partial(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Partial::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_EhEntries = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4ExtRemoveSpaceDoneFtraceEvent>; + + static constexpr FieldMetadata_EhEntries kEhEntries{}; + void set_eh_entries(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_EhEntries::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PcLblk = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4ExtRemoveSpaceDoneFtraceEvent>; + + static constexpr FieldMetadata_PcLblk kPcLblk{}; + void set_pc_lblk(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_PcLblk::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PcPclu = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4ExtRemoveSpaceDoneFtraceEvent>; + + static constexpr FieldMetadata_PcPclu kPcPclu{}; + void set_pc_pclu(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_PcPclu::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PcState = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4ExtRemoveSpaceDoneFtraceEvent>; + + static constexpr FieldMetadata_PcState kPcState{}; + void set_pc_state(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_PcState::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class Ext4ExtRemoveSpaceFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4ExtRemoveSpaceFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4ExtRemoveSpaceFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4ExtRemoveSpaceFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_start() const { return at<3>().valid(); } + uint32_t start() const { return at<3>().as_uint32(); } + bool has_end() const { return at<4>().valid(); } + uint32_t end() const { return at<4>().as_uint32(); } + bool has_depth() const { return at<5>().valid(); } + int32_t depth() const { return at<5>().as_int32(); } +}; + +class Ext4ExtRemoveSpaceFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4ExtRemoveSpaceFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kStartFieldNumber = 3, + kEndFieldNumber = 4, + kDepthFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4ExtRemoveSpaceFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4ExtRemoveSpaceFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4ExtRemoveSpaceFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Start = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4ExtRemoveSpaceFtraceEvent>; + + static constexpr FieldMetadata_Start kStart{}; + void set_start(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Start::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_End = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4ExtRemoveSpaceFtraceEvent>; + + static constexpr FieldMetadata_End kEnd{}; + void set_end(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_End::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Depth = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4ExtRemoveSpaceFtraceEvent>; + + static constexpr FieldMetadata_Depth kDepth{}; + void set_depth(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Depth::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class Ext4ExtPutInCacheFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4ExtPutInCacheFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4ExtPutInCacheFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4ExtPutInCacheFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_lblk() const { return at<3>().valid(); } + uint32_t lblk() const { return at<3>().as_uint32(); } + bool has_len() const { return at<4>().valid(); } + uint32_t len() const { return at<4>().as_uint32(); } + bool has_start() const { return at<5>().valid(); } + uint64_t start() const { return at<5>().as_uint64(); } +}; + +class Ext4ExtPutInCacheFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4ExtPutInCacheFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kLblkFieldNumber = 3, + kLenFieldNumber = 4, + kStartFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4ExtPutInCacheFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4ExtPutInCacheFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4ExtPutInCacheFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Lblk = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4ExtPutInCacheFtraceEvent>; + + static constexpr FieldMetadata_Lblk kLblk{}; + void set_lblk(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Lblk::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Len = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4ExtPutInCacheFtraceEvent>; + + static constexpr FieldMetadata_Len kLen{}; + void set_len(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Start = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4ExtPutInCacheFtraceEvent>; + + static constexpr FieldMetadata_Start kStart{}; + void set_start(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Start::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class Ext4ExtMapBlocksExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4ExtMapBlocksExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4ExtMapBlocksExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4ExtMapBlocksExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_flags() const { return at<3>().valid(); } + uint32_t flags() const { return at<3>().as_uint32(); } + bool has_pblk() const { return at<4>().valid(); } + uint64_t pblk() const { return at<4>().as_uint64(); } + bool has_lblk() const { return at<5>().valid(); } + uint32_t lblk() const { return at<5>().as_uint32(); } + bool has_len() const { return at<6>().valid(); } + uint32_t len() const { return at<6>().as_uint32(); } + bool has_mflags() const { return at<7>().valid(); } + uint32_t mflags() const { return at<7>().as_uint32(); } + bool has_ret() const { return at<8>().valid(); } + int32_t ret() const { return at<8>().as_int32(); } +}; + +class Ext4ExtMapBlocksExitFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4ExtMapBlocksExitFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kFlagsFieldNumber = 3, + kPblkFieldNumber = 4, + kLblkFieldNumber = 5, + kLenFieldNumber = 6, + kMflagsFieldNumber = 7, + kRetFieldNumber = 8, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4ExtMapBlocksExitFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4ExtMapBlocksExitFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4ExtMapBlocksExitFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Flags = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4ExtMapBlocksExitFtraceEvent>; + + static constexpr FieldMetadata_Flags kFlags{}; + void set_flags(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pblk = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4ExtMapBlocksExitFtraceEvent>; + + static constexpr FieldMetadata_Pblk kPblk{}; + void set_pblk(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pblk::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Lblk = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4ExtMapBlocksExitFtraceEvent>; + + static constexpr FieldMetadata_Lblk kLblk{}; + void set_lblk(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Lblk::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Len = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4ExtMapBlocksExitFtraceEvent>; + + static constexpr FieldMetadata_Len kLen{}; + void set_len(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Mflags = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4ExtMapBlocksExitFtraceEvent>; + + static constexpr FieldMetadata_Mflags kMflags{}; + void set_mflags(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Mflags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ret = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4ExtMapBlocksExitFtraceEvent>; + + static constexpr FieldMetadata_Ret kRet{}; + void set_ret(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class Ext4ExtMapBlocksEnterFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4ExtMapBlocksEnterFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4ExtMapBlocksEnterFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4ExtMapBlocksEnterFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_lblk() const { return at<3>().valid(); } + uint32_t lblk() const { return at<3>().as_uint32(); } + bool has_len() const { return at<4>().valid(); } + uint32_t len() const { return at<4>().as_uint32(); } + bool has_flags() const { return at<5>().valid(); } + uint32_t flags() const { return at<5>().as_uint32(); } +}; + +class Ext4ExtMapBlocksEnterFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4ExtMapBlocksEnterFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kLblkFieldNumber = 3, + kLenFieldNumber = 4, + kFlagsFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4ExtMapBlocksEnterFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4ExtMapBlocksEnterFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4ExtMapBlocksEnterFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Lblk = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4ExtMapBlocksEnterFtraceEvent>; + + static constexpr FieldMetadata_Lblk kLblk{}; + void set_lblk(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Lblk::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Len = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4ExtMapBlocksEnterFtraceEvent>; + + static constexpr FieldMetadata_Len kLen{}; + void set_len(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Flags = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4ExtMapBlocksEnterFtraceEvent>; + + static constexpr FieldMetadata_Flags kFlags{}; + void set_flags(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class Ext4ExtLoadExtentFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4ExtLoadExtentFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4ExtLoadExtentFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4ExtLoadExtentFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_pblk() const { return at<3>().valid(); } + uint64_t pblk() const { return at<3>().as_uint64(); } + bool has_lblk() const { return at<4>().valid(); } + uint32_t lblk() const { return at<4>().as_uint32(); } +}; + +class Ext4ExtLoadExtentFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4ExtLoadExtentFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kPblkFieldNumber = 3, + kLblkFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4ExtLoadExtentFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4ExtLoadExtentFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4ExtLoadExtentFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pblk = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4ExtLoadExtentFtraceEvent>; + + static constexpr FieldMetadata_Pblk kPblk{}; + void set_pblk(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pblk::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Lblk = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4ExtLoadExtentFtraceEvent>; + + static constexpr FieldMetadata_Lblk kLblk{}; + void set_lblk(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Lblk::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class Ext4ExtInCacheFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4ExtInCacheFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4ExtInCacheFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4ExtInCacheFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_lblk() const { return at<3>().valid(); } + uint32_t lblk() const { return at<3>().as_uint32(); } + bool has_ret() const { return at<4>().valid(); } + int32_t ret() const { return at<4>().as_int32(); } +}; + +class Ext4ExtInCacheFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4ExtInCacheFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kLblkFieldNumber = 3, + kRetFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4ExtInCacheFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4ExtInCacheFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4ExtInCacheFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Lblk = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4ExtInCacheFtraceEvent>; + + static constexpr FieldMetadata_Lblk kLblk{}; + void set_lblk(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Lblk::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ret = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4ExtInCacheFtraceEvent>; + + static constexpr FieldMetadata_Ret kRet{}; + void set_ret(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class Ext4ExtHandleUnwrittenExtentsFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4ExtHandleUnwrittenExtentsFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4ExtHandleUnwrittenExtentsFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4ExtHandleUnwrittenExtentsFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_flags() const { return at<3>().valid(); } + int32_t flags() const { return at<3>().as_int32(); } + bool has_lblk() const { return at<4>().valid(); } + uint32_t lblk() const { return at<4>().as_uint32(); } + bool has_pblk() const { return at<5>().valid(); } + uint64_t pblk() const { return at<5>().as_uint64(); } + bool has_len() const { return at<6>().valid(); } + uint32_t len() const { return at<6>().as_uint32(); } + bool has_allocated() const { return at<7>().valid(); } + uint32_t allocated() const { return at<7>().as_uint32(); } + bool has_newblk() const { return at<8>().valid(); } + uint64_t newblk() const { return at<8>().as_uint64(); } +}; + +class Ext4ExtHandleUnwrittenExtentsFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4ExtHandleUnwrittenExtentsFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kFlagsFieldNumber = 3, + kLblkFieldNumber = 4, + kPblkFieldNumber = 5, + kLenFieldNumber = 6, + kAllocatedFieldNumber = 7, + kNewblkFieldNumber = 8, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4ExtHandleUnwrittenExtentsFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4ExtHandleUnwrittenExtentsFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4ExtHandleUnwrittenExtentsFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Flags = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4ExtHandleUnwrittenExtentsFtraceEvent>; + + static constexpr FieldMetadata_Flags kFlags{}; + void set_flags(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Lblk = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4ExtHandleUnwrittenExtentsFtraceEvent>; + + static constexpr FieldMetadata_Lblk kLblk{}; + void set_lblk(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Lblk::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pblk = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4ExtHandleUnwrittenExtentsFtraceEvent>; + + static constexpr FieldMetadata_Pblk kPblk{}; + void set_pblk(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pblk::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Len = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4ExtHandleUnwrittenExtentsFtraceEvent>; + + static constexpr FieldMetadata_Len kLen{}; + void set_len(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Allocated = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4ExtHandleUnwrittenExtentsFtraceEvent>; + + static constexpr FieldMetadata_Allocated kAllocated{}; + void set_allocated(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Allocated::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Newblk = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4ExtHandleUnwrittenExtentsFtraceEvent>; + + static constexpr FieldMetadata_Newblk kNewblk{}; + void set_newblk(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Newblk::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class Ext4ExtConvertToInitializedFastpathFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4ExtConvertToInitializedFastpathFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4ExtConvertToInitializedFastpathFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4ExtConvertToInitializedFastpathFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_m_lblk() const { return at<3>().valid(); } + uint32_t m_lblk() const { return at<3>().as_uint32(); } + bool has_m_len() const { return at<4>().valid(); } + uint32_t m_len() const { return at<4>().as_uint32(); } + bool has_u_lblk() const { return at<5>().valid(); } + uint32_t u_lblk() const { return at<5>().as_uint32(); } + bool has_u_len() const { return at<6>().valid(); } + uint32_t u_len() const { return at<6>().as_uint32(); } + bool has_u_pblk() const { return at<7>().valid(); } + uint64_t u_pblk() const { return at<7>().as_uint64(); } + bool has_i_lblk() const { return at<8>().valid(); } + uint32_t i_lblk() const { return at<8>().as_uint32(); } + bool has_i_len() const { return at<9>().valid(); } + uint32_t i_len() const { return at<9>().as_uint32(); } + bool has_i_pblk() const { return at<10>().valid(); } + uint64_t i_pblk() const { return at<10>().as_uint64(); } +}; + +class Ext4ExtConvertToInitializedFastpathFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4ExtConvertToInitializedFastpathFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kMLblkFieldNumber = 3, + kMLenFieldNumber = 4, + kULblkFieldNumber = 5, + kULenFieldNumber = 6, + kUPblkFieldNumber = 7, + kILblkFieldNumber = 8, + kILenFieldNumber = 9, + kIPblkFieldNumber = 10, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4ExtConvertToInitializedFastpathFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4ExtConvertToInitializedFastpathFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4ExtConvertToInitializedFastpathFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_MLblk = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4ExtConvertToInitializedFastpathFtraceEvent>; + + static constexpr FieldMetadata_MLblk kMLblk{}; + void set_m_lblk(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_MLblk::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_MLen = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4ExtConvertToInitializedFastpathFtraceEvent>; + + static constexpr FieldMetadata_MLen kMLen{}; + void set_m_len(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_MLen::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ULblk = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4ExtConvertToInitializedFastpathFtraceEvent>; + + static constexpr FieldMetadata_ULblk kULblk{}; + void set_u_lblk(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ULblk::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ULen = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4ExtConvertToInitializedFastpathFtraceEvent>; + + static constexpr FieldMetadata_ULen kULen{}; + void set_u_len(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ULen::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_UPblk = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4ExtConvertToInitializedFastpathFtraceEvent>; + + static constexpr FieldMetadata_UPblk kUPblk{}; + void set_u_pblk(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_UPblk::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ILblk = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4ExtConvertToInitializedFastpathFtraceEvent>; + + static constexpr FieldMetadata_ILblk kILblk{}; + void set_i_lblk(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ILblk::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ILen = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4ExtConvertToInitializedFastpathFtraceEvent>; + + static constexpr FieldMetadata_ILen kILen{}; + void set_i_len(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ILen::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_IPblk = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4ExtConvertToInitializedFastpathFtraceEvent>; + + static constexpr FieldMetadata_IPblk kIPblk{}; + void set_i_pblk(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_IPblk::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class Ext4ExtConvertToInitializedEnterFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4ExtConvertToInitializedEnterFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4ExtConvertToInitializedEnterFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4ExtConvertToInitializedEnterFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_m_lblk() const { return at<3>().valid(); } + uint32_t m_lblk() const { return at<3>().as_uint32(); } + bool has_m_len() const { return at<4>().valid(); } + uint32_t m_len() const { return at<4>().as_uint32(); } + bool has_u_lblk() const { return at<5>().valid(); } + uint32_t u_lblk() const { return at<5>().as_uint32(); } + bool has_u_len() const { return at<6>().valid(); } + uint32_t u_len() const { return at<6>().as_uint32(); } + bool has_u_pblk() const { return at<7>().valid(); } + uint64_t u_pblk() const { return at<7>().as_uint64(); } +}; + +class Ext4ExtConvertToInitializedEnterFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4ExtConvertToInitializedEnterFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kMLblkFieldNumber = 3, + kMLenFieldNumber = 4, + kULblkFieldNumber = 5, + kULenFieldNumber = 6, + kUPblkFieldNumber = 7, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4ExtConvertToInitializedEnterFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4ExtConvertToInitializedEnterFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4ExtConvertToInitializedEnterFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_MLblk = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4ExtConvertToInitializedEnterFtraceEvent>; + + static constexpr FieldMetadata_MLblk kMLblk{}; + void set_m_lblk(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_MLblk::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_MLen = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4ExtConvertToInitializedEnterFtraceEvent>; + + static constexpr FieldMetadata_MLen kMLen{}; + void set_m_len(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_MLen::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ULblk = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4ExtConvertToInitializedEnterFtraceEvent>; + + static constexpr FieldMetadata_ULblk kULblk{}; + void set_u_lblk(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ULblk::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ULen = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4ExtConvertToInitializedEnterFtraceEvent>; + + static constexpr FieldMetadata_ULen kULen{}; + void set_u_len(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ULen::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_UPblk = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4ExtConvertToInitializedEnterFtraceEvent>; + + static constexpr FieldMetadata_UPblk kUPblk{}; + void set_u_pblk(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_UPblk::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class Ext4EvictInodeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4EvictInodeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4EvictInodeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4EvictInodeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_nlink() const { return at<3>().valid(); } + int32_t nlink() const { return at<3>().as_int32(); } +}; + +class Ext4EvictInodeFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4EvictInodeFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kNlinkFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4EvictInodeFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4EvictInodeFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4EvictInodeFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Nlink = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4EvictInodeFtraceEvent>; + + static constexpr FieldMetadata_Nlink kNlink{}; + void set_nlink(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Nlink::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class Ext4EsShrinkScanExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4EsShrinkScanExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4EsShrinkScanExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4EsShrinkScanExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_nr_shrunk() const { return at<2>().valid(); } + int32_t nr_shrunk() const { return at<2>().as_int32(); } + bool has_cache_cnt() const { return at<3>().valid(); } + int32_t cache_cnt() const { return at<3>().as_int32(); } +}; + +class Ext4EsShrinkScanExitFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4EsShrinkScanExitFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kNrShrunkFieldNumber = 2, + kCacheCntFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4EsShrinkScanExitFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4EsShrinkScanExitFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NrShrunk = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4EsShrinkScanExitFtraceEvent>; + + static constexpr FieldMetadata_NrShrunk kNrShrunk{}; + void set_nr_shrunk(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_NrShrunk::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CacheCnt = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4EsShrinkScanExitFtraceEvent>; + + static constexpr FieldMetadata_CacheCnt kCacheCnt{}; + void set_cache_cnt(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_CacheCnt::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class Ext4EsShrinkScanEnterFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4EsShrinkScanEnterFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4EsShrinkScanEnterFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4EsShrinkScanEnterFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_nr_to_scan() const { return at<2>().valid(); } + int32_t nr_to_scan() const { return at<2>().as_int32(); } + bool has_cache_cnt() const { return at<3>().valid(); } + int32_t cache_cnt() const { return at<3>().as_int32(); } +}; + +class Ext4EsShrinkScanEnterFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4EsShrinkScanEnterFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kNrToScanFieldNumber = 2, + kCacheCntFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4EsShrinkScanEnterFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4EsShrinkScanEnterFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NrToScan = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4EsShrinkScanEnterFtraceEvent>; + + static constexpr FieldMetadata_NrToScan kNrToScan{}; + void set_nr_to_scan(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_NrToScan::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CacheCnt = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4EsShrinkScanEnterFtraceEvent>; + + static constexpr FieldMetadata_CacheCnt kCacheCnt{}; + void set_cache_cnt(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_CacheCnt::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class Ext4EsShrinkCountFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4EsShrinkCountFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4EsShrinkCountFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4EsShrinkCountFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_nr_to_scan() const { return at<2>().valid(); } + int32_t nr_to_scan() const { return at<2>().as_int32(); } + bool has_cache_cnt() const { return at<3>().valid(); } + int32_t cache_cnt() const { return at<3>().as_int32(); } +}; + +class Ext4EsShrinkCountFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4EsShrinkCountFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kNrToScanFieldNumber = 2, + kCacheCntFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4EsShrinkCountFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4EsShrinkCountFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NrToScan = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4EsShrinkCountFtraceEvent>; + + static constexpr FieldMetadata_NrToScan kNrToScan{}; + void set_nr_to_scan(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_NrToScan::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CacheCnt = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4EsShrinkCountFtraceEvent>; + + static constexpr FieldMetadata_CacheCnt kCacheCnt{}; + void set_cache_cnt(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_CacheCnt::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class Ext4EsShrinkFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4EsShrinkFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4EsShrinkFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4EsShrinkFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_nr_shrunk() const { return at<2>().valid(); } + int32_t nr_shrunk() const { return at<2>().as_int32(); } + bool has_scan_time() const { return at<3>().valid(); } + uint64_t scan_time() const { return at<3>().as_uint64(); } + bool has_nr_skipped() const { return at<4>().valid(); } + int32_t nr_skipped() const { return at<4>().as_int32(); } + bool has_retried() const { return at<5>().valid(); } + int32_t retried() const { return at<5>().as_int32(); } +}; + +class Ext4EsShrinkFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4EsShrinkFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kNrShrunkFieldNumber = 2, + kScanTimeFieldNumber = 3, + kNrSkippedFieldNumber = 4, + kRetriedFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4EsShrinkFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4EsShrinkFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NrShrunk = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4EsShrinkFtraceEvent>; + + static constexpr FieldMetadata_NrShrunk kNrShrunk{}; + void set_nr_shrunk(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_NrShrunk::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ScanTime = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4EsShrinkFtraceEvent>; + + static constexpr FieldMetadata_ScanTime kScanTime{}; + void set_scan_time(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_ScanTime::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NrSkipped = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4EsShrinkFtraceEvent>; + + static constexpr FieldMetadata_NrSkipped kNrSkipped{}; + void set_nr_skipped(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_NrSkipped::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Retried = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4EsShrinkFtraceEvent>; + + static constexpr FieldMetadata_Retried kRetried{}; + void set_retried(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Retried::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class Ext4EsRemoveExtentFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4EsRemoveExtentFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4EsRemoveExtentFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4EsRemoveExtentFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_lblk() const { return at<3>().valid(); } + int64_t lblk() const { return at<3>().as_int64(); } + bool has_len() const { return at<4>().valid(); } + int64_t len() const { return at<4>().as_int64(); } +}; + +class Ext4EsRemoveExtentFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4EsRemoveExtentFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kLblkFieldNumber = 3, + kLenFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4EsRemoveExtentFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4EsRemoveExtentFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4EsRemoveExtentFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Lblk = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + Ext4EsRemoveExtentFtraceEvent>; + + static constexpr FieldMetadata_Lblk kLblk{}; + void set_lblk(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Lblk::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Len = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + Ext4EsRemoveExtentFtraceEvent>; + + static constexpr FieldMetadata_Len kLen{}; + void set_len(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } +}; + +class Ext4EsLookupExtentExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4EsLookupExtentExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4EsLookupExtentExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4EsLookupExtentExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_lblk() const { return at<3>().valid(); } + uint32_t lblk() const { return at<3>().as_uint32(); } + bool has_len() const { return at<4>().valid(); } + uint32_t len() const { return at<4>().as_uint32(); } + bool has_pblk() const { return at<5>().valid(); } + uint64_t pblk() const { return at<5>().as_uint64(); } + bool has_status() const { return at<6>().valid(); } + uint64_t status() const { return at<6>().as_uint64(); } + bool has_found() const { return at<7>().valid(); } + int32_t found() const { return at<7>().as_int32(); } +}; + +class Ext4EsLookupExtentExitFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4EsLookupExtentExitFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kLblkFieldNumber = 3, + kLenFieldNumber = 4, + kPblkFieldNumber = 5, + kStatusFieldNumber = 6, + kFoundFieldNumber = 7, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4EsLookupExtentExitFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4EsLookupExtentExitFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4EsLookupExtentExitFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Lblk = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4EsLookupExtentExitFtraceEvent>; + + static constexpr FieldMetadata_Lblk kLblk{}; + void set_lblk(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Lblk::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Len = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4EsLookupExtentExitFtraceEvent>; + + static constexpr FieldMetadata_Len kLen{}; + void set_len(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pblk = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4EsLookupExtentExitFtraceEvent>; + + static constexpr FieldMetadata_Pblk kPblk{}; + void set_pblk(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pblk::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Status = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4EsLookupExtentExitFtraceEvent>; + + static constexpr FieldMetadata_Status kStatus{}; + void set_status(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Status::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Found = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4EsLookupExtentExitFtraceEvent>; + + static constexpr FieldMetadata_Found kFound{}; + void set_found(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Found::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class Ext4EsLookupExtentEnterFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4EsLookupExtentEnterFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4EsLookupExtentEnterFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4EsLookupExtentEnterFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_lblk() const { return at<3>().valid(); } + uint32_t lblk() const { return at<3>().as_uint32(); } +}; + +class Ext4EsLookupExtentEnterFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4EsLookupExtentEnterFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kLblkFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4EsLookupExtentEnterFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4EsLookupExtentEnterFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4EsLookupExtentEnterFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Lblk = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4EsLookupExtentEnterFtraceEvent>; + + static constexpr FieldMetadata_Lblk kLblk{}; + void set_lblk(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Lblk::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class Ext4EsInsertExtentFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4EsInsertExtentFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4EsInsertExtentFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4EsInsertExtentFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_lblk() const { return at<3>().valid(); } + uint32_t lblk() const { return at<3>().as_uint32(); } + bool has_len() const { return at<4>().valid(); } + uint32_t len() const { return at<4>().as_uint32(); } + bool has_pblk() const { return at<5>().valid(); } + uint64_t pblk() const { return at<5>().as_uint64(); } + bool has_status() const { return at<6>().valid(); } + uint64_t status() const { return at<6>().as_uint64(); } +}; + +class Ext4EsInsertExtentFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4EsInsertExtentFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kLblkFieldNumber = 3, + kLenFieldNumber = 4, + kPblkFieldNumber = 5, + kStatusFieldNumber = 6, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4EsInsertExtentFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4EsInsertExtentFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4EsInsertExtentFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Lblk = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4EsInsertExtentFtraceEvent>; + + static constexpr FieldMetadata_Lblk kLblk{}; + void set_lblk(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Lblk::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Len = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4EsInsertExtentFtraceEvent>; + + static constexpr FieldMetadata_Len kLen{}; + void set_len(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pblk = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4EsInsertExtentFtraceEvent>; + + static constexpr FieldMetadata_Pblk kPblk{}; + void set_pblk(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pblk::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Status = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4EsInsertExtentFtraceEvent>; + + static constexpr FieldMetadata_Status kStatus{}; + void set_status(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Status::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class Ext4EsFindDelayedExtentRangeExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4EsFindDelayedExtentRangeExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4EsFindDelayedExtentRangeExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4EsFindDelayedExtentRangeExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_lblk() const { return at<3>().valid(); } + uint32_t lblk() const { return at<3>().as_uint32(); } + bool has_len() const { return at<4>().valid(); } + uint32_t len() const { return at<4>().as_uint32(); } + bool has_pblk() const { return at<5>().valid(); } + uint64_t pblk() const { return at<5>().as_uint64(); } + bool has_status() const { return at<6>().valid(); } + uint64_t status() const { return at<6>().as_uint64(); } +}; + +class Ext4EsFindDelayedExtentRangeExitFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4EsFindDelayedExtentRangeExitFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kLblkFieldNumber = 3, + kLenFieldNumber = 4, + kPblkFieldNumber = 5, + kStatusFieldNumber = 6, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4EsFindDelayedExtentRangeExitFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4EsFindDelayedExtentRangeExitFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4EsFindDelayedExtentRangeExitFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Lblk = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4EsFindDelayedExtentRangeExitFtraceEvent>; + + static constexpr FieldMetadata_Lblk kLblk{}; + void set_lblk(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Lblk::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Len = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4EsFindDelayedExtentRangeExitFtraceEvent>; + + static constexpr FieldMetadata_Len kLen{}; + void set_len(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pblk = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4EsFindDelayedExtentRangeExitFtraceEvent>; + + static constexpr FieldMetadata_Pblk kPblk{}; + void set_pblk(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pblk::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Status = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4EsFindDelayedExtentRangeExitFtraceEvent>; + + static constexpr FieldMetadata_Status kStatus{}; + void set_status(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Status::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class Ext4EsFindDelayedExtentRangeEnterFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4EsFindDelayedExtentRangeEnterFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4EsFindDelayedExtentRangeEnterFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4EsFindDelayedExtentRangeEnterFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_lblk() const { return at<3>().valid(); } + uint32_t lblk() const { return at<3>().as_uint32(); } +}; + +class Ext4EsFindDelayedExtentRangeEnterFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4EsFindDelayedExtentRangeEnterFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kLblkFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4EsFindDelayedExtentRangeEnterFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4EsFindDelayedExtentRangeEnterFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4EsFindDelayedExtentRangeEnterFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Lblk = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4EsFindDelayedExtentRangeEnterFtraceEvent>; + + static constexpr FieldMetadata_Lblk kLblk{}; + void set_lblk(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Lblk::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class Ext4EsCacheExtentFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4EsCacheExtentFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4EsCacheExtentFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4EsCacheExtentFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_lblk() const { return at<3>().valid(); } + uint32_t lblk() const { return at<3>().as_uint32(); } + bool has_len() const { return at<4>().valid(); } + uint32_t len() const { return at<4>().as_uint32(); } + bool has_pblk() const { return at<5>().valid(); } + uint64_t pblk() const { return at<5>().as_uint64(); } + bool has_status() const { return at<6>().valid(); } + uint32_t status() const { return at<6>().as_uint32(); } +}; + +class Ext4EsCacheExtentFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4EsCacheExtentFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kLblkFieldNumber = 3, + kLenFieldNumber = 4, + kPblkFieldNumber = 5, + kStatusFieldNumber = 6, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4EsCacheExtentFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4EsCacheExtentFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4EsCacheExtentFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Lblk = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4EsCacheExtentFtraceEvent>; + + static constexpr FieldMetadata_Lblk kLblk{}; + void set_lblk(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Lblk::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Len = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4EsCacheExtentFtraceEvent>; + + static constexpr FieldMetadata_Len kLen{}; + void set_len(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pblk = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4EsCacheExtentFtraceEvent>; + + static constexpr FieldMetadata_Pblk kPblk{}; + void set_pblk(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pblk::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Status = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4EsCacheExtentFtraceEvent>; + + static constexpr FieldMetadata_Status kStatus{}; + void set_status(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Status::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class Ext4DropInodeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4DropInodeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4DropInodeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4DropInodeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_drop() const { return at<3>().valid(); } + int32_t drop() const { return at<3>().as_int32(); } +}; + +class Ext4DropInodeFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4DropInodeFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kDropFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4DropInodeFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4DropInodeFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4DropInodeFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Drop = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4DropInodeFtraceEvent>; + + static constexpr FieldMetadata_Drop kDrop{}; + void set_drop(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Drop::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class Ext4DiscardPreallocationsFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4DiscardPreallocationsFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4DiscardPreallocationsFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4DiscardPreallocationsFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_len() const { return at<3>().valid(); } + uint32_t len() const { return at<3>().as_uint32(); } + bool has_needed() const { return at<4>().valid(); } + uint32_t needed() const { return at<4>().as_uint32(); } +}; + +class Ext4DiscardPreallocationsFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4DiscardPreallocationsFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kLenFieldNumber = 3, + kNeededFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4DiscardPreallocationsFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4DiscardPreallocationsFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4DiscardPreallocationsFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Len = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4DiscardPreallocationsFtraceEvent>; + + static constexpr FieldMetadata_Len kLen{}; + void set_len(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Needed = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4DiscardPreallocationsFtraceEvent>; + + static constexpr FieldMetadata_Needed kNeeded{}; + void set_needed(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Needed::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class Ext4DiscardBlocksFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4DiscardBlocksFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4DiscardBlocksFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4DiscardBlocksFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_blk() const { return at<2>().valid(); } + uint64_t blk() const { return at<2>().as_uint64(); } + bool has_count() const { return at<3>().valid(); } + uint64_t count() const { return at<3>().as_uint64(); } +}; + +class Ext4DiscardBlocksFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4DiscardBlocksFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kBlkFieldNumber = 2, + kCountFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4DiscardBlocksFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4DiscardBlocksFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Blk = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4DiscardBlocksFtraceEvent>; + + static constexpr FieldMetadata_Blk kBlk{}; + void set_blk(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Blk::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Count = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4DiscardBlocksFtraceEvent>; + + static constexpr FieldMetadata_Count kCount{}; + void set_count(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Count::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class Ext4DirectIOExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4DirectIOExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4DirectIOExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4DirectIOExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_pos() const { return at<3>().valid(); } + int64_t pos() const { return at<3>().as_int64(); } + bool has_len() const { return at<4>().valid(); } + uint64_t len() const { return at<4>().as_uint64(); } + bool has_rw() const { return at<5>().valid(); } + int32_t rw() const { return at<5>().as_int32(); } + bool has_ret() const { return at<6>().valid(); } + int32_t ret() const { return at<6>().as_int32(); } +}; + +class Ext4DirectIOExitFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4DirectIOExitFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kPosFieldNumber = 3, + kLenFieldNumber = 4, + kRwFieldNumber = 5, + kRetFieldNumber = 6, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4DirectIOExitFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4DirectIOExitFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4DirectIOExitFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pos = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + Ext4DirectIOExitFtraceEvent>; + + static constexpr FieldMetadata_Pos kPos{}; + void set_pos(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pos::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Len = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4DirectIOExitFtraceEvent>; + + static constexpr FieldMetadata_Len kLen{}; + void set_len(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Rw = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4DirectIOExitFtraceEvent>; + + static constexpr FieldMetadata_Rw kRw{}; + void set_rw(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Rw::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ret = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4DirectIOExitFtraceEvent>; + + static constexpr FieldMetadata_Ret kRet{}; + void set_ret(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class Ext4DirectIOEnterFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4DirectIOEnterFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4DirectIOEnterFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4DirectIOEnterFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_pos() const { return at<3>().valid(); } + int64_t pos() const { return at<3>().as_int64(); } + bool has_len() const { return at<4>().valid(); } + uint64_t len() const { return at<4>().as_uint64(); } + bool has_rw() const { return at<5>().valid(); } + int32_t rw() const { return at<5>().as_int32(); } +}; + +class Ext4DirectIOEnterFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4DirectIOEnterFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kPosFieldNumber = 3, + kLenFieldNumber = 4, + kRwFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4DirectIOEnterFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4DirectIOEnterFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4DirectIOEnterFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pos = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + Ext4DirectIOEnterFtraceEvent>; + + static constexpr FieldMetadata_Pos kPos{}; + void set_pos(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pos::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Len = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4DirectIOEnterFtraceEvent>; + + static constexpr FieldMetadata_Len kLen{}; + void set_len(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Rw = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4DirectIOEnterFtraceEvent>; + + static constexpr FieldMetadata_Rw kRw{}; + void set_rw(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Rw::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class Ext4DaWritePagesExtentFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4DaWritePagesExtentFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4DaWritePagesExtentFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4DaWritePagesExtentFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_lblk() const { return at<3>().valid(); } + uint64_t lblk() const { return at<3>().as_uint64(); } + bool has_len() const { return at<4>().valid(); } + uint32_t len() const { return at<4>().as_uint32(); } + bool has_flags() const { return at<5>().valid(); } + uint32_t flags() const { return at<5>().as_uint32(); } +}; + +class Ext4DaWritePagesExtentFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4DaWritePagesExtentFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kLblkFieldNumber = 3, + kLenFieldNumber = 4, + kFlagsFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4DaWritePagesExtentFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4DaWritePagesExtentFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4DaWritePagesExtentFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Lblk = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4DaWritePagesExtentFtraceEvent>; + + static constexpr FieldMetadata_Lblk kLblk{}; + void set_lblk(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Lblk::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Len = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4DaWritePagesExtentFtraceEvent>; + + static constexpr FieldMetadata_Len kLen{}; + void set_len(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Flags = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4DaWritePagesExtentFtraceEvent>; + + static constexpr FieldMetadata_Flags kFlags{}; + void set_flags(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class Ext4DaWritePagesFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4DaWritePagesFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4DaWritePagesFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4DaWritePagesFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_first_page() const { return at<3>().valid(); } + uint64_t first_page() const { return at<3>().as_uint64(); } + bool has_nr_to_write() const { return at<4>().valid(); } + int64_t nr_to_write() const { return at<4>().as_int64(); } + bool has_sync_mode() const { return at<5>().valid(); } + int32_t sync_mode() const { return at<5>().as_int32(); } + bool has_b_blocknr() const { return at<6>().valid(); } + uint64_t b_blocknr() const { return at<6>().as_uint64(); } + bool has_b_size() const { return at<7>().valid(); } + uint32_t b_size() const { return at<7>().as_uint32(); } + bool has_b_state() const { return at<8>().valid(); } + uint32_t b_state() const { return at<8>().as_uint32(); } + bool has_io_done() const { return at<9>().valid(); } + int32_t io_done() const { return at<9>().as_int32(); } + bool has_pages_written() const { return at<10>().valid(); } + int32_t pages_written() const { return at<10>().as_int32(); } +}; + +class Ext4DaWritePagesFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4DaWritePagesFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kFirstPageFieldNumber = 3, + kNrToWriteFieldNumber = 4, + kSyncModeFieldNumber = 5, + kBBlocknrFieldNumber = 6, + kBSizeFieldNumber = 7, + kBStateFieldNumber = 8, + kIoDoneFieldNumber = 9, + kPagesWrittenFieldNumber = 10, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4DaWritePagesFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4DaWritePagesFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4DaWritePagesFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FirstPage = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4DaWritePagesFtraceEvent>; + + static constexpr FieldMetadata_FirstPage kFirstPage{}; + void set_first_page(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_FirstPage::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NrToWrite = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + Ext4DaWritePagesFtraceEvent>; + + static constexpr FieldMetadata_NrToWrite kNrToWrite{}; + void set_nr_to_write(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_NrToWrite::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SyncMode = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4DaWritePagesFtraceEvent>; + + static constexpr FieldMetadata_SyncMode kSyncMode{}; + void set_sync_mode(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_SyncMode::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_BBlocknr = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4DaWritePagesFtraceEvent>; + + static constexpr FieldMetadata_BBlocknr kBBlocknr{}; + void set_b_blocknr(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_BBlocknr::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_BSize = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4DaWritePagesFtraceEvent>; + + static constexpr FieldMetadata_BSize kBSize{}; + void set_b_size(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_BSize::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_BState = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4DaWritePagesFtraceEvent>; + + static constexpr FieldMetadata_BState kBState{}; + void set_b_state(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_BState::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_IoDone = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4DaWritePagesFtraceEvent>; + + static constexpr FieldMetadata_IoDone kIoDone{}; + void set_io_done(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_IoDone::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PagesWritten = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4DaWritePagesFtraceEvent>; + + static constexpr FieldMetadata_PagesWritten kPagesWritten{}; + void set_pages_written(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_PagesWritten::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class Ext4DaUpdateReserveSpaceFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4DaUpdateReserveSpaceFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4DaUpdateReserveSpaceFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4DaUpdateReserveSpaceFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_i_blocks() const { return at<3>().valid(); } + uint64_t i_blocks() const { return at<3>().as_uint64(); } + bool has_used_blocks() const { return at<4>().valid(); } + int32_t used_blocks() const { return at<4>().as_int32(); } + bool has_reserved_data_blocks() const { return at<5>().valid(); } + int32_t reserved_data_blocks() const { return at<5>().as_int32(); } + bool has_reserved_meta_blocks() const { return at<6>().valid(); } + int32_t reserved_meta_blocks() const { return at<6>().as_int32(); } + bool has_allocated_meta_blocks() const { return at<7>().valid(); } + int32_t allocated_meta_blocks() const { return at<7>().as_int32(); } + bool has_quota_claim() const { return at<8>().valid(); } + int32_t quota_claim() const { return at<8>().as_int32(); } + bool has_mode() const { return at<9>().valid(); } + uint32_t mode() const { return at<9>().as_uint32(); } +}; + +class Ext4DaUpdateReserveSpaceFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4DaUpdateReserveSpaceFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kIBlocksFieldNumber = 3, + kUsedBlocksFieldNumber = 4, + kReservedDataBlocksFieldNumber = 5, + kReservedMetaBlocksFieldNumber = 6, + kAllocatedMetaBlocksFieldNumber = 7, + kQuotaClaimFieldNumber = 8, + kModeFieldNumber = 9, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4DaUpdateReserveSpaceFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4DaUpdateReserveSpaceFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4DaUpdateReserveSpaceFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_IBlocks = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4DaUpdateReserveSpaceFtraceEvent>; + + static constexpr FieldMetadata_IBlocks kIBlocks{}; + void set_i_blocks(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_IBlocks::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_UsedBlocks = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4DaUpdateReserveSpaceFtraceEvent>; + + static constexpr FieldMetadata_UsedBlocks kUsedBlocks{}; + void set_used_blocks(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_UsedBlocks::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ReservedDataBlocks = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4DaUpdateReserveSpaceFtraceEvent>; + + static constexpr FieldMetadata_ReservedDataBlocks kReservedDataBlocks{}; + void set_reserved_data_blocks(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ReservedDataBlocks::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ReservedMetaBlocks = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4DaUpdateReserveSpaceFtraceEvent>; + + static constexpr FieldMetadata_ReservedMetaBlocks kReservedMetaBlocks{}; + void set_reserved_meta_blocks(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ReservedMetaBlocks::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_AllocatedMetaBlocks = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4DaUpdateReserveSpaceFtraceEvent>; + + static constexpr FieldMetadata_AllocatedMetaBlocks kAllocatedMetaBlocks{}; + void set_allocated_meta_blocks(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_AllocatedMetaBlocks::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_QuotaClaim = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4DaUpdateReserveSpaceFtraceEvent>; + + static constexpr FieldMetadata_QuotaClaim kQuotaClaim{}; + void set_quota_claim(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_QuotaClaim::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Mode = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4DaUpdateReserveSpaceFtraceEvent>; + + static constexpr FieldMetadata_Mode kMode{}; + void set_mode(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Mode::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class Ext4DaReserveSpaceFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4DaReserveSpaceFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4DaReserveSpaceFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4DaReserveSpaceFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_i_blocks() const { return at<3>().valid(); } + uint64_t i_blocks() const { return at<3>().as_uint64(); } + bool has_reserved_data_blocks() const { return at<4>().valid(); } + int32_t reserved_data_blocks() const { return at<4>().as_int32(); } + bool has_reserved_meta_blocks() const { return at<5>().valid(); } + int32_t reserved_meta_blocks() const { return at<5>().as_int32(); } + bool has_mode() const { return at<6>().valid(); } + uint32_t mode() const { return at<6>().as_uint32(); } + bool has_md_needed() const { return at<7>().valid(); } + int32_t md_needed() const { return at<7>().as_int32(); } +}; + +class Ext4DaReserveSpaceFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4DaReserveSpaceFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kIBlocksFieldNumber = 3, + kReservedDataBlocksFieldNumber = 4, + kReservedMetaBlocksFieldNumber = 5, + kModeFieldNumber = 6, + kMdNeededFieldNumber = 7, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4DaReserveSpaceFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4DaReserveSpaceFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4DaReserveSpaceFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_IBlocks = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4DaReserveSpaceFtraceEvent>; + + static constexpr FieldMetadata_IBlocks kIBlocks{}; + void set_i_blocks(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_IBlocks::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ReservedDataBlocks = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4DaReserveSpaceFtraceEvent>; + + static constexpr FieldMetadata_ReservedDataBlocks kReservedDataBlocks{}; + void set_reserved_data_blocks(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ReservedDataBlocks::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ReservedMetaBlocks = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4DaReserveSpaceFtraceEvent>; + + static constexpr FieldMetadata_ReservedMetaBlocks kReservedMetaBlocks{}; + void set_reserved_meta_blocks(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ReservedMetaBlocks::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Mode = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4DaReserveSpaceFtraceEvent>; + + static constexpr FieldMetadata_Mode kMode{}; + void set_mode(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Mode::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_MdNeeded = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4DaReserveSpaceFtraceEvent>; + + static constexpr FieldMetadata_MdNeeded kMdNeeded{}; + void set_md_needed(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_MdNeeded::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class Ext4DaReleaseSpaceFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4DaReleaseSpaceFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4DaReleaseSpaceFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4DaReleaseSpaceFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_i_blocks() const { return at<3>().valid(); } + uint64_t i_blocks() const { return at<3>().as_uint64(); } + bool has_freed_blocks() const { return at<4>().valid(); } + int32_t freed_blocks() const { return at<4>().as_int32(); } + bool has_reserved_data_blocks() const { return at<5>().valid(); } + int32_t reserved_data_blocks() const { return at<5>().as_int32(); } + bool has_reserved_meta_blocks() const { return at<6>().valid(); } + int32_t reserved_meta_blocks() const { return at<6>().as_int32(); } + bool has_allocated_meta_blocks() const { return at<7>().valid(); } + int32_t allocated_meta_blocks() const { return at<7>().as_int32(); } + bool has_mode() const { return at<8>().valid(); } + uint32_t mode() const { return at<8>().as_uint32(); } +}; + +class Ext4DaReleaseSpaceFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4DaReleaseSpaceFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kIBlocksFieldNumber = 3, + kFreedBlocksFieldNumber = 4, + kReservedDataBlocksFieldNumber = 5, + kReservedMetaBlocksFieldNumber = 6, + kAllocatedMetaBlocksFieldNumber = 7, + kModeFieldNumber = 8, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4DaReleaseSpaceFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4DaReleaseSpaceFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4DaReleaseSpaceFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_IBlocks = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4DaReleaseSpaceFtraceEvent>; + + static constexpr FieldMetadata_IBlocks kIBlocks{}; + void set_i_blocks(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_IBlocks::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FreedBlocks = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4DaReleaseSpaceFtraceEvent>; + + static constexpr FieldMetadata_FreedBlocks kFreedBlocks{}; + void set_freed_blocks(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_FreedBlocks::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ReservedDataBlocks = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4DaReleaseSpaceFtraceEvent>; + + static constexpr FieldMetadata_ReservedDataBlocks kReservedDataBlocks{}; + void set_reserved_data_blocks(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ReservedDataBlocks::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ReservedMetaBlocks = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4DaReleaseSpaceFtraceEvent>; + + static constexpr FieldMetadata_ReservedMetaBlocks kReservedMetaBlocks{}; + void set_reserved_meta_blocks(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ReservedMetaBlocks::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_AllocatedMetaBlocks = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4DaReleaseSpaceFtraceEvent>; + + static constexpr FieldMetadata_AllocatedMetaBlocks kAllocatedMetaBlocks{}; + void set_allocated_meta_blocks(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_AllocatedMetaBlocks::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Mode = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4DaReleaseSpaceFtraceEvent>; + + static constexpr FieldMetadata_Mode kMode{}; + void set_mode(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Mode::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class Ext4CollapseRangeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4CollapseRangeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4CollapseRangeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4CollapseRangeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_offset() const { return at<3>().valid(); } + int64_t offset() const { return at<3>().as_int64(); } + bool has_len() const { return at<4>().valid(); } + int64_t len() const { return at<4>().as_int64(); } +}; + +class Ext4CollapseRangeFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4CollapseRangeFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kOffsetFieldNumber = 3, + kLenFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4CollapseRangeFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4CollapseRangeFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4CollapseRangeFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Offset = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + Ext4CollapseRangeFtraceEvent>; + + static constexpr FieldMetadata_Offset kOffset{}; + void set_offset(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Offset::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Len = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + Ext4CollapseRangeFtraceEvent>; + + static constexpr FieldMetadata_Len kLen{}; + void set_len(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } +}; + +class Ext4BeginOrderedTruncateFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4BeginOrderedTruncateFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4BeginOrderedTruncateFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4BeginOrderedTruncateFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_new_size() const { return at<3>().valid(); } + int64_t new_size() const { return at<3>().as_int64(); } +}; + +class Ext4BeginOrderedTruncateFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4BeginOrderedTruncateFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kNewSizeFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4BeginOrderedTruncateFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4BeginOrderedTruncateFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4BeginOrderedTruncateFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NewSize = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + Ext4BeginOrderedTruncateFtraceEvent>; + + static constexpr FieldMetadata_NewSize kNewSize{}; + void set_new_size(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_NewSize::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } +}; + +class Ext4AllocateInodeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4AllocateInodeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4AllocateInodeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4AllocateInodeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_dir() const { return at<3>().valid(); } + uint64_t dir() const { return at<3>().as_uint64(); } + bool has_mode() const { return at<4>().valid(); } + uint32_t mode() const { return at<4>().as_uint32(); } +}; + +class Ext4AllocateInodeFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4AllocateInodeFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kDirFieldNumber = 3, + kModeFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4AllocateInodeFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4AllocateInodeFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4AllocateInodeFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Dir = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4AllocateInodeFtraceEvent>; + + static constexpr FieldMetadata_Dir kDir{}; + void set_dir(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dir::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Mode = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4AllocateInodeFtraceEvent>; + + static constexpr FieldMetadata_Mode kMode{}; + void set_mode(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Mode::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class Ext4AllocateBlocksFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4AllocateBlocksFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4AllocateBlocksFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4AllocateBlocksFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_block() const { return at<3>().valid(); } + uint64_t block() const { return at<3>().as_uint64(); } + bool has_len() const { return at<4>().valid(); } + uint32_t len() const { return at<4>().as_uint32(); } + bool has_logical() const { return at<5>().valid(); } + uint32_t logical() const { return at<5>().as_uint32(); } + bool has_lleft() const { return at<6>().valid(); } + uint32_t lleft() const { return at<6>().as_uint32(); } + bool has_lright() const { return at<7>().valid(); } + uint32_t lright() const { return at<7>().as_uint32(); } + bool has_goal() const { return at<8>().valid(); } + uint64_t goal() const { return at<8>().as_uint64(); } + bool has_pleft() const { return at<9>().valid(); } + uint64_t pleft() const { return at<9>().as_uint64(); } + bool has_pright() const { return at<10>().valid(); } + uint64_t pright() const { return at<10>().as_uint64(); } + bool has_flags() const { return at<11>().valid(); } + uint32_t flags() const { return at<11>().as_uint32(); } +}; + +class Ext4AllocateBlocksFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4AllocateBlocksFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kBlockFieldNumber = 3, + kLenFieldNumber = 4, + kLogicalFieldNumber = 5, + kLleftFieldNumber = 6, + kLrightFieldNumber = 7, + kGoalFieldNumber = 8, + kPleftFieldNumber = 9, + kPrightFieldNumber = 10, + kFlagsFieldNumber = 11, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4AllocateBlocksFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4AllocateBlocksFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4AllocateBlocksFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Block = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4AllocateBlocksFtraceEvent>; + + static constexpr FieldMetadata_Block kBlock{}; + void set_block(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Block::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Len = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4AllocateBlocksFtraceEvent>; + + static constexpr FieldMetadata_Len kLen{}; + void set_len(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Logical = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4AllocateBlocksFtraceEvent>; + + static constexpr FieldMetadata_Logical kLogical{}; + void set_logical(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Logical::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Lleft = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4AllocateBlocksFtraceEvent>; + + static constexpr FieldMetadata_Lleft kLleft{}; + void set_lleft(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Lleft::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Lright = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4AllocateBlocksFtraceEvent>; + + static constexpr FieldMetadata_Lright kLright{}; + void set_lright(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Lright::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Goal = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4AllocateBlocksFtraceEvent>; + + static constexpr FieldMetadata_Goal kGoal{}; + void set_goal(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Goal::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pleft = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4AllocateBlocksFtraceEvent>; + + static constexpr FieldMetadata_Pleft kPleft{}; + void set_pleft(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pleft::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pright = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4AllocateBlocksFtraceEvent>; + + static constexpr FieldMetadata_Pright kPright{}; + void set_pright(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pright::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Flags = + ::protozero::proto_utils::FieldMetadata< + 11, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4AllocateBlocksFtraceEvent>; + + static constexpr FieldMetadata_Flags kFlags{}; + void set_flags(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class Ext4AllocDaBlocksFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4AllocDaBlocksFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4AllocDaBlocksFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4AllocDaBlocksFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_data_blocks() const { return at<3>().valid(); } + uint32_t data_blocks() const { return at<3>().as_uint32(); } + bool has_meta_blocks() const { return at<4>().valid(); } + uint32_t meta_blocks() const { return at<4>().as_uint32(); } +}; + +class Ext4AllocDaBlocksFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4AllocDaBlocksFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kDataBlocksFieldNumber = 3, + kMetaBlocksFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4AllocDaBlocksFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4AllocDaBlocksFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4AllocDaBlocksFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DataBlocks = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4AllocDaBlocksFtraceEvent>; + + static constexpr FieldMetadata_DataBlocks kDataBlocks{}; + void set_data_blocks(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_DataBlocks::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_MetaBlocks = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4AllocDaBlocksFtraceEvent>; + + static constexpr FieldMetadata_MetaBlocks kMetaBlocks{}; + void set_meta_blocks(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_MetaBlocks::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class Ext4SyncFileExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4SyncFileExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4SyncFileExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4SyncFileExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_ret() const { return at<3>().valid(); } + int32_t ret() const { return at<3>().as_int32(); } +}; + +class Ext4SyncFileExitFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4SyncFileExitFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kRetFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4SyncFileExitFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4SyncFileExitFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4SyncFileExitFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ret = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4SyncFileExitFtraceEvent>; + + static constexpr FieldMetadata_Ret kRet{}; + void set_ret(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class Ext4SyncFileEnterFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4SyncFileEnterFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4SyncFileEnterFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4SyncFileEnterFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_parent() const { return at<3>().valid(); } + uint64_t parent() const { return at<3>().as_uint64(); } + bool has_datasync() const { return at<4>().valid(); } + int32_t datasync() const { return at<4>().as_int32(); } +}; + +class Ext4SyncFileEnterFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4SyncFileEnterFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kParentFieldNumber = 3, + kDatasyncFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4SyncFileEnterFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4SyncFileEnterFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4SyncFileEnterFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Parent = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4SyncFileEnterFtraceEvent>; + + static constexpr FieldMetadata_Parent kParent{}; + void set_parent(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Parent::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Datasync = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + Ext4SyncFileEnterFtraceEvent>; + + static constexpr FieldMetadata_Datasync kDatasync{}; + void set_datasync(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Datasync::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class Ext4DaWriteEndFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4DaWriteEndFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4DaWriteEndFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4DaWriteEndFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_pos() const { return at<3>().valid(); } + int64_t pos() const { return at<3>().as_int64(); } + bool has_len() const { return at<4>().valid(); } + uint32_t len() const { return at<4>().as_uint32(); } + bool has_copied() const { return at<5>().valid(); } + uint32_t copied() const { return at<5>().as_uint32(); } +}; + +class Ext4DaWriteEndFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4DaWriteEndFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kPosFieldNumber = 3, + kLenFieldNumber = 4, + kCopiedFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4DaWriteEndFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4DaWriteEndFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4DaWriteEndFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pos = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + Ext4DaWriteEndFtraceEvent>; + + static constexpr FieldMetadata_Pos kPos{}; + void set_pos(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pos::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Len = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4DaWriteEndFtraceEvent>; + + static constexpr FieldMetadata_Len kLen{}; + void set_len(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Copied = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4DaWriteEndFtraceEvent>; + + static constexpr FieldMetadata_Copied kCopied{}; + void set_copied(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Copied::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class Ext4DaWriteBeginFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + Ext4DaWriteBeginFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Ext4DaWriteBeginFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Ext4DaWriteBeginFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_pos() const { return at<3>().valid(); } + int64_t pos() const { return at<3>().as_int64(); } + bool has_len() const { return at<4>().valid(); } + uint32_t len() const { return at<4>().as_uint32(); } + bool has_flags() const { return at<5>().valid(); } + uint32_t flags() const { return at<5>().as_uint32(); } +}; + +class Ext4DaWriteBeginFtraceEvent : public ::protozero::Message { + public: + using Decoder = Ext4DaWriteBeginFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kInoFieldNumber = 2, + kPosFieldNumber = 3, + kLenFieldNumber = 4, + kFlagsFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Ext4DaWriteBeginFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4DaWriteBeginFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + Ext4DaWriteBeginFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pos = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + Ext4DaWriteBeginFtraceEvent>; + + static constexpr FieldMetadata_Pos kPos{}; + void set_pos(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pos::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Len = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4DaWriteBeginFtraceEvent>; + + static constexpr FieldMetadata_Len kLen{}; + void set_len(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Flags = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + Ext4DaWriteBeginFtraceEvent>; + + static constexpr FieldMetadata_Flags kFlags{}; + void set_flags(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class DrmVblankEventDeliveredFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + DrmVblankEventDeliveredFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit DrmVblankEventDeliveredFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit DrmVblankEventDeliveredFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_crtc() const { return at<1>().valid(); } + int32_t crtc() const { return at<1>().as_int32(); } + bool has_file() const { return at<2>().valid(); } + uint64_t file() const { return at<2>().as_uint64(); } + bool has_seq() const { return at<3>().valid(); } + uint32_t seq() const { return at<3>().as_uint32(); } +}; + +class DrmVblankEventDeliveredFtraceEvent : public ::protozero::Message { + public: + using Decoder = DrmVblankEventDeliveredFtraceEvent_Decoder; + enum : int32_t { + kCrtcFieldNumber = 1, + kFileFieldNumber = 2, + kSeqFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.DrmVblankEventDeliveredFtraceEvent"; } + + + using FieldMetadata_Crtc = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + DrmVblankEventDeliveredFtraceEvent>; + + static constexpr FieldMetadata_Crtc kCrtc{}; + void set_crtc(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Crtc::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_File = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + DrmVblankEventDeliveredFtraceEvent>; + + static constexpr FieldMetadata_File kFile{}; + void set_file(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_File::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Seq = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + DrmVblankEventDeliveredFtraceEvent>; + + static constexpr FieldMetadata_Seq kSeq{}; + void set_seq(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Seq::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class DrmVblankEventFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + DrmVblankEventFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit DrmVblankEventFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit DrmVblankEventFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_crtc() const { return at<1>().valid(); } + int32_t crtc() const { return at<1>().as_int32(); } + bool has_high_prec() const { return at<2>().valid(); } + uint32_t high_prec() const { return at<2>().as_uint32(); } + bool has_seq() const { return at<3>().valid(); } + uint32_t seq() const { return at<3>().as_uint32(); } + bool has_time() const { return at<4>().valid(); } + int64_t time() const { return at<4>().as_int64(); } +}; + +class DrmVblankEventFtraceEvent : public ::protozero::Message { + public: + using Decoder = DrmVblankEventFtraceEvent_Decoder; + enum : int32_t { + kCrtcFieldNumber = 1, + kHighPrecFieldNumber = 2, + kSeqFieldNumber = 3, + kTimeFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.DrmVblankEventFtraceEvent"; } + + + using FieldMetadata_Crtc = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + DrmVblankEventFtraceEvent>; + + static constexpr FieldMetadata_Crtc kCrtc{}; + void set_crtc(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Crtc::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_HighPrec = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + DrmVblankEventFtraceEvent>; + + static constexpr FieldMetadata_HighPrec kHighPrec{}; + void set_high_prec(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_HighPrec::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Seq = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + DrmVblankEventFtraceEvent>; + + static constexpr FieldMetadata_Seq kSeq{}; + void set_seq(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Seq::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Time = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + DrmVblankEventFtraceEvent>; + + static constexpr FieldMetadata_Time kTime{}; + void set_time(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Time::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } +}; + +class DpuDsiTxFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + DpuDsiTxFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit DpuDsiTxFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit DpuDsiTxFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_type() const { return at<1>().valid(); } + uint32_t type() const { return at<1>().as_uint32(); } + bool has_tx_buf() const { return at<2>().valid(); } + uint32_t tx_buf() const { return at<2>().as_uint32(); } + bool has_last() const { return at<3>().valid(); } + uint32_t last() const { return at<3>().as_uint32(); } + bool has_delay_ms() const { return at<4>().valid(); } + uint32_t delay_ms() const { return at<4>().as_uint32(); } +}; + +class DpuDsiTxFtraceEvent : public ::protozero::Message { + public: + using Decoder = DpuDsiTxFtraceEvent_Decoder; + enum : int32_t { + kTypeFieldNumber = 1, + kTxBufFieldNumber = 2, + kLastFieldNumber = 3, + kDelayMsFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.DpuDsiTxFtraceEvent"; } + + + using FieldMetadata_Type = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + DpuDsiTxFtraceEvent>; + + static constexpr FieldMetadata_Type kType{}; + void set_type(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TxBuf = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + DpuDsiTxFtraceEvent>; + + static constexpr FieldMetadata_TxBuf kTxBuf{}; + void set_tx_buf(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TxBuf::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Last = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + DpuDsiTxFtraceEvent>; + + static constexpr FieldMetadata_Last kLast{}; + void set_last(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Last::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DelayMs = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + DpuDsiTxFtraceEvent>; + + static constexpr FieldMetadata_DelayMs kDelayMs{}; + void set_delay_ms(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_DelayMs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class DpuDsiRxFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + DpuDsiRxFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit DpuDsiRxFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit DpuDsiRxFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_cmd() const { return at<1>().valid(); } + uint32_t cmd() const { return at<1>().as_uint32(); } + bool has_rx_buf() const { return at<2>().valid(); } + uint32_t rx_buf() const { return at<2>().as_uint32(); } +}; + +class DpuDsiRxFtraceEvent : public ::protozero::Message { + public: + using Decoder = DpuDsiRxFtraceEvent_Decoder; + enum : int32_t { + kCmdFieldNumber = 1, + kRxBufFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.DpuDsiRxFtraceEvent"; } + + + using FieldMetadata_Cmd = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + DpuDsiRxFtraceEvent>; + + static constexpr FieldMetadata_Cmd kCmd{}; + void set_cmd(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Cmd::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_RxBuf = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + DpuDsiRxFtraceEvent>; + + static constexpr FieldMetadata_RxBuf kRxBuf{}; + void set_rx_buf(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_RxBuf::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class DpuDsiCmdFifoStatusFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + DpuDsiCmdFifoStatusFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit DpuDsiCmdFifoStatusFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit DpuDsiCmdFifoStatusFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_header() const { return at<1>().valid(); } + uint32_t header() const { return at<1>().as_uint32(); } + bool has_payload() const { return at<2>().valid(); } + uint32_t payload() const { return at<2>().as_uint32(); } +}; + +class DpuDsiCmdFifoStatusFtraceEvent : public ::protozero::Message { + public: + using Decoder = DpuDsiCmdFifoStatusFtraceEvent_Decoder; + enum : int32_t { + kHeaderFieldNumber = 1, + kPayloadFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.DpuDsiCmdFifoStatusFtraceEvent"; } + + + using FieldMetadata_Header = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + DpuDsiCmdFifoStatusFtraceEvent>; + + static constexpr FieldMetadata_Header kHeader{}; + void set_header(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Header::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Payload = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + DpuDsiCmdFifoStatusFtraceEvent>; + + static constexpr FieldMetadata_Payload kPayload{}; + void set_payload(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Payload::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class DpuTracingMarkWriteFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + DpuTracingMarkWriteFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit DpuTracingMarkWriteFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit DpuTracingMarkWriteFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_pid() const { return at<1>().valid(); } + int32_t pid() const { return at<1>().as_int32(); } + bool has_trace_name() const { return at<2>().valid(); } + ::protozero::ConstChars trace_name() const { return at<2>().as_string(); } + bool has_trace_begin() const { return at<3>().valid(); } + uint32_t trace_begin() const { return at<3>().as_uint32(); } + bool has_name() const { return at<4>().valid(); } + ::protozero::ConstChars name() const { return at<4>().as_string(); } + bool has_type() const { return at<5>().valid(); } + uint32_t type() const { return at<5>().as_uint32(); } + bool has_value() const { return at<6>().valid(); } + int32_t value() const { return at<6>().as_int32(); } +}; + +class DpuTracingMarkWriteFtraceEvent : public ::protozero::Message { + public: + using Decoder = DpuTracingMarkWriteFtraceEvent_Decoder; + enum : int32_t { + kPidFieldNumber = 1, + kTraceNameFieldNumber = 2, + kTraceBeginFieldNumber = 3, + kNameFieldNumber = 4, + kTypeFieldNumber = 5, + kValueFieldNumber = 6, + }; + static constexpr const char* GetName() { return ".perfetto.protos.DpuTracingMarkWriteFtraceEvent"; } + + + using FieldMetadata_Pid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + DpuTracingMarkWriteFtraceEvent>; + + static constexpr FieldMetadata_Pid kPid{}; + void set_pid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TraceName = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + DpuTracingMarkWriteFtraceEvent>; + + static constexpr FieldMetadata_TraceName kTraceName{}; + void set_trace_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_TraceName::kFieldId, data, size); + } + void set_trace_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_TraceName::kFieldId, chars.data, chars.size); + } + void set_trace_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_TraceName::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TraceBegin = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + DpuTracingMarkWriteFtraceEvent>; + + static constexpr FieldMetadata_TraceBegin kTraceBegin{}; + void set_trace_begin(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TraceBegin::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + DpuTracingMarkWriteFtraceEvent>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Type = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + DpuTracingMarkWriteFtraceEvent>; + + static constexpr FieldMetadata_Type kType{}; + void set_type(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Value = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + DpuTracingMarkWriteFtraceEvent>; + + static constexpr FieldMetadata_Value kValue{}; + void set_value(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class DmaHeapStatFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + DmaHeapStatFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit DmaHeapStatFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit DmaHeapStatFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_inode() const { return at<1>().valid(); } + uint64_t inode() const { return at<1>().as_uint64(); } + bool has_len() const { return at<2>().valid(); } + int64_t len() const { return at<2>().as_int64(); } + bool has_total_allocated() const { return at<3>().valid(); } + uint64_t total_allocated() const { return at<3>().as_uint64(); } +}; + +class DmaHeapStatFtraceEvent : public ::protozero::Message { + public: + using Decoder = DmaHeapStatFtraceEvent_Decoder; + enum : int32_t { + kInodeFieldNumber = 1, + kLenFieldNumber = 2, + kTotalAllocatedFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.DmaHeapStatFtraceEvent"; } + + + using FieldMetadata_Inode = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + DmaHeapStatFtraceEvent>; + + static constexpr FieldMetadata_Inode kInode{}; + void set_inode(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Inode::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Len = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + DmaHeapStatFtraceEvent>; + + static constexpr FieldMetadata_Len kLen{}; + void set_len(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TotalAllocated = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + DmaHeapStatFtraceEvent>; + + static constexpr FieldMetadata_TotalAllocated kTotalAllocated{}; + void set_total_allocated(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_TotalAllocated::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class DmaFenceWaitEndFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + DmaFenceWaitEndFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit DmaFenceWaitEndFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit DmaFenceWaitEndFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_context() const { return at<1>().valid(); } + uint32_t context() const { return at<1>().as_uint32(); } + bool has_driver() const { return at<2>().valid(); } + ::protozero::ConstChars driver() const { return at<2>().as_string(); } + bool has_seqno() const { return at<3>().valid(); } + uint32_t seqno() const { return at<3>().as_uint32(); } + bool has_timeline() const { return at<4>().valid(); } + ::protozero::ConstChars timeline() const { return at<4>().as_string(); } +}; + +class DmaFenceWaitEndFtraceEvent : public ::protozero::Message { + public: + using Decoder = DmaFenceWaitEndFtraceEvent_Decoder; + enum : int32_t { + kContextFieldNumber = 1, + kDriverFieldNumber = 2, + kSeqnoFieldNumber = 3, + kTimelineFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.DmaFenceWaitEndFtraceEvent"; } + + + using FieldMetadata_Context = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + DmaFenceWaitEndFtraceEvent>; + + static constexpr FieldMetadata_Context kContext{}; + void set_context(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Context::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Driver = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + DmaFenceWaitEndFtraceEvent>; + + static constexpr FieldMetadata_Driver kDriver{}; + void set_driver(const char* data, size_t size) { + AppendBytes(FieldMetadata_Driver::kFieldId, data, size); + } + void set_driver(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Driver::kFieldId, chars.data, chars.size); + } + void set_driver(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Driver::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Seqno = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + DmaFenceWaitEndFtraceEvent>; + + static constexpr FieldMetadata_Seqno kSeqno{}; + void set_seqno(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Seqno::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Timeline = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + DmaFenceWaitEndFtraceEvent>; + + static constexpr FieldMetadata_Timeline kTimeline{}; + void set_timeline(const char* data, size_t size) { + AppendBytes(FieldMetadata_Timeline::kFieldId, data, size); + } + void set_timeline(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Timeline::kFieldId, chars.data, chars.size); + } + void set_timeline(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Timeline::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class DmaFenceWaitStartFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + DmaFenceWaitStartFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit DmaFenceWaitStartFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit DmaFenceWaitStartFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_context() const { return at<1>().valid(); } + uint32_t context() const { return at<1>().as_uint32(); } + bool has_driver() const { return at<2>().valid(); } + ::protozero::ConstChars driver() const { return at<2>().as_string(); } + bool has_seqno() const { return at<3>().valid(); } + uint32_t seqno() const { return at<3>().as_uint32(); } + bool has_timeline() const { return at<4>().valid(); } + ::protozero::ConstChars timeline() const { return at<4>().as_string(); } +}; + +class DmaFenceWaitStartFtraceEvent : public ::protozero::Message { + public: + using Decoder = DmaFenceWaitStartFtraceEvent_Decoder; + enum : int32_t { + kContextFieldNumber = 1, + kDriverFieldNumber = 2, + kSeqnoFieldNumber = 3, + kTimelineFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.DmaFenceWaitStartFtraceEvent"; } + + + using FieldMetadata_Context = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + DmaFenceWaitStartFtraceEvent>; + + static constexpr FieldMetadata_Context kContext{}; + void set_context(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Context::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Driver = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + DmaFenceWaitStartFtraceEvent>; + + static constexpr FieldMetadata_Driver kDriver{}; + void set_driver(const char* data, size_t size) { + AppendBytes(FieldMetadata_Driver::kFieldId, data, size); + } + void set_driver(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Driver::kFieldId, chars.data, chars.size); + } + void set_driver(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Driver::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Seqno = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + DmaFenceWaitStartFtraceEvent>; + + static constexpr FieldMetadata_Seqno kSeqno{}; + void set_seqno(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Seqno::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Timeline = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + DmaFenceWaitStartFtraceEvent>; + + static constexpr FieldMetadata_Timeline kTimeline{}; + void set_timeline(const char* data, size_t size) { + AppendBytes(FieldMetadata_Timeline::kFieldId, data, size); + } + void set_timeline(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Timeline::kFieldId, chars.data, chars.size); + } + void set_timeline(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Timeline::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class DmaFenceSignaledFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + DmaFenceSignaledFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit DmaFenceSignaledFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit DmaFenceSignaledFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_context() const { return at<1>().valid(); } + uint32_t context() const { return at<1>().as_uint32(); } + bool has_driver() const { return at<2>().valid(); } + ::protozero::ConstChars driver() const { return at<2>().as_string(); } + bool has_seqno() const { return at<3>().valid(); } + uint32_t seqno() const { return at<3>().as_uint32(); } + bool has_timeline() const { return at<4>().valid(); } + ::protozero::ConstChars timeline() const { return at<4>().as_string(); } +}; + +class DmaFenceSignaledFtraceEvent : public ::protozero::Message { + public: + using Decoder = DmaFenceSignaledFtraceEvent_Decoder; + enum : int32_t { + kContextFieldNumber = 1, + kDriverFieldNumber = 2, + kSeqnoFieldNumber = 3, + kTimelineFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.DmaFenceSignaledFtraceEvent"; } + + + using FieldMetadata_Context = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + DmaFenceSignaledFtraceEvent>; + + static constexpr FieldMetadata_Context kContext{}; + void set_context(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Context::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Driver = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + DmaFenceSignaledFtraceEvent>; + + static constexpr FieldMetadata_Driver kDriver{}; + void set_driver(const char* data, size_t size) { + AppendBytes(FieldMetadata_Driver::kFieldId, data, size); + } + void set_driver(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Driver::kFieldId, chars.data, chars.size); + } + void set_driver(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Driver::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Seqno = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + DmaFenceSignaledFtraceEvent>; + + static constexpr FieldMetadata_Seqno kSeqno{}; + void set_seqno(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Seqno::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Timeline = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + DmaFenceSignaledFtraceEvent>; + + static constexpr FieldMetadata_Timeline kTimeline{}; + void set_timeline(const char* data, size_t size) { + AppendBytes(FieldMetadata_Timeline::kFieldId, data, size); + } + void set_timeline(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Timeline::kFieldId, chars.data, chars.size); + } + void set_timeline(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Timeline::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class DmaFenceEmitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + DmaFenceEmitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit DmaFenceEmitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit DmaFenceEmitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_context() const { return at<1>().valid(); } + uint32_t context() const { return at<1>().as_uint32(); } + bool has_driver() const { return at<2>().valid(); } + ::protozero::ConstChars driver() const { return at<2>().as_string(); } + bool has_seqno() const { return at<3>().valid(); } + uint32_t seqno() const { return at<3>().as_uint32(); } + bool has_timeline() const { return at<4>().valid(); } + ::protozero::ConstChars timeline() const { return at<4>().as_string(); } +}; + +class DmaFenceEmitFtraceEvent : public ::protozero::Message { + public: + using Decoder = DmaFenceEmitFtraceEvent_Decoder; + enum : int32_t { + kContextFieldNumber = 1, + kDriverFieldNumber = 2, + kSeqnoFieldNumber = 3, + kTimelineFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.DmaFenceEmitFtraceEvent"; } + + + using FieldMetadata_Context = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + DmaFenceEmitFtraceEvent>; + + static constexpr FieldMetadata_Context kContext{}; + void set_context(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Context::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Driver = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + DmaFenceEmitFtraceEvent>; + + static constexpr FieldMetadata_Driver kDriver{}; + void set_driver(const char* data, size_t size) { + AppendBytes(FieldMetadata_Driver::kFieldId, data, size); + } + void set_driver(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Driver::kFieldId, chars.data, chars.size); + } + void set_driver(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Driver::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Seqno = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + DmaFenceEmitFtraceEvent>; + + static constexpr FieldMetadata_Seqno kSeqno{}; + void set_seqno(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Seqno::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Timeline = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + DmaFenceEmitFtraceEvent>; + + static constexpr FieldMetadata_Timeline kTimeline{}; + void set_timeline(const char* data, size_t size) { + AppendBytes(FieldMetadata_Timeline::kFieldId, data, size); + } + void set_timeline(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Timeline::kFieldId, chars.data, chars.size); + } + void set_timeline(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Timeline::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class DmaFenceInitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + DmaFenceInitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit DmaFenceInitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit DmaFenceInitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_context() const { return at<1>().valid(); } + uint32_t context() const { return at<1>().as_uint32(); } + bool has_driver() const { return at<2>().valid(); } + ::protozero::ConstChars driver() const { return at<2>().as_string(); } + bool has_seqno() const { return at<3>().valid(); } + uint32_t seqno() const { return at<3>().as_uint32(); } + bool has_timeline() const { return at<4>().valid(); } + ::protozero::ConstChars timeline() const { return at<4>().as_string(); } +}; + +class DmaFenceInitFtraceEvent : public ::protozero::Message { + public: + using Decoder = DmaFenceInitFtraceEvent_Decoder; + enum : int32_t { + kContextFieldNumber = 1, + kDriverFieldNumber = 2, + kSeqnoFieldNumber = 3, + kTimelineFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.DmaFenceInitFtraceEvent"; } + + + using FieldMetadata_Context = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + DmaFenceInitFtraceEvent>; + + static constexpr FieldMetadata_Context kContext{}; + void set_context(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Context::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Driver = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + DmaFenceInitFtraceEvent>; + + static constexpr FieldMetadata_Driver kDriver{}; + void set_driver(const char* data, size_t size) { + AppendBytes(FieldMetadata_Driver::kFieldId, data, size); + } + void set_driver(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Driver::kFieldId, chars.data, chars.size); + } + void set_driver(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Driver::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Seqno = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + DmaFenceInitFtraceEvent>; + + static constexpr FieldMetadata_Seqno kSeqno{}; + void set_seqno(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Seqno::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Timeline = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + DmaFenceInitFtraceEvent>; + + static constexpr FieldMetadata_Timeline kTimeline{}; + void set_timeline(const char* data, size_t size) { + AppendBytes(FieldMetadata_Timeline::kFieldId, data, size); + } + void set_timeline(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Timeline::kFieldId, chars.data, chars.size); + } + void set_timeline(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Timeline::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class CrosEcSensorhubDataFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + CrosEcSensorhubDataFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit CrosEcSensorhubDataFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit CrosEcSensorhubDataFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_current_time() const { return at<1>().valid(); } + int64_t current_time() const { return at<1>().as_int64(); } + bool has_current_timestamp() const { return at<2>().valid(); } + int64_t current_timestamp() const { return at<2>().as_int64(); } + bool has_delta() const { return at<3>().valid(); } + int64_t delta() const { return at<3>().as_int64(); } + bool has_ec_fifo_timestamp() const { return at<4>().valid(); } + uint32_t ec_fifo_timestamp() const { return at<4>().as_uint32(); } + bool has_ec_sensor_num() const { return at<5>().valid(); } + uint32_t ec_sensor_num() const { return at<5>().as_uint32(); } + bool has_fifo_timestamp() const { return at<6>().valid(); } + int64_t fifo_timestamp() const { return at<6>().as_int64(); } +}; + +class CrosEcSensorhubDataFtraceEvent : public ::protozero::Message { + public: + using Decoder = CrosEcSensorhubDataFtraceEvent_Decoder; + enum : int32_t { + kCurrentTimeFieldNumber = 1, + kCurrentTimestampFieldNumber = 2, + kDeltaFieldNumber = 3, + kEcFifoTimestampFieldNumber = 4, + kEcSensorNumFieldNumber = 5, + kFifoTimestampFieldNumber = 6, + }; + static constexpr const char* GetName() { return ".perfetto.protos.CrosEcSensorhubDataFtraceEvent"; } + + + using FieldMetadata_CurrentTime = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + CrosEcSensorhubDataFtraceEvent>; + + static constexpr FieldMetadata_CurrentTime kCurrentTime{}; + void set_current_time(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_CurrentTime::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CurrentTimestamp = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + CrosEcSensorhubDataFtraceEvent>; + + static constexpr FieldMetadata_CurrentTimestamp kCurrentTimestamp{}; + void set_current_timestamp(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_CurrentTimestamp::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Delta = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + CrosEcSensorhubDataFtraceEvent>; + + static constexpr FieldMetadata_Delta kDelta{}; + void set_delta(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Delta::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_EcFifoTimestamp = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + CrosEcSensorhubDataFtraceEvent>; + + static constexpr FieldMetadata_EcFifoTimestamp kEcFifoTimestamp{}; + void set_ec_fifo_timestamp(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_EcFifoTimestamp::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_EcSensorNum = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + CrosEcSensorhubDataFtraceEvent>; + + static constexpr FieldMetadata_EcSensorNum kEcSensorNum{}; + void set_ec_sensor_num(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_EcSensorNum::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FifoTimestamp = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + CrosEcSensorhubDataFtraceEvent>; + + static constexpr FieldMetadata_FifoTimestamp kFifoTimestamp{}; + void set_fifo_timestamp(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_FifoTimestamp::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } +}; + +class CpuhpPauseFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + CpuhpPauseFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit CpuhpPauseFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit CpuhpPauseFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_active_cpus() const { return at<1>().valid(); } + uint32_t active_cpus() const { return at<1>().as_uint32(); } + bool has_cpus() const { return at<2>().valid(); } + uint32_t cpus() const { return at<2>().as_uint32(); } + bool has_pause() const { return at<3>().valid(); } + uint32_t pause() const { return at<3>().as_uint32(); } + bool has_time() const { return at<4>().valid(); } + uint32_t time() const { return at<4>().as_uint32(); } +}; + +class CpuhpPauseFtraceEvent : public ::protozero::Message { + public: + using Decoder = CpuhpPauseFtraceEvent_Decoder; + enum : int32_t { + kActiveCpusFieldNumber = 1, + kCpusFieldNumber = 2, + kPauseFieldNumber = 3, + kTimeFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.CpuhpPauseFtraceEvent"; } + + + using FieldMetadata_ActiveCpus = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + CpuhpPauseFtraceEvent>; + + static constexpr FieldMetadata_ActiveCpus kActiveCpus{}; + void set_active_cpus(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ActiveCpus::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Cpus = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + CpuhpPauseFtraceEvent>; + + static constexpr FieldMetadata_Cpus kCpus{}; + void set_cpus(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Cpus::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pause = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + CpuhpPauseFtraceEvent>; + + static constexpr FieldMetadata_Pause kPause{}; + void set_pause(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pause::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Time = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + CpuhpPauseFtraceEvent>; + + static constexpr FieldMetadata_Time kTime{}; + void set_time(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Time::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class CpuhpLatencyFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + CpuhpLatencyFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit CpuhpLatencyFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit CpuhpLatencyFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_cpu() const { return at<1>().valid(); } + uint32_t cpu() const { return at<1>().as_uint32(); } + bool has_ret() const { return at<2>().valid(); } + int32_t ret() const { return at<2>().as_int32(); } + bool has_state() const { return at<3>().valid(); } + uint32_t state() const { return at<3>().as_uint32(); } + bool has_time() const { return at<4>().valid(); } + uint64_t time() const { return at<4>().as_uint64(); } +}; + +class CpuhpLatencyFtraceEvent : public ::protozero::Message { + public: + using Decoder = CpuhpLatencyFtraceEvent_Decoder; + enum : int32_t { + kCpuFieldNumber = 1, + kRetFieldNumber = 2, + kStateFieldNumber = 3, + kTimeFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.CpuhpLatencyFtraceEvent"; } + + + using FieldMetadata_Cpu = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + CpuhpLatencyFtraceEvent>; + + static constexpr FieldMetadata_Cpu kCpu{}; + void set_cpu(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Cpu::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ret = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + CpuhpLatencyFtraceEvent>; + + static constexpr FieldMetadata_Ret kRet{}; + void set_ret(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_State = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + CpuhpLatencyFtraceEvent>; + + static constexpr FieldMetadata_State kState{}; + void set_state(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_State::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Time = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + CpuhpLatencyFtraceEvent>; + + static constexpr FieldMetadata_Time kTime{}; + void set_time(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Time::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class CpuhpEnterFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + CpuhpEnterFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit CpuhpEnterFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit CpuhpEnterFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_cpu() const { return at<1>().valid(); } + uint32_t cpu() const { return at<1>().as_uint32(); } + bool has_fun() const { return at<2>().valid(); } + uint64_t fun() const { return at<2>().as_uint64(); } + bool has_idx() const { return at<3>().valid(); } + int32_t idx() const { return at<3>().as_int32(); } + bool has_target() const { return at<4>().valid(); } + int32_t target() const { return at<4>().as_int32(); } +}; + +class CpuhpEnterFtraceEvent : public ::protozero::Message { + public: + using Decoder = CpuhpEnterFtraceEvent_Decoder; + enum : int32_t { + kCpuFieldNumber = 1, + kFunFieldNumber = 2, + kIdxFieldNumber = 3, + kTargetFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.CpuhpEnterFtraceEvent"; } + + + using FieldMetadata_Cpu = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + CpuhpEnterFtraceEvent>; + + static constexpr FieldMetadata_Cpu kCpu{}; + void set_cpu(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Cpu::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Fun = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + CpuhpEnterFtraceEvent>; + + static constexpr FieldMetadata_Fun kFun{}; + void set_fun(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Fun::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Idx = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + CpuhpEnterFtraceEvent>; + + static constexpr FieldMetadata_Idx kIdx{}; + void set_idx(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Idx::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Target = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + CpuhpEnterFtraceEvent>; + + static constexpr FieldMetadata_Target kTarget{}; + void set_target(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Target::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class CpuhpMultiEnterFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + CpuhpMultiEnterFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit CpuhpMultiEnterFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit CpuhpMultiEnterFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_cpu() const { return at<1>().valid(); } + uint32_t cpu() const { return at<1>().as_uint32(); } + bool has_fun() const { return at<2>().valid(); } + uint64_t fun() const { return at<2>().as_uint64(); } + bool has_idx() const { return at<3>().valid(); } + int32_t idx() const { return at<3>().as_int32(); } + bool has_target() const { return at<4>().valid(); } + int32_t target() const { return at<4>().as_int32(); } +}; + +class CpuhpMultiEnterFtraceEvent : public ::protozero::Message { + public: + using Decoder = CpuhpMultiEnterFtraceEvent_Decoder; + enum : int32_t { + kCpuFieldNumber = 1, + kFunFieldNumber = 2, + kIdxFieldNumber = 3, + kTargetFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.CpuhpMultiEnterFtraceEvent"; } + + + using FieldMetadata_Cpu = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + CpuhpMultiEnterFtraceEvent>; + + static constexpr FieldMetadata_Cpu kCpu{}; + void set_cpu(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Cpu::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Fun = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + CpuhpMultiEnterFtraceEvent>; + + static constexpr FieldMetadata_Fun kFun{}; + void set_fun(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Fun::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Idx = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + CpuhpMultiEnterFtraceEvent>; + + static constexpr FieldMetadata_Idx kIdx{}; + void set_idx(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Idx::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Target = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + CpuhpMultiEnterFtraceEvent>; + + static constexpr FieldMetadata_Target kTarget{}; + void set_target(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Target::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class CpuhpExitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + CpuhpExitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit CpuhpExitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit CpuhpExitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_cpu() const { return at<1>().valid(); } + uint32_t cpu() const { return at<1>().as_uint32(); } + bool has_idx() const { return at<2>().valid(); } + int32_t idx() const { return at<2>().as_int32(); } + bool has_ret() const { return at<3>().valid(); } + int32_t ret() const { return at<3>().as_int32(); } + bool has_state() const { return at<4>().valid(); } + int32_t state() const { return at<4>().as_int32(); } +}; + +class CpuhpExitFtraceEvent : public ::protozero::Message { + public: + using Decoder = CpuhpExitFtraceEvent_Decoder; + enum : int32_t { + kCpuFieldNumber = 1, + kIdxFieldNumber = 2, + kRetFieldNumber = 3, + kStateFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.CpuhpExitFtraceEvent"; } + + + using FieldMetadata_Cpu = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + CpuhpExitFtraceEvent>; + + static constexpr FieldMetadata_Cpu kCpu{}; + void set_cpu(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Cpu::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Idx = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + CpuhpExitFtraceEvent>; + + static constexpr FieldMetadata_Idx kIdx{}; + void set_idx(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Idx::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ret = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + CpuhpExitFtraceEvent>; + + static constexpr FieldMetadata_Ret kRet{}; + void set_ret(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_State = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + CpuhpExitFtraceEvent>; + + static constexpr FieldMetadata_State kState{}; + void set_state(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_State::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class MmCompactionWakeupKcompactdFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + MmCompactionWakeupKcompactdFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MmCompactionWakeupKcompactdFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MmCompactionWakeupKcompactdFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_nid() const { return at<1>().valid(); } + int32_t nid() const { return at<1>().as_int32(); } + bool has_order() const { return at<2>().valid(); } + int32_t order() const { return at<2>().as_int32(); } + bool has_classzone_idx() const { return at<3>().valid(); } + uint32_t classzone_idx() const { return at<3>().as_uint32(); } + bool has_highest_zoneidx() const { return at<4>().valid(); } + uint32_t highest_zoneidx() const { return at<4>().as_uint32(); } +}; + +class MmCompactionWakeupKcompactdFtraceEvent : public ::protozero::Message { + public: + using Decoder = MmCompactionWakeupKcompactdFtraceEvent_Decoder; + enum : int32_t { + kNidFieldNumber = 1, + kOrderFieldNumber = 2, + kClasszoneIdxFieldNumber = 3, + kHighestZoneidxFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MmCompactionWakeupKcompactdFtraceEvent"; } + + + using FieldMetadata_Nid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MmCompactionWakeupKcompactdFtraceEvent>; + + static constexpr FieldMetadata_Nid kNid{}; + void set_nid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Nid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Order = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MmCompactionWakeupKcompactdFtraceEvent>; + + static constexpr FieldMetadata_Order kOrder{}; + void set_order(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Order::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ClasszoneIdx = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MmCompactionWakeupKcompactdFtraceEvent>; + + static constexpr FieldMetadata_ClasszoneIdx kClasszoneIdx{}; + void set_classzone_idx(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ClasszoneIdx::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_HighestZoneidx = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MmCompactionWakeupKcompactdFtraceEvent>; + + static constexpr FieldMetadata_HighestZoneidx kHighestZoneidx{}; + void set_highest_zoneidx(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_HighestZoneidx::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class MmCompactionTryToCompactPagesFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + MmCompactionTryToCompactPagesFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MmCompactionTryToCompactPagesFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MmCompactionTryToCompactPagesFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_order() const { return at<1>().valid(); } + int32_t order() const { return at<1>().as_int32(); } + bool has_gfp_mask() const { return at<2>().valid(); } + uint32_t gfp_mask() const { return at<2>().as_uint32(); } + bool has_mode() const { return at<3>().valid(); } + uint32_t mode() const { return at<3>().as_uint32(); } + bool has_prio() const { return at<4>().valid(); } + int32_t prio() const { return at<4>().as_int32(); } +}; + +class MmCompactionTryToCompactPagesFtraceEvent : public ::protozero::Message { + public: + using Decoder = MmCompactionTryToCompactPagesFtraceEvent_Decoder; + enum : int32_t { + kOrderFieldNumber = 1, + kGfpMaskFieldNumber = 2, + kModeFieldNumber = 3, + kPrioFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MmCompactionTryToCompactPagesFtraceEvent"; } + + + using FieldMetadata_Order = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MmCompactionTryToCompactPagesFtraceEvent>; + + static constexpr FieldMetadata_Order kOrder{}; + void set_order(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Order::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_GfpMask = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MmCompactionTryToCompactPagesFtraceEvent>; + + static constexpr FieldMetadata_GfpMask kGfpMask{}; + void set_gfp_mask(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_GfpMask::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Mode = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MmCompactionTryToCompactPagesFtraceEvent>; + + static constexpr FieldMetadata_Mode kMode{}; + void set_mode(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Mode::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Prio = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MmCompactionTryToCompactPagesFtraceEvent>; + + static constexpr FieldMetadata_Prio kPrio{}; + void set_prio(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Prio::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class MmCompactionSuitableFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + MmCompactionSuitableFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MmCompactionSuitableFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MmCompactionSuitableFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_nid() const { return at<1>().valid(); } + int32_t nid() const { return at<1>().as_int32(); } + bool has_idx() const { return at<2>().valid(); } + uint32_t idx() const { return at<2>().as_uint32(); } + bool has_order() const { return at<3>().valid(); } + int32_t order() const { return at<3>().as_int32(); } + bool has_ret() const { return at<4>().valid(); } + int32_t ret() const { return at<4>().as_int32(); } +}; + +class MmCompactionSuitableFtraceEvent : public ::protozero::Message { + public: + using Decoder = MmCompactionSuitableFtraceEvent_Decoder; + enum : int32_t { + kNidFieldNumber = 1, + kIdxFieldNumber = 2, + kOrderFieldNumber = 3, + kRetFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MmCompactionSuitableFtraceEvent"; } + + + using FieldMetadata_Nid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MmCompactionSuitableFtraceEvent>; + + static constexpr FieldMetadata_Nid kNid{}; + void set_nid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Nid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Idx = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MmCompactionSuitableFtraceEvent>; + + static constexpr FieldMetadata_Idx kIdx{}; + void set_idx(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Idx::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Order = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MmCompactionSuitableFtraceEvent>; + + static constexpr FieldMetadata_Order kOrder{}; + void set_order(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Order::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ret = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MmCompactionSuitableFtraceEvent>; + + static constexpr FieldMetadata_Ret kRet{}; + void set_ret(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class MmCompactionMigratepagesFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + MmCompactionMigratepagesFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MmCompactionMigratepagesFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MmCompactionMigratepagesFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_nr_migrated() const { return at<1>().valid(); } + uint64_t nr_migrated() const { return at<1>().as_uint64(); } + bool has_nr_failed() const { return at<2>().valid(); } + uint64_t nr_failed() const { return at<2>().as_uint64(); } +}; + +class MmCompactionMigratepagesFtraceEvent : public ::protozero::Message { + public: + using Decoder = MmCompactionMigratepagesFtraceEvent_Decoder; + enum : int32_t { + kNrMigratedFieldNumber = 1, + kNrFailedFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MmCompactionMigratepagesFtraceEvent"; } + + + using FieldMetadata_NrMigrated = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MmCompactionMigratepagesFtraceEvent>; + + static constexpr FieldMetadata_NrMigrated kNrMigrated{}; + void set_nr_migrated(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_NrMigrated::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NrFailed = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MmCompactionMigratepagesFtraceEvent>; + + static constexpr FieldMetadata_NrFailed kNrFailed{}; + void set_nr_failed(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_NrFailed::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class MmCompactionKcompactdWakeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + MmCompactionKcompactdWakeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MmCompactionKcompactdWakeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MmCompactionKcompactdWakeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_nid() const { return at<1>().valid(); } + int32_t nid() const { return at<1>().as_int32(); } + bool has_order() const { return at<2>().valid(); } + int32_t order() const { return at<2>().as_int32(); } + bool has_classzone_idx() const { return at<3>().valid(); } + uint32_t classzone_idx() const { return at<3>().as_uint32(); } + bool has_highest_zoneidx() const { return at<4>().valid(); } + uint32_t highest_zoneidx() const { return at<4>().as_uint32(); } +}; + +class MmCompactionKcompactdWakeFtraceEvent : public ::protozero::Message { + public: + using Decoder = MmCompactionKcompactdWakeFtraceEvent_Decoder; + enum : int32_t { + kNidFieldNumber = 1, + kOrderFieldNumber = 2, + kClasszoneIdxFieldNumber = 3, + kHighestZoneidxFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MmCompactionKcompactdWakeFtraceEvent"; } + + + using FieldMetadata_Nid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MmCompactionKcompactdWakeFtraceEvent>; + + static constexpr FieldMetadata_Nid kNid{}; + void set_nid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Nid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Order = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MmCompactionKcompactdWakeFtraceEvent>; + + static constexpr FieldMetadata_Order kOrder{}; + void set_order(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Order::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ClasszoneIdx = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MmCompactionKcompactdWakeFtraceEvent>; + + static constexpr FieldMetadata_ClasszoneIdx kClasszoneIdx{}; + void set_classzone_idx(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ClasszoneIdx::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_HighestZoneidx = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MmCompactionKcompactdWakeFtraceEvent>; + + static constexpr FieldMetadata_HighestZoneidx kHighestZoneidx{}; + void set_highest_zoneidx(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_HighestZoneidx::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class MmCompactionKcompactdSleepFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + MmCompactionKcompactdSleepFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MmCompactionKcompactdSleepFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MmCompactionKcompactdSleepFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_nid() const { return at<1>().valid(); } + int32_t nid() const { return at<1>().as_int32(); } +}; + +class MmCompactionKcompactdSleepFtraceEvent : public ::protozero::Message { + public: + using Decoder = MmCompactionKcompactdSleepFtraceEvent_Decoder; + enum : int32_t { + kNidFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MmCompactionKcompactdSleepFtraceEvent"; } + + + using FieldMetadata_Nid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MmCompactionKcompactdSleepFtraceEvent>; + + static constexpr FieldMetadata_Nid kNid{}; + void set_nid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Nid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class MmCompactionIsolateMigratepagesFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + MmCompactionIsolateMigratepagesFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MmCompactionIsolateMigratepagesFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MmCompactionIsolateMigratepagesFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_start_pfn() const { return at<1>().valid(); } + uint64_t start_pfn() const { return at<1>().as_uint64(); } + bool has_end_pfn() const { return at<2>().valid(); } + uint64_t end_pfn() const { return at<2>().as_uint64(); } + bool has_nr_scanned() const { return at<3>().valid(); } + uint64_t nr_scanned() const { return at<3>().as_uint64(); } + bool has_nr_taken() const { return at<4>().valid(); } + uint64_t nr_taken() const { return at<4>().as_uint64(); } +}; + +class MmCompactionIsolateMigratepagesFtraceEvent : public ::protozero::Message { + public: + using Decoder = MmCompactionIsolateMigratepagesFtraceEvent_Decoder; + enum : int32_t { + kStartPfnFieldNumber = 1, + kEndPfnFieldNumber = 2, + kNrScannedFieldNumber = 3, + kNrTakenFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MmCompactionIsolateMigratepagesFtraceEvent"; } + + + using FieldMetadata_StartPfn = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MmCompactionIsolateMigratepagesFtraceEvent>; + + static constexpr FieldMetadata_StartPfn kStartPfn{}; + void set_start_pfn(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_StartPfn::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_EndPfn = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MmCompactionIsolateMigratepagesFtraceEvent>; + + static constexpr FieldMetadata_EndPfn kEndPfn{}; + void set_end_pfn(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_EndPfn::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NrScanned = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MmCompactionIsolateMigratepagesFtraceEvent>; + + static constexpr FieldMetadata_NrScanned kNrScanned{}; + void set_nr_scanned(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_NrScanned::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NrTaken = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MmCompactionIsolateMigratepagesFtraceEvent>; + + static constexpr FieldMetadata_NrTaken kNrTaken{}; + void set_nr_taken(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_NrTaken::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class MmCompactionIsolateFreepagesFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + MmCompactionIsolateFreepagesFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MmCompactionIsolateFreepagesFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MmCompactionIsolateFreepagesFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_start_pfn() const { return at<1>().valid(); } + uint64_t start_pfn() const { return at<1>().as_uint64(); } + bool has_end_pfn() const { return at<2>().valid(); } + uint64_t end_pfn() const { return at<2>().as_uint64(); } + bool has_nr_scanned() const { return at<3>().valid(); } + uint64_t nr_scanned() const { return at<3>().as_uint64(); } + bool has_nr_taken() const { return at<4>().valid(); } + uint64_t nr_taken() const { return at<4>().as_uint64(); } +}; + +class MmCompactionIsolateFreepagesFtraceEvent : public ::protozero::Message { + public: + using Decoder = MmCompactionIsolateFreepagesFtraceEvent_Decoder; + enum : int32_t { + kStartPfnFieldNumber = 1, + kEndPfnFieldNumber = 2, + kNrScannedFieldNumber = 3, + kNrTakenFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MmCompactionIsolateFreepagesFtraceEvent"; } + + + using FieldMetadata_StartPfn = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MmCompactionIsolateFreepagesFtraceEvent>; + + static constexpr FieldMetadata_StartPfn kStartPfn{}; + void set_start_pfn(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_StartPfn::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_EndPfn = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MmCompactionIsolateFreepagesFtraceEvent>; + + static constexpr FieldMetadata_EndPfn kEndPfn{}; + void set_end_pfn(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_EndPfn::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NrScanned = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MmCompactionIsolateFreepagesFtraceEvent>; + + static constexpr FieldMetadata_NrScanned kNrScanned{}; + void set_nr_scanned(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_NrScanned::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NrTaken = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MmCompactionIsolateFreepagesFtraceEvent>; + + static constexpr FieldMetadata_NrTaken kNrTaken{}; + void set_nr_taken(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_NrTaken::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class MmCompactionFinishedFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + MmCompactionFinishedFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MmCompactionFinishedFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MmCompactionFinishedFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_nid() const { return at<1>().valid(); } + int32_t nid() const { return at<1>().as_int32(); } + bool has_idx() const { return at<2>().valid(); } + uint32_t idx() const { return at<2>().as_uint32(); } + bool has_order() const { return at<3>().valid(); } + int32_t order() const { return at<3>().as_int32(); } + bool has_ret() const { return at<4>().valid(); } + int32_t ret() const { return at<4>().as_int32(); } +}; + +class MmCompactionFinishedFtraceEvent : public ::protozero::Message { + public: + using Decoder = MmCompactionFinishedFtraceEvent_Decoder; + enum : int32_t { + kNidFieldNumber = 1, + kIdxFieldNumber = 2, + kOrderFieldNumber = 3, + kRetFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MmCompactionFinishedFtraceEvent"; } + + + using FieldMetadata_Nid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MmCompactionFinishedFtraceEvent>; + + static constexpr FieldMetadata_Nid kNid{}; + void set_nid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Nid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Idx = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MmCompactionFinishedFtraceEvent>; + + static constexpr FieldMetadata_Idx kIdx{}; + void set_idx(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Idx::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Order = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MmCompactionFinishedFtraceEvent>; + + static constexpr FieldMetadata_Order kOrder{}; + void set_order(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Order::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ret = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MmCompactionFinishedFtraceEvent>; + + static constexpr FieldMetadata_Ret kRet{}; + void set_ret(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ret::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class MmCompactionEndFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + MmCompactionEndFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MmCompactionEndFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MmCompactionEndFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_zone_start() const { return at<1>().valid(); } + uint64_t zone_start() const { return at<1>().as_uint64(); } + bool has_migrate_pfn() const { return at<2>().valid(); } + uint64_t migrate_pfn() const { return at<2>().as_uint64(); } + bool has_free_pfn() const { return at<3>().valid(); } + uint64_t free_pfn() const { return at<3>().as_uint64(); } + bool has_zone_end() const { return at<4>().valid(); } + uint64_t zone_end() const { return at<4>().as_uint64(); } + bool has_sync() const { return at<5>().valid(); } + uint32_t sync() const { return at<5>().as_uint32(); } + bool has_status() const { return at<6>().valid(); } + int32_t status() const { return at<6>().as_int32(); } +}; + +class MmCompactionEndFtraceEvent : public ::protozero::Message { + public: + using Decoder = MmCompactionEndFtraceEvent_Decoder; + enum : int32_t { + kZoneStartFieldNumber = 1, + kMigratePfnFieldNumber = 2, + kFreePfnFieldNumber = 3, + kZoneEndFieldNumber = 4, + kSyncFieldNumber = 5, + kStatusFieldNumber = 6, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MmCompactionEndFtraceEvent"; } + + + using FieldMetadata_ZoneStart = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MmCompactionEndFtraceEvent>; + + static constexpr FieldMetadata_ZoneStart kZoneStart{}; + void set_zone_start(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_ZoneStart::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_MigratePfn = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MmCompactionEndFtraceEvent>; + + static constexpr FieldMetadata_MigratePfn kMigratePfn{}; + void set_migrate_pfn(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_MigratePfn::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FreePfn = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MmCompactionEndFtraceEvent>; + + static constexpr FieldMetadata_FreePfn kFreePfn{}; + void set_free_pfn(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_FreePfn::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ZoneEnd = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MmCompactionEndFtraceEvent>; + + static constexpr FieldMetadata_ZoneEnd kZoneEnd{}; + void set_zone_end(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_ZoneEnd::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Sync = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MmCompactionEndFtraceEvent>; + + static constexpr FieldMetadata_Sync kSync{}; + void set_sync(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Sync::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Status = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MmCompactionEndFtraceEvent>; + + static constexpr FieldMetadata_Status kStatus{}; + void set_status(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Status::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class MmCompactionDeferResetFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + MmCompactionDeferResetFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MmCompactionDeferResetFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MmCompactionDeferResetFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_nid() const { return at<1>().valid(); } + int32_t nid() const { return at<1>().as_int32(); } + bool has_idx() const { return at<2>().valid(); } + uint32_t idx() const { return at<2>().as_uint32(); } + bool has_order() const { return at<3>().valid(); } + int32_t order() const { return at<3>().as_int32(); } + bool has_considered() const { return at<4>().valid(); } + uint32_t considered() const { return at<4>().as_uint32(); } + bool has_defer_shift() const { return at<5>().valid(); } + uint32_t defer_shift() const { return at<5>().as_uint32(); } + bool has_order_failed() const { return at<6>().valid(); } + int32_t order_failed() const { return at<6>().as_int32(); } +}; + +class MmCompactionDeferResetFtraceEvent : public ::protozero::Message { + public: + using Decoder = MmCompactionDeferResetFtraceEvent_Decoder; + enum : int32_t { + kNidFieldNumber = 1, + kIdxFieldNumber = 2, + kOrderFieldNumber = 3, + kConsideredFieldNumber = 4, + kDeferShiftFieldNumber = 5, + kOrderFailedFieldNumber = 6, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MmCompactionDeferResetFtraceEvent"; } + + + using FieldMetadata_Nid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MmCompactionDeferResetFtraceEvent>; + + static constexpr FieldMetadata_Nid kNid{}; + void set_nid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Nid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Idx = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MmCompactionDeferResetFtraceEvent>; + + static constexpr FieldMetadata_Idx kIdx{}; + void set_idx(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Idx::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Order = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MmCompactionDeferResetFtraceEvent>; + + static constexpr FieldMetadata_Order kOrder{}; + void set_order(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Order::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Considered = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MmCompactionDeferResetFtraceEvent>; + + static constexpr FieldMetadata_Considered kConsidered{}; + void set_considered(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Considered::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DeferShift = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MmCompactionDeferResetFtraceEvent>; + + static constexpr FieldMetadata_DeferShift kDeferShift{}; + void set_defer_shift(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_DeferShift::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_OrderFailed = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MmCompactionDeferResetFtraceEvent>; + + static constexpr FieldMetadata_OrderFailed kOrderFailed{}; + void set_order_failed(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_OrderFailed::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class MmCompactionDeferredFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + MmCompactionDeferredFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MmCompactionDeferredFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MmCompactionDeferredFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_nid() const { return at<1>().valid(); } + int32_t nid() const { return at<1>().as_int32(); } + bool has_idx() const { return at<2>().valid(); } + uint32_t idx() const { return at<2>().as_uint32(); } + bool has_order() const { return at<3>().valid(); } + int32_t order() const { return at<3>().as_int32(); } + bool has_considered() const { return at<4>().valid(); } + uint32_t considered() const { return at<4>().as_uint32(); } + bool has_defer_shift() const { return at<5>().valid(); } + uint32_t defer_shift() const { return at<5>().as_uint32(); } + bool has_order_failed() const { return at<6>().valid(); } + int32_t order_failed() const { return at<6>().as_int32(); } +}; + +class MmCompactionDeferredFtraceEvent : public ::protozero::Message { + public: + using Decoder = MmCompactionDeferredFtraceEvent_Decoder; + enum : int32_t { + kNidFieldNumber = 1, + kIdxFieldNumber = 2, + kOrderFieldNumber = 3, + kConsideredFieldNumber = 4, + kDeferShiftFieldNumber = 5, + kOrderFailedFieldNumber = 6, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MmCompactionDeferredFtraceEvent"; } + + + using FieldMetadata_Nid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MmCompactionDeferredFtraceEvent>; + + static constexpr FieldMetadata_Nid kNid{}; + void set_nid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Nid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Idx = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MmCompactionDeferredFtraceEvent>; + + static constexpr FieldMetadata_Idx kIdx{}; + void set_idx(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Idx::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Order = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MmCompactionDeferredFtraceEvent>; + + static constexpr FieldMetadata_Order kOrder{}; + void set_order(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Order::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Considered = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MmCompactionDeferredFtraceEvent>; + + static constexpr FieldMetadata_Considered kConsidered{}; + void set_considered(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Considered::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DeferShift = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MmCompactionDeferredFtraceEvent>; + + static constexpr FieldMetadata_DeferShift kDeferShift{}; + void set_defer_shift(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_DeferShift::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_OrderFailed = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MmCompactionDeferredFtraceEvent>; + + static constexpr FieldMetadata_OrderFailed kOrderFailed{}; + void set_order_failed(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_OrderFailed::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class MmCompactionDeferCompactionFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + MmCompactionDeferCompactionFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MmCompactionDeferCompactionFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MmCompactionDeferCompactionFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_nid() const { return at<1>().valid(); } + int32_t nid() const { return at<1>().as_int32(); } + bool has_idx() const { return at<2>().valid(); } + uint32_t idx() const { return at<2>().as_uint32(); } + bool has_order() const { return at<3>().valid(); } + int32_t order() const { return at<3>().as_int32(); } + bool has_considered() const { return at<4>().valid(); } + uint32_t considered() const { return at<4>().as_uint32(); } + bool has_defer_shift() const { return at<5>().valid(); } + uint32_t defer_shift() const { return at<5>().as_uint32(); } + bool has_order_failed() const { return at<6>().valid(); } + int32_t order_failed() const { return at<6>().as_int32(); } +}; + +class MmCompactionDeferCompactionFtraceEvent : public ::protozero::Message { + public: + using Decoder = MmCompactionDeferCompactionFtraceEvent_Decoder; + enum : int32_t { + kNidFieldNumber = 1, + kIdxFieldNumber = 2, + kOrderFieldNumber = 3, + kConsideredFieldNumber = 4, + kDeferShiftFieldNumber = 5, + kOrderFailedFieldNumber = 6, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MmCompactionDeferCompactionFtraceEvent"; } + + + using FieldMetadata_Nid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MmCompactionDeferCompactionFtraceEvent>; + + static constexpr FieldMetadata_Nid kNid{}; + void set_nid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Nid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Idx = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MmCompactionDeferCompactionFtraceEvent>; + + static constexpr FieldMetadata_Idx kIdx{}; + void set_idx(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Idx::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Order = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MmCompactionDeferCompactionFtraceEvent>; + + static constexpr FieldMetadata_Order kOrder{}; + void set_order(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Order::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Considered = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MmCompactionDeferCompactionFtraceEvent>; + + static constexpr FieldMetadata_Considered kConsidered{}; + void set_considered(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Considered::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DeferShift = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MmCompactionDeferCompactionFtraceEvent>; + + static constexpr FieldMetadata_DeferShift kDeferShift{}; + void set_defer_shift(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_DeferShift::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_OrderFailed = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MmCompactionDeferCompactionFtraceEvent>; + + static constexpr FieldMetadata_OrderFailed kOrderFailed{}; + void set_order_failed(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_OrderFailed::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class MmCompactionBeginFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + MmCompactionBeginFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MmCompactionBeginFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MmCompactionBeginFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_zone_start() const { return at<1>().valid(); } + uint64_t zone_start() const { return at<1>().as_uint64(); } + bool has_migrate_pfn() const { return at<2>().valid(); } + uint64_t migrate_pfn() const { return at<2>().as_uint64(); } + bool has_free_pfn() const { return at<3>().valid(); } + uint64_t free_pfn() const { return at<3>().as_uint64(); } + bool has_zone_end() const { return at<4>().valid(); } + uint64_t zone_end() const { return at<4>().as_uint64(); } + bool has_sync() const { return at<5>().valid(); } + uint32_t sync() const { return at<5>().as_uint32(); } +}; + +class MmCompactionBeginFtraceEvent : public ::protozero::Message { + public: + using Decoder = MmCompactionBeginFtraceEvent_Decoder; + enum : int32_t { + kZoneStartFieldNumber = 1, + kMigratePfnFieldNumber = 2, + kFreePfnFieldNumber = 3, + kZoneEndFieldNumber = 4, + kSyncFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MmCompactionBeginFtraceEvent"; } + + + using FieldMetadata_ZoneStart = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MmCompactionBeginFtraceEvent>; + + static constexpr FieldMetadata_ZoneStart kZoneStart{}; + void set_zone_start(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_ZoneStart::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_MigratePfn = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MmCompactionBeginFtraceEvent>; + + static constexpr FieldMetadata_MigratePfn kMigratePfn{}; + void set_migrate_pfn(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_MigratePfn::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FreePfn = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MmCompactionBeginFtraceEvent>; + + static constexpr FieldMetadata_FreePfn kFreePfn{}; + void set_free_pfn(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_FreePfn::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ZoneEnd = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MmCompactionBeginFtraceEvent>; + + static constexpr FieldMetadata_ZoneEnd kZoneEnd{}; + void set_zone_end(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_ZoneEnd::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Sync = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MmCompactionBeginFtraceEvent>; + + static constexpr FieldMetadata_Sync kSync{}; + void set_sync(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Sync::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class CmaAllocInfoFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + CmaAllocInfoFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit CmaAllocInfoFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit CmaAllocInfoFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_align() const { return at<1>().valid(); } + uint32_t align() const { return at<1>().as_uint32(); } + bool has_count() const { return at<2>().valid(); } + uint32_t count() const { return at<2>().as_uint32(); } + bool has_err_iso() const { return at<3>().valid(); } + uint32_t err_iso() const { return at<3>().as_uint32(); } + bool has_err_mig() const { return at<4>().valid(); } + uint32_t err_mig() const { return at<4>().as_uint32(); } + bool has_err_test() const { return at<5>().valid(); } + uint32_t err_test() const { return at<5>().as_uint32(); } + bool has_name() const { return at<6>().valid(); } + ::protozero::ConstChars name() const { return at<6>().as_string(); } + bool has_nr_mapped() const { return at<7>().valid(); } + uint64_t nr_mapped() const { return at<7>().as_uint64(); } + bool has_nr_migrated() const { return at<8>().valid(); } + uint64_t nr_migrated() const { return at<8>().as_uint64(); } + bool has_nr_reclaimed() const { return at<9>().valid(); } + uint64_t nr_reclaimed() const { return at<9>().as_uint64(); } + bool has_pfn() const { return at<10>().valid(); } + uint64_t pfn() const { return at<10>().as_uint64(); } +}; + +class CmaAllocInfoFtraceEvent : public ::protozero::Message { + public: + using Decoder = CmaAllocInfoFtraceEvent_Decoder; + enum : int32_t { + kAlignFieldNumber = 1, + kCountFieldNumber = 2, + kErrIsoFieldNumber = 3, + kErrMigFieldNumber = 4, + kErrTestFieldNumber = 5, + kNameFieldNumber = 6, + kNrMappedFieldNumber = 7, + kNrMigratedFieldNumber = 8, + kNrReclaimedFieldNumber = 9, + kPfnFieldNumber = 10, + }; + static constexpr const char* GetName() { return ".perfetto.protos.CmaAllocInfoFtraceEvent"; } + + + using FieldMetadata_Align = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + CmaAllocInfoFtraceEvent>; + + static constexpr FieldMetadata_Align kAlign{}; + void set_align(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Align::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Count = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + CmaAllocInfoFtraceEvent>; + + static constexpr FieldMetadata_Count kCount{}; + void set_count(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Count::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ErrIso = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + CmaAllocInfoFtraceEvent>; + + static constexpr FieldMetadata_ErrIso kErrIso{}; + void set_err_iso(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ErrIso::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ErrMig = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + CmaAllocInfoFtraceEvent>; + + static constexpr FieldMetadata_ErrMig kErrMig{}; + void set_err_mig(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ErrMig::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ErrTest = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + CmaAllocInfoFtraceEvent>; + + static constexpr FieldMetadata_ErrTest kErrTest{}; + void set_err_test(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ErrTest::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + CmaAllocInfoFtraceEvent>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NrMapped = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + CmaAllocInfoFtraceEvent>; + + static constexpr FieldMetadata_NrMapped kNrMapped{}; + void set_nr_mapped(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_NrMapped::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NrMigrated = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + CmaAllocInfoFtraceEvent>; + + static constexpr FieldMetadata_NrMigrated kNrMigrated{}; + void set_nr_migrated(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_NrMigrated::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NrReclaimed = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + CmaAllocInfoFtraceEvent>; + + static constexpr FieldMetadata_NrReclaimed kNrReclaimed{}; + void set_nr_reclaimed(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_NrReclaimed::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pfn = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + CmaAllocInfoFtraceEvent>; + + static constexpr FieldMetadata_Pfn kPfn{}; + void set_pfn(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pfn::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class CmaAllocStartFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + CmaAllocStartFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit CmaAllocStartFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit CmaAllocStartFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_align() const { return at<1>().valid(); } + uint32_t align() const { return at<1>().as_uint32(); } + bool has_count() const { return at<2>().valid(); } + uint32_t count() const { return at<2>().as_uint32(); } + bool has_name() const { return at<3>().valid(); } + ::protozero::ConstChars name() const { return at<3>().as_string(); } +}; + +class CmaAllocStartFtraceEvent : public ::protozero::Message { + public: + using Decoder = CmaAllocStartFtraceEvent_Decoder; + enum : int32_t { + kAlignFieldNumber = 1, + kCountFieldNumber = 2, + kNameFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.CmaAllocStartFtraceEvent"; } + + + using FieldMetadata_Align = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + CmaAllocStartFtraceEvent>; + + static constexpr FieldMetadata_Align kAlign{}; + void set_align(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Align::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Count = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + CmaAllocStartFtraceEvent>; + + static constexpr FieldMetadata_Count kCount{}; + void set_count(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Count::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + CmaAllocStartFtraceEvent>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class ClkSetRateFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + ClkSetRateFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ClkSetRateFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ClkSetRateFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_name() const { return at<1>().valid(); } + ::protozero::ConstChars name() const { return at<1>().as_string(); } + bool has_rate() const { return at<2>().valid(); } + uint64_t rate() const { return at<2>().as_uint64(); } +}; + +class ClkSetRateFtraceEvent : public ::protozero::Message { + public: + using Decoder = ClkSetRateFtraceEvent_Decoder; + enum : int32_t { + kNameFieldNumber = 1, + kRateFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ClkSetRateFtraceEvent"; } + + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + ClkSetRateFtraceEvent>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Rate = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + ClkSetRateFtraceEvent>; + + static constexpr FieldMetadata_Rate kRate{}; + void set_rate(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Rate::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class ClkDisableFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + ClkDisableFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ClkDisableFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ClkDisableFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_name() const { return at<1>().valid(); } + ::protozero::ConstChars name() const { return at<1>().as_string(); } +}; + +class ClkDisableFtraceEvent : public ::protozero::Message { + public: + using Decoder = ClkDisableFtraceEvent_Decoder; + enum : int32_t { + kNameFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ClkDisableFtraceEvent"; } + + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + ClkDisableFtraceEvent>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class ClkEnableFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + ClkEnableFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ClkEnableFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ClkEnableFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_name() const { return at<1>().valid(); } + ::protozero::ConstChars name() const { return at<1>().as_string(); } +}; + +class ClkEnableFtraceEvent : public ::protozero::Message { + public: + using Decoder = ClkEnableFtraceEvent_Decoder; + enum : int32_t { + kNameFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ClkEnableFtraceEvent"; } + + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + ClkEnableFtraceEvent>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class CgroupSetupRootFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + CgroupSetupRootFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit CgroupSetupRootFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit CgroupSetupRootFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_root() const { return at<1>().valid(); } + int32_t root() const { return at<1>().as_int32(); } + bool has_ss_mask() const { return at<2>().valid(); } + uint32_t ss_mask() const { return at<2>().as_uint32(); } + bool has_name() const { return at<3>().valid(); } + ::protozero::ConstChars name() const { return at<3>().as_string(); } +}; + +class CgroupSetupRootFtraceEvent : public ::protozero::Message { + public: + using Decoder = CgroupSetupRootFtraceEvent_Decoder; + enum : int32_t { + kRootFieldNumber = 1, + kSsMaskFieldNumber = 2, + kNameFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.CgroupSetupRootFtraceEvent"; } + + + using FieldMetadata_Root = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + CgroupSetupRootFtraceEvent>; + + static constexpr FieldMetadata_Root kRoot{}; + void set_root(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Root::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SsMask = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + CgroupSetupRootFtraceEvent>; + + static constexpr FieldMetadata_SsMask kSsMask{}; + void set_ss_mask(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_SsMask::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + CgroupSetupRootFtraceEvent>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class CgroupRenameFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + CgroupRenameFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit CgroupRenameFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit CgroupRenameFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_root() const { return at<1>().valid(); } + int32_t root() const { return at<1>().as_int32(); } + bool has_id() const { return at<2>().valid(); } + int32_t id() const { return at<2>().as_int32(); } + bool has_cname() const { return at<3>().valid(); } + ::protozero::ConstChars cname() const { return at<3>().as_string(); } + bool has_level() const { return at<4>().valid(); } + int32_t level() const { return at<4>().as_int32(); } + bool has_path() const { return at<5>().valid(); } + ::protozero::ConstChars path() const { return at<5>().as_string(); } +}; + +class CgroupRenameFtraceEvent : public ::protozero::Message { + public: + using Decoder = CgroupRenameFtraceEvent_Decoder; + enum : int32_t { + kRootFieldNumber = 1, + kIdFieldNumber = 2, + kCnameFieldNumber = 3, + kLevelFieldNumber = 4, + kPathFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.CgroupRenameFtraceEvent"; } + + + using FieldMetadata_Root = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + CgroupRenameFtraceEvent>; + + static constexpr FieldMetadata_Root kRoot{}; + void set_root(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Root::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Id = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + CgroupRenameFtraceEvent>; + + static constexpr FieldMetadata_Id kId{}; + void set_id(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Cname = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + CgroupRenameFtraceEvent>; + + static constexpr FieldMetadata_Cname kCname{}; + void set_cname(const char* data, size_t size) { + AppendBytes(FieldMetadata_Cname::kFieldId, data, size); + } + void set_cname(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Cname::kFieldId, chars.data, chars.size); + } + void set_cname(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Cname::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Level = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + CgroupRenameFtraceEvent>; + + static constexpr FieldMetadata_Level kLevel{}; + void set_level(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Level::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Path = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + CgroupRenameFtraceEvent>; + + static constexpr FieldMetadata_Path kPath{}; + void set_path(const char* data, size_t size) { + AppendBytes(FieldMetadata_Path::kFieldId, data, size); + } + void set_path(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Path::kFieldId, chars.data, chars.size); + } + void set_path(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Path::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class CgroupReleaseFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + CgroupReleaseFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit CgroupReleaseFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit CgroupReleaseFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_root() const { return at<1>().valid(); } + int32_t root() const { return at<1>().as_int32(); } + bool has_id() const { return at<2>().valid(); } + int32_t id() const { return at<2>().as_int32(); } + bool has_cname() const { return at<3>().valid(); } + ::protozero::ConstChars cname() const { return at<3>().as_string(); } + bool has_level() const { return at<4>().valid(); } + int32_t level() const { return at<4>().as_int32(); } + bool has_path() const { return at<5>().valid(); } + ::protozero::ConstChars path() const { return at<5>().as_string(); } +}; + +class CgroupReleaseFtraceEvent : public ::protozero::Message { + public: + using Decoder = CgroupReleaseFtraceEvent_Decoder; + enum : int32_t { + kRootFieldNumber = 1, + kIdFieldNumber = 2, + kCnameFieldNumber = 3, + kLevelFieldNumber = 4, + kPathFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.CgroupReleaseFtraceEvent"; } + + + using FieldMetadata_Root = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + CgroupReleaseFtraceEvent>; + + static constexpr FieldMetadata_Root kRoot{}; + void set_root(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Root::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Id = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + CgroupReleaseFtraceEvent>; + + static constexpr FieldMetadata_Id kId{}; + void set_id(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Cname = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + CgroupReleaseFtraceEvent>; + + static constexpr FieldMetadata_Cname kCname{}; + void set_cname(const char* data, size_t size) { + AppendBytes(FieldMetadata_Cname::kFieldId, data, size); + } + void set_cname(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Cname::kFieldId, chars.data, chars.size); + } + void set_cname(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Cname::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Level = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + CgroupReleaseFtraceEvent>; + + static constexpr FieldMetadata_Level kLevel{}; + void set_level(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Level::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Path = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + CgroupReleaseFtraceEvent>; + + static constexpr FieldMetadata_Path kPath{}; + void set_path(const char* data, size_t size) { + AppendBytes(FieldMetadata_Path::kFieldId, data, size); + } + void set_path(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Path::kFieldId, chars.data, chars.size); + } + void set_path(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Path::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class CgroupDestroyRootFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + CgroupDestroyRootFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit CgroupDestroyRootFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit CgroupDestroyRootFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_root() const { return at<1>().valid(); } + int32_t root() const { return at<1>().as_int32(); } + bool has_ss_mask() const { return at<2>().valid(); } + uint32_t ss_mask() const { return at<2>().as_uint32(); } + bool has_name() const { return at<3>().valid(); } + ::protozero::ConstChars name() const { return at<3>().as_string(); } +}; + +class CgroupDestroyRootFtraceEvent : public ::protozero::Message { + public: + using Decoder = CgroupDestroyRootFtraceEvent_Decoder; + enum : int32_t { + kRootFieldNumber = 1, + kSsMaskFieldNumber = 2, + kNameFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.CgroupDestroyRootFtraceEvent"; } + + + using FieldMetadata_Root = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + CgroupDestroyRootFtraceEvent>; + + static constexpr FieldMetadata_Root kRoot{}; + void set_root(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Root::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SsMask = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + CgroupDestroyRootFtraceEvent>; + + static constexpr FieldMetadata_SsMask kSsMask{}; + void set_ss_mask(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_SsMask::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + CgroupDestroyRootFtraceEvent>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class CgroupTransferTasksFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + CgroupTransferTasksFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit CgroupTransferTasksFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit CgroupTransferTasksFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dst_root() const { return at<1>().valid(); } + int32_t dst_root() const { return at<1>().as_int32(); } + bool has_dst_id() const { return at<2>().valid(); } + int32_t dst_id() const { return at<2>().as_int32(); } + bool has_pid() const { return at<3>().valid(); } + int32_t pid() const { return at<3>().as_int32(); } + bool has_comm() const { return at<4>().valid(); } + ::protozero::ConstChars comm() const { return at<4>().as_string(); } + bool has_cname() const { return at<5>().valid(); } + ::protozero::ConstChars cname() const { return at<5>().as_string(); } + bool has_dst_level() const { return at<6>().valid(); } + int32_t dst_level() const { return at<6>().as_int32(); } + bool has_dst_path() const { return at<7>().valid(); } + ::protozero::ConstChars dst_path() const { return at<7>().as_string(); } +}; + +class CgroupTransferTasksFtraceEvent : public ::protozero::Message { + public: + using Decoder = CgroupTransferTasksFtraceEvent_Decoder; + enum : int32_t { + kDstRootFieldNumber = 1, + kDstIdFieldNumber = 2, + kPidFieldNumber = 3, + kCommFieldNumber = 4, + kCnameFieldNumber = 5, + kDstLevelFieldNumber = 6, + kDstPathFieldNumber = 7, + }; + static constexpr const char* GetName() { return ".perfetto.protos.CgroupTransferTasksFtraceEvent"; } + + + using FieldMetadata_DstRoot = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + CgroupTransferTasksFtraceEvent>; + + static constexpr FieldMetadata_DstRoot kDstRoot{}; + void set_dst_root(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_DstRoot::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DstId = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + CgroupTransferTasksFtraceEvent>; + + static constexpr FieldMetadata_DstId kDstId{}; + void set_dst_id(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_DstId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pid = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + CgroupTransferTasksFtraceEvent>; + + static constexpr FieldMetadata_Pid kPid{}; + void set_pid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Comm = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + CgroupTransferTasksFtraceEvent>; + + static constexpr FieldMetadata_Comm kComm{}; + void set_comm(const char* data, size_t size) { + AppendBytes(FieldMetadata_Comm::kFieldId, data, size); + } + void set_comm(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Comm::kFieldId, chars.data, chars.size); + } + void set_comm(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Comm::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Cname = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + CgroupTransferTasksFtraceEvent>; + + static constexpr FieldMetadata_Cname kCname{}; + void set_cname(const char* data, size_t size) { + AppendBytes(FieldMetadata_Cname::kFieldId, data, size); + } + void set_cname(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Cname::kFieldId, chars.data, chars.size); + } + void set_cname(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Cname::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DstLevel = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + CgroupTransferTasksFtraceEvent>; + + static constexpr FieldMetadata_DstLevel kDstLevel{}; + void set_dst_level(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_DstLevel::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DstPath = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + CgroupTransferTasksFtraceEvent>; + + static constexpr FieldMetadata_DstPath kDstPath{}; + void set_dst_path(const char* data, size_t size) { + AppendBytes(FieldMetadata_DstPath::kFieldId, data, size); + } + void set_dst_path(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_DstPath::kFieldId, chars.data, chars.size); + } + void set_dst_path(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_DstPath::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class CgroupRmdirFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + CgroupRmdirFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit CgroupRmdirFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit CgroupRmdirFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_root() const { return at<1>().valid(); } + int32_t root() const { return at<1>().as_int32(); } + bool has_id() const { return at<2>().valid(); } + int32_t id() const { return at<2>().as_int32(); } + bool has_cname() const { return at<3>().valid(); } + ::protozero::ConstChars cname() const { return at<3>().as_string(); } + bool has_level() const { return at<4>().valid(); } + int32_t level() const { return at<4>().as_int32(); } + bool has_path() const { return at<5>().valid(); } + ::protozero::ConstChars path() const { return at<5>().as_string(); } +}; + +class CgroupRmdirFtraceEvent : public ::protozero::Message { + public: + using Decoder = CgroupRmdirFtraceEvent_Decoder; + enum : int32_t { + kRootFieldNumber = 1, + kIdFieldNumber = 2, + kCnameFieldNumber = 3, + kLevelFieldNumber = 4, + kPathFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.CgroupRmdirFtraceEvent"; } + + + using FieldMetadata_Root = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + CgroupRmdirFtraceEvent>; + + static constexpr FieldMetadata_Root kRoot{}; + void set_root(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Root::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Id = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + CgroupRmdirFtraceEvent>; + + static constexpr FieldMetadata_Id kId{}; + void set_id(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Cname = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + CgroupRmdirFtraceEvent>; + + static constexpr FieldMetadata_Cname kCname{}; + void set_cname(const char* data, size_t size) { + AppendBytes(FieldMetadata_Cname::kFieldId, data, size); + } + void set_cname(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Cname::kFieldId, chars.data, chars.size); + } + void set_cname(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Cname::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Level = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + CgroupRmdirFtraceEvent>; + + static constexpr FieldMetadata_Level kLevel{}; + void set_level(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Level::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Path = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + CgroupRmdirFtraceEvent>; + + static constexpr FieldMetadata_Path kPath{}; + void set_path(const char* data, size_t size) { + AppendBytes(FieldMetadata_Path::kFieldId, data, size); + } + void set_path(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Path::kFieldId, chars.data, chars.size); + } + void set_path(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Path::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class CgroupRemountFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + CgroupRemountFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit CgroupRemountFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit CgroupRemountFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_root() const { return at<1>().valid(); } + int32_t root() const { return at<1>().as_int32(); } + bool has_ss_mask() const { return at<2>().valid(); } + uint32_t ss_mask() const { return at<2>().as_uint32(); } + bool has_name() const { return at<3>().valid(); } + ::protozero::ConstChars name() const { return at<3>().as_string(); } +}; + +class CgroupRemountFtraceEvent : public ::protozero::Message { + public: + using Decoder = CgroupRemountFtraceEvent_Decoder; + enum : int32_t { + kRootFieldNumber = 1, + kSsMaskFieldNumber = 2, + kNameFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.CgroupRemountFtraceEvent"; } + + + using FieldMetadata_Root = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + CgroupRemountFtraceEvent>; + + static constexpr FieldMetadata_Root kRoot{}; + void set_root(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Root::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SsMask = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + CgroupRemountFtraceEvent>; + + static constexpr FieldMetadata_SsMask kSsMask{}; + void set_ss_mask(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_SsMask::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + CgroupRemountFtraceEvent>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class CgroupMkdirFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + CgroupMkdirFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit CgroupMkdirFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit CgroupMkdirFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_root() const { return at<1>().valid(); } + int32_t root() const { return at<1>().as_int32(); } + bool has_id() const { return at<2>().valid(); } + int32_t id() const { return at<2>().as_int32(); } + bool has_cname() const { return at<3>().valid(); } + ::protozero::ConstChars cname() const { return at<3>().as_string(); } + bool has_level() const { return at<4>().valid(); } + int32_t level() const { return at<4>().as_int32(); } + bool has_path() const { return at<5>().valid(); } + ::protozero::ConstChars path() const { return at<5>().as_string(); } +}; + +class CgroupMkdirFtraceEvent : public ::protozero::Message { + public: + using Decoder = CgroupMkdirFtraceEvent_Decoder; + enum : int32_t { + kRootFieldNumber = 1, + kIdFieldNumber = 2, + kCnameFieldNumber = 3, + kLevelFieldNumber = 4, + kPathFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.CgroupMkdirFtraceEvent"; } + + + using FieldMetadata_Root = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + CgroupMkdirFtraceEvent>; + + static constexpr FieldMetadata_Root kRoot{}; + void set_root(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Root::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Id = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + CgroupMkdirFtraceEvent>; + + static constexpr FieldMetadata_Id kId{}; + void set_id(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Cname = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + CgroupMkdirFtraceEvent>; + + static constexpr FieldMetadata_Cname kCname{}; + void set_cname(const char* data, size_t size) { + AppendBytes(FieldMetadata_Cname::kFieldId, data, size); + } + void set_cname(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Cname::kFieldId, chars.data, chars.size); + } + void set_cname(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Cname::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Level = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + CgroupMkdirFtraceEvent>; + + static constexpr FieldMetadata_Level kLevel{}; + void set_level(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Level::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Path = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + CgroupMkdirFtraceEvent>; + + static constexpr FieldMetadata_Path kPath{}; + void set_path(const char* data, size_t size) { + AppendBytes(FieldMetadata_Path::kFieldId, data, size); + } + void set_path(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Path::kFieldId, chars.data, chars.size); + } + void set_path(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Path::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class CgroupAttachTaskFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + CgroupAttachTaskFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit CgroupAttachTaskFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit CgroupAttachTaskFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dst_root() const { return at<1>().valid(); } + int32_t dst_root() const { return at<1>().as_int32(); } + bool has_dst_id() const { return at<2>().valid(); } + int32_t dst_id() const { return at<2>().as_int32(); } + bool has_pid() const { return at<3>().valid(); } + int32_t pid() const { return at<3>().as_int32(); } + bool has_comm() const { return at<4>().valid(); } + ::protozero::ConstChars comm() const { return at<4>().as_string(); } + bool has_cname() const { return at<5>().valid(); } + ::protozero::ConstChars cname() const { return at<5>().as_string(); } + bool has_dst_level() const { return at<6>().valid(); } + int32_t dst_level() const { return at<6>().as_int32(); } + bool has_dst_path() const { return at<7>().valid(); } + ::protozero::ConstChars dst_path() const { return at<7>().as_string(); } +}; + +class CgroupAttachTaskFtraceEvent : public ::protozero::Message { + public: + using Decoder = CgroupAttachTaskFtraceEvent_Decoder; + enum : int32_t { + kDstRootFieldNumber = 1, + kDstIdFieldNumber = 2, + kPidFieldNumber = 3, + kCommFieldNumber = 4, + kCnameFieldNumber = 5, + kDstLevelFieldNumber = 6, + kDstPathFieldNumber = 7, + }; + static constexpr const char* GetName() { return ".perfetto.protos.CgroupAttachTaskFtraceEvent"; } + + + using FieldMetadata_DstRoot = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + CgroupAttachTaskFtraceEvent>; + + static constexpr FieldMetadata_DstRoot kDstRoot{}; + void set_dst_root(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_DstRoot::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DstId = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + CgroupAttachTaskFtraceEvent>; + + static constexpr FieldMetadata_DstId kDstId{}; + void set_dst_id(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_DstId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pid = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + CgroupAttachTaskFtraceEvent>; + + static constexpr FieldMetadata_Pid kPid{}; + void set_pid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Comm = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + CgroupAttachTaskFtraceEvent>; + + static constexpr FieldMetadata_Comm kComm{}; + void set_comm(const char* data, size_t size) { + AppendBytes(FieldMetadata_Comm::kFieldId, data, size); + } + void set_comm(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Comm::kFieldId, chars.data, chars.size); + } + void set_comm(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Comm::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Cname = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + CgroupAttachTaskFtraceEvent>; + + static constexpr FieldMetadata_Cname kCname{}; + void set_cname(const char* data, size_t size) { + AppendBytes(FieldMetadata_Cname::kFieldId, data, size); + } + void set_cname(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Cname::kFieldId, chars.data, chars.size); + } + void set_cname(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Cname::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DstLevel = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + CgroupAttachTaskFtraceEvent>; + + static constexpr FieldMetadata_DstLevel kDstLevel{}; + void set_dst_level(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_DstLevel::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DstPath = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + CgroupAttachTaskFtraceEvent>; + + static constexpr FieldMetadata_DstPath kDstPath{}; + void set_dst_path(const char* data, size_t size) { + AppendBytes(FieldMetadata_DstPath::kFieldId, data, size); + } + void set_dst_path(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_DstPath::kFieldId, chars.data, chars.size); + } + void set_dst_path(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_DstPath::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class BlockUnplugFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + BlockUnplugFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit BlockUnplugFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit BlockUnplugFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_nr_rq() const { return at<1>().valid(); } + int32_t nr_rq() const { return at<1>().as_int32(); } + bool has_comm() const { return at<2>().valid(); } + ::protozero::ConstChars comm() const { return at<2>().as_string(); } +}; + +class BlockUnplugFtraceEvent : public ::protozero::Message { + public: + using Decoder = BlockUnplugFtraceEvent_Decoder; + enum : int32_t { + kNrRqFieldNumber = 1, + kCommFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.BlockUnplugFtraceEvent"; } + + + using FieldMetadata_NrRq = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + BlockUnplugFtraceEvent>; + + static constexpr FieldMetadata_NrRq kNrRq{}; + void set_nr_rq(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_NrRq::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Comm = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + BlockUnplugFtraceEvent>; + + static constexpr FieldMetadata_Comm kComm{}; + void set_comm(const char* data, size_t size) { + AppendBytes(FieldMetadata_Comm::kFieldId, data, size); + } + void set_comm(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Comm::kFieldId, chars.data, chars.size); + } + void set_comm(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Comm::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class BlockTouchBufferFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + BlockTouchBufferFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit BlockTouchBufferFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit BlockTouchBufferFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_sector() const { return at<2>().valid(); } + uint64_t sector() const { return at<2>().as_uint64(); } + bool has_size() const { return at<3>().valid(); } + uint64_t size() const { return at<3>().as_uint64(); } +}; + +class BlockTouchBufferFtraceEvent : public ::protozero::Message { + public: + using Decoder = BlockTouchBufferFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kSectorFieldNumber = 2, + kSizeFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.BlockTouchBufferFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + BlockTouchBufferFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Sector = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + BlockTouchBufferFtraceEvent>; + + static constexpr FieldMetadata_Sector kSector{}; + void set_sector(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Sector::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Size = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + BlockTouchBufferFtraceEvent>; + + static constexpr FieldMetadata_Size kSize{}; + void set_size(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Size::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class BlockSplitFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + BlockSplitFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit BlockSplitFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit BlockSplitFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_sector() const { return at<2>().valid(); } + uint64_t sector() const { return at<2>().as_uint64(); } + bool has_new_sector() const { return at<3>().valid(); } + uint64_t new_sector() const { return at<3>().as_uint64(); } + bool has_rwbs() const { return at<4>().valid(); } + ::protozero::ConstChars rwbs() const { return at<4>().as_string(); } + bool has_comm() const { return at<5>().valid(); } + ::protozero::ConstChars comm() const { return at<5>().as_string(); } +}; + +class BlockSplitFtraceEvent : public ::protozero::Message { + public: + using Decoder = BlockSplitFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kSectorFieldNumber = 2, + kNewSectorFieldNumber = 3, + kRwbsFieldNumber = 4, + kCommFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.BlockSplitFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + BlockSplitFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Sector = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + BlockSplitFtraceEvent>; + + static constexpr FieldMetadata_Sector kSector{}; + void set_sector(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Sector::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NewSector = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + BlockSplitFtraceEvent>; + + static constexpr FieldMetadata_NewSector kNewSector{}; + void set_new_sector(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_NewSector::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Rwbs = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + BlockSplitFtraceEvent>; + + static constexpr FieldMetadata_Rwbs kRwbs{}; + void set_rwbs(const char* data, size_t size) { + AppendBytes(FieldMetadata_Rwbs::kFieldId, data, size); + } + void set_rwbs(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Rwbs::kFieldId, chars.data, chars.size); + } + void set_rwbs(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Rwbs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Comm = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + BlockSplitFtraceEvent>; + + static constexpr FieldMetadata_Comm kComm{}; + void set_comm(const char* data, size_t size) { + AppendBytes(FieldMetadata_Comm::kFieldId, data, size); + } + void set_comm(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Comm::kFieldId, chars.data, chars.size); + } + void set_comm(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Comm::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class BlockSleeprqFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + BlockSleeprqFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit BlockSleeprqFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit BlockSleeprqFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_sector() const { return at<2>().valid(); } + uint64_t sector() const { return at<2>().as_uint64(); } + bool has_nr_sector() const { return at<3>().valid(); } + uint32_t nr_sector() const { return at<3>().as_uint32(); } + bool has_rwbs() const { return at<4>().valid(); } + ::protozero::ConstChars rwbs() const { return at<4>().as_string(); } + bool has_comm() const { return at<5>().valid(); } + ::protozero::ConstChars comm() const { return at<5>().as_string(); } +}; + +class BlockSleeprqFtraceEvent : public ::protozero::Message { + public: + using Decoder = BlockSleeprqFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kSectorFieldNumber = 2, + kNrSectorFieldNumber = 3, + kRwbsFieldNumber = 4, + kCommFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.BlockSleeprqFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + BlockSleeprqFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Sector = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + BlockSleeprqFtraceEvent>; + + static constexpr FieldMetadata_Sector kSector{}; + void set_sector(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Sector::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NrSector = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + BlockSleeprqFtraceEvent>; + + static constexpr FieldMetadata_NrSector kNrSector{}; + void set_nr_sector(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_NrSector::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Rwbs = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + BlockSleeprqFtraceEvent>; + + static constexpr FieldMetadata_Rwbs kRwbs{}; + void set_rwbs(const char* data, size_t size) { + AppendBytes(FieldMetadata_Rwbs::kFieldId, data, size); + } + void set_rwbs(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Rwbs::kFieldId, chars.data, chars.size); + } + void set_rwbs(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Rwbs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Comm = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + BlockSleeprqFtraceEvent>; + + static constexpr FieldMetadata_Comm kComm{}; + void set_comm(const char* data, size_t size) { + AppendBytes(FieldMetadata_Comm::kFieldId, data, size); + } + void set_comm(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Comm::kFieldId, chars.data, chars.size); + } + void set_comm(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Comm::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class BlockRqRequeueFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + BlockRqRequeueFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit BlockRqRequeueFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit BlockRqRequeueFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_sector() const { return at<2>().valid(); } + uint64_t sector() const { return at<2>().as_uint64(); } + bool has_nr_sector() const { return at<3>().valid(); } + uint32_t nr_sector() const { return at<3>().as_uint32(); } + bool has_errors() const { return at<4>().valid(); } + int32_t errors() const { return at<4>().as_int32(); } + bool has_rwbs() const { return at<5>().valid(); } + ::protozero::ConstChars rwbs() const { return at<5>().as_string(); } + bool has_cmd() const { return at<6>().valid(); } + ::protozero::ConstChars cmd() const { return at<6>().as_string(); } +}; + +class BlockRqRequeueFtraceEvent : public ::protozero::Message { + public: + using Decoder = BlockRqRequeueFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kSectorFieldNumber = 2, + kNrSectorFieldNumber = 3, + kErrorsFieldNumber = 4, + kRwbsFieldNumber = 5, + kCmdFieldNumber = 6, + }; + static constexpr const char* GetName() { return ".perfetto.protos.BlockRqRequeueFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + BlockRqRequeueFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Sector = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + BlockRqRequeueFtraceEvent>; + + static constexpr FieldMetadata_Sector kSector{}; + void set_sector(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Sector::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NrSector = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + BlockRqRequeueFtraceEvent>; + + static constexpr FieldMetadata_NrSector kNrSector{}; + void set_nr_sector(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_NrSector::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Errors = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + BlockRqRequeueFtraceEvent>; + + static constexpr FieldMetadata_Errors kErrors{}; + void set_errors(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Errors::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Rwbs = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + BlockRqRequeueFtraceEvent>; + + static constexpr FieldMetadata_Rwbs kRwbs{}; + void set_rwbs(const char* data, size_t size) { + AppendBytes(FieldMetadata_Rwbs::kFieldId, data, size); + } + void set_rwbs(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Rwbs::kFieldId, chars.data, chars.size); + } + void set_rwbs(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Rwbs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Cmd = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + BlockRqRequeueFtraceEvent>; + + static constexpr FieldMetadata_Cmd kCmd{}; + void set_cmd(const char* data, size_t size) { + AppendBytes(FieldMetadata_Cmd::kFieldId, data, size); + } + void set_cmd(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Cmd::kFieldId, chars.data, chars.size); + } + void set_cmd(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Cmd::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class BlockRqRemapFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + BlockRqRemapFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit BlockRqRemapFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit BlockRqRemapFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_sector() const { return at<2>().valid(); } + uint64_t sector() const { return at<2>().as_uint64(); } + bool has_nr_sector() const { return at<3>().valid(); } + uint32_t nr_sector() const { return at<3>().as_uint32(); } + bool has_old_dev() const { return at<4>().valid(); } + uint64_t old_dev() const { return at<4>().as_uint64(); } + bool has_old_sector() const { return at<5>().valid(); } + uint64_t old_sector() const { return at<5>().as_uint64(); } + bool has_nr_bios() const { return at<6>().valid(); } + uint32_t nr_bios() const { return at<6>().as_uint32(); } + bool has_rwbs() const { return at<7>().valid(); } + ::protozero::ConstChars rwbs() const { return at<7>().as_string(); } +}; + +class BlockRqRemapFtraceEvent : public ::protozero::Message { + public: + using Decoder = BlockRqRemapFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kSectorFieldNumber = 2, + kNrSectorFieldNumber = 3, + kOldDevFieldNumber = 4, + kOldSectorFieldNumber = 5, + kNrBiosFieldNumber = 6, + kRwbsFieldNumber = 7, + }; + static constexpr const char* GetName() { return ".perfetto.protos.BlockRqRemapFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + BlockRqRemapFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Sector = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + BlockRqRemapFtraceEvent>; + + static constexpr FieldMetadata_Sector kSector{}; + void set_sector(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Sector::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NrSector = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + BlockRqRemapFtraceEvent>; + + static constexpr FieldMetadata_NrSector kNrSector{}; + void set_nr_sector(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_NrSector::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_OldDev = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + BlockRqRemapFtraceEvent>; + + static constexpr FieldMetadata_OldDev kOldDev{}; + void set_old_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_OldDev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_OldSector = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + BlockRqRemapFtraceEvent>; + + static constexpr FieldMetadata_OldSector kOldSector{}; + void set_old_sector(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_OldSector::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NrBios = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + BlockRqRemapFtraceEvent>; + + static constexpr FieldMetadata_NrBios kNrBios{}; + void set_nr_bios(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_NrBios::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Rwbs = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + BlockRqRemapFtraceEvent>; + + static constexpr FieldMetadata_Rwbs kRwbs{}; + void set_rwbs(const char* data, size_t size) { + AppendBytes(FieldMetadata_Rwbs::kFieldId, data, size); + } + void set_rwbs(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Rwbs::kFieldId, chars.data, chars.size); + } + void set_rwbs(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Rwbs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class BlockRqInsertFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + BlockRqInsertFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit BlockRqInsertFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit BlockRqInsertFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_sector() const { return at<2>().valid(); } + uint64_t sector() const { return at<2>().as_uint64(); } + bool has_nr_sector() const { return at<3>().valid(); } + uint32_t nr_sector() const { return at<3>().as_uint32(); } + bool has_bytes() const { return at<4>().valid(); } + uint32_t bytes() const { return at<4>().as_uint32(); } + bool has_rwbs() const { return at<5>().valid(); } + ::protozero::ConstChars rwbs() const { return at<5>().as_string(); } + bool has_comm() const { return at<6>().valid(); } + ::protozero::ConstChars comm() const { return at<6>().as_string(); } + bool has_cmd() const { return at<7>().valid(); } + ::protozero::ConstChars cmd() const { return at<7>().as_string(); } +}; + +class BlockRqInsertFtraceEvent : public ::protozero::Message { + public: + using Decoder = BlockRqInsertFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kSectorFieldNumber = 2, + kNrSectorFieldNumber = 3, + kBytesFieldNumber = 4, + kRwbsFieldNumber = 5, + kCommFieldNumber = 6, + kCmdFieldNumber = 7, + }; + static constexpr const char* GetName() { return ".perfetto.protos.BlockRqInsertFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + BlockRqInsertFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Sector = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + BlockRqInsertFtraceEvent>; + + static constexpr FieldMetadata_Sector kSector{}; + void set_sector(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Sector::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NrSector = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + BlockRqInsertFtraceEvent>; + + static constexpr FieldMetadata_NrSector kNrSector{}; + void set_nr_sector(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_NrSector::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Bytes = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + BlockRqInsertFtraceEvent>; + + static constexpr FieldMetadata_Bytes kBytes{}; + void set_bytes(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Bytes::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Rwbs = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + BlockRqInsertFtraceEvent>; + + static constexpr FieldMetadata_Rwbs kRwbs{}; + void set_rwbs(const char* data, size_t size) { + AppendBytes(FieldMetadata_Rwbs::kFieldId, data, size); + } + void set_rwbs(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Rwbs::kFieldId, chars.data, chars.size); + } + void set_rwbs(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Rwbs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Comm = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + BlockRqInsertFtraceEvent>; + + static constexpr FieldMetadata_Comm kComm{}; + void set_comm(const char* data, size_t size) { + AppendBytes(FieldMetadata_Comm::kFieldId, data, size); + } + void set_comm(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Comm::kFieldId, chars.data, chars.size); + } + void set_comm(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Comm::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Cmd = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + BlockRqInsertFtraceEvent>; + + static constexpr FieldMetadata_Cmd kCmd{}; + void set_cmd(const char* data, size_t size) { + AppendBytes(FieldMetadata_Cmd::kFieldId, data, size); + } + void set_cmd(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Cmd::kFieldId, chars.data, chars.size); + } + void set_cmd(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Cmd::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class BlockRqCompleteFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + BlockRqCompleteFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit BlockRqCompleteFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit BlockRqCompleteFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_sector() const { return at<2>().valid(); } + uint64_t sector() const { return at<2>().as_uint64(); } + bool has_nr_sector() const { return at<3>().valid(); } + uint32_t nr_sector() const { return at<3>().as_uint32(); } + bool has_errors() const { return at<4>().valid(); } + int32_t errors() const { return at<4>().as_int32(); } + bool has_rwbs() const { return at<5>().valid(); } + ::protozero::ConstChars rwbs() const { return at<5>().as_string(); } + bool has_cmd() const { return at<6>().valid(); } + ::protozero::ConstChars cmd() const { return at<6>().as_string(); } + bool has_error() const { return at<7>().valid(); } + int32_t error() const { return at<7>().as_int32(); } +}; + +class BlockRqCompleteFtraceEvent : public ::protozero::Message { + public: + using Decoder = BlockRqCompleteFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kSectorFieldNumber = 2, + kNrSectorFieldNumber = 3, + kErrorsFieldNumber = 4, + kRwbsFieldNumber = 5, + kCmdFieldNumber = 6, + kErrorFieldNumber = 7, + }; + static constexpr const char* GetName() { return ".perfetto.protos.BlockRqCompleteFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + BlockRqCompleteFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Sector = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + BlockRqCompleteFtraceEvent>; + + static constexpr FieldMetadata_Sector kSector{}; + void set_sector(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Sector::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NrSector = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + BlockRqCompleteFtraceEvent>; + + static constexpr FieldMetadata_NrSector kNrSector{}; + void set_nr_sector(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_NrSector::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Errors = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + BlockRqCompleteFtraceEvent>; + + static constexpr FieldMetadata_Errors kErrors{}; + void set_errors(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Errors::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Rwbs = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + BlockRqCompleteFtraceEvent>; + + static constexpr FieldMetadata_Rwbs kRwbs{}; + void set_rwbs(const char* data, size_t size) { + AppendBytes(FieldMetadata_Rwbs::kFieldId, data, size); + } + void set_rwbs(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Rwbs::kFieldId, chars.data, chars.size); + } + void set_rwbs(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Rwbs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Cmd = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + BlockRqCompleteFtraceEvent>; + + static constexpr FieldMetadata_Cmd kCmd{}; + void set_cmd(const char* data, size_t size) { + AppendBytes(FieldMetadata_Cmd::kFieldId, data, size); + } + void set_cmd(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Cmd::kFieldId, chars.data, chars.size); + } + void set_cmd(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Cmd::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Error = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + BlockRqCompleteFtraceEvent>; + + static constexpr FieldMetadata_Error kError{}; + void set_error(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Error::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class BlockRqAbortFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + BlockRqAbortFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit BlockRqAbortFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit BlockRqAbortFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_sector() const { return at<2>().valid(); } + uint64_t sector() const { return at<2>().as_uint64(); } + bool has_nr_sector() const { return at<3>().valid(); } + uint32_t nr_sector() const { return at<3>().as_uint32(); } + bool has_errors() const { return at<4>().valid(); } + int32_t errors() const { return at<4>().as_int32(); } + bool has_rwbs() const { return at<5>().valid(); } + ::protozero::ConstChars rwbs() const { return at<5>().as_string(); } + bool has_cmd() const { return at<6>().valid(); } + ::protozero::ConstChars cmd() const { return at<6>().as_string(); } +}; + +class BlockRqAbortFtraceEvent : public ::protozero::Message { + public: + using Decoder = BlockRqAbortFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kSectorFieldNumber = 2, + kNrSectorFieldNumber = 3, + kErrorsFieldNumber = 4, + kRwbsFieldNumber = 5, + kCmdFieldNumber = 6, + }; + static constexpr const char* GetName() { return ".perfetto.protos.BlockRqAbortFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + BlockRqAbortFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Sector = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + BlockRqAbortFtraceEvent>; + + static constexpr FieldMetadata_Sector kSector{}; + void set_sector(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Sector::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NrSector = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + BlockRqAbortFtraceEvent>; + + static constexpr FieldMetadata_NrSector kNrSector{}; + void set_nr_sector(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_NrSector::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Errors = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + BlockRqAbortFtraceEvent>; + + static constexpr FieldMetadata_Errors kErrors{}; + void set_errors(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Errors::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Rwbs = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + BlockRqAbortFtraceEvent>; + + static constexpr FieldMetadata_Rwbs kRwbs{}; + void set_rwbs(const char* data, size_t size) { + AppendBytes(FieldMetadata_Rwbs::kFieldId, data, size); + } + void set_rwbs(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Rwbs::kFieldId, chars.data, chars.size); + } + void set_rwbs(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Rwbs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Cmd = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + BlockRqAbortFtraceEvent>; + + static constexpr FieldMetadata_Cmd kCmd{}; + void set_cmd(const char* data, size_t size) { + AppendBytes(FieldMetadata_Cmd::kFieldId, data, size); + } + void set_cmd(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Cmd::kFieldId, chars.data, chars.size); + } + void set_cmd(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Cmd::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class BlockPlugFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + BlockPlugFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit BlockPlugFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit BlockPlugFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_comm() const { return at<1>().valid(); } + ::protozero::ConstChars comm() const { return at<1>().as_string(); } +}; + +class BlockPlugFtraceEvent : public ::protozero::Message { + public: + using Decoder = BlockPlugFtraceEvent_Decoder; + enum : int32_t { + kCommFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.BlockPlugFtraceEvent"; } + + + using FieldMetadata_Comm = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + BlockPlugFtraceEvent>; + + static constexpr FieldMetadata_Comm kComm{}; + void set_comm(const char* data, size_t size) { + AppendBytes(FieldMetadata_Comm::kFieldId, data, size); + } + void set_comm(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Comm::kFieldId, chars.data, chars.size); + } + void set_comm(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Comm::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class BlockGetrqFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + BlockGetrqFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit BlockGetrqFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit BlockGetrqFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_sector() const { return at<2>().valid(); } + uint64_t sector() const { return at<2>().as_uint64(); } + bool has_nr_sector() const { return at<3>().valid(); } + uint32_t nr_sector() const { return at<3>().as_uint32(); } + bool has_rwbs() const { return at<4>().valid(); } + ::protozero::ConstChars rwbs() const { return at<4>().as_string(); } + bool has_comm() const { return at<5>().valid(); } + ::protozero::ConstChars comm() const { return at<5>().as_string(); } +}; + +class BlockGetrqFtraceEvent : public ::protozero::Message { + public: + using Decoder = BlockGetrqFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kSectorFieldNumber = 2, + kNrSectorFieldNumber = 3, + kRwbsFieldNumber = 4, + kCommFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.BlockGetrqFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + BlockGetrqFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Sector = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + BlockGetrqFtraceEvent>; + + static constexpr FieldMetadata_Sector kSector{}; + void set_sector(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Sector::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NrSector = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + BlockGetrqFtraceEvent>; + + static constexpr FieldMetadata_NrSector kNrSector{}; + void set_nr_sector(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_NrSector::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Rwbs = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + BlockGetrqFtraceEvent>; + + static constexpr FieldMetadata_Rwbs kRwbs{}; + void set_rwbs(const char* data, size_t size) { + AppendBytes(FieldMetadata_Rwbs::kFieldId, data, size); + } + void set_rwbs(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Rwbs::kFieldId, chars.data, chars.size); + } + void set_rwbs(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Rwbs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Comm = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + BlockGetrqFtraceEvent>; + + static constexpr FieldMetadata_Comm kComm{}; + void set_comm(const char* data, size_t size) { + AppendBytes(FieldMetadata_Comm::kFieldId, data, size); + } + void set_comm(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Comm::kFieldId, chars.data, chars.size); + } + void set_comm(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Comm::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class BlockDirtyBufferFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + BlockDirtyBufferFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit BlockDirtyBufferFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit BlockDirtyBufferFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_sector() const { return at<2>().valid(); } + uint64_t sector() const { return at<2>().as_uint64(); } + bool has_size() const { return at<3>().valid(); } + uint64_t size() const { return at<3>().as_uint64(); } +}; + +class BlockDirtyBufferFtraceEvent : public ::protozero::Message { + public: + using Decoder = BlockDirtyBufferFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kSectorFieldNumber = 2, + kSizeFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.BlockDirtyBufferFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + BlockDirtyBufferFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Sector = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + BlockDirtyBufferFtraceEvent>; + + static constexpr FieldMetadata_Sector kSector{}; + void set_sector(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Sector::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Size = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + BlockDirtyBufferFtraceEvent>; + + static constexpr FieldMetadata_Size kSize{}; + void set_size(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Size::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class BlockBioRemapFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + BlockBioRemapFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit BlockBioRemapFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit BlockBioRemapFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_sector() const { return at<2>().valid(); } + uint64_t sector() const { return at<2>().as_uint64(); } + bool has_nr_sector() const { return at<3>().valid(); } + uint32_t nr_sector() const { return at<3>().as_uint32(); } + bool has_old_dev() const { return at<4>().valid(); } + uint64_t old_dev() const { return at<4>().as_uint64(); } + bool has_old_sector() const { return at<5>().valid(); } + uint64_t old_sector() const { return at<5>().as_uint64(); } + bool has_rwbs() const { return at<6>().valid(); } + ::protozero::ConstChars rwbs() const { return at<6>().as_string(); } +}; + +class BlockBioRemapFtraceEvent : public ::protozero::Message { + public: + using Decoder = BlockBioRemapFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kSectorFieldNumber = 2, + kNrSectorFieldNumber = 3, + kOldDevFieldNumber = 4, + kOldSectorFieldNumber = 5, + kRwbsFieldNumber = 6, + }; + static constexpr const char* GetName() { return ".perfetto.protos.BlockBioRemapFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + BlockBioRemapFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Sector = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + BlockBioRemapFtraceEvent>; + + static constexpr FieldMetadata_Sector kSector{}; + void set_sector(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Sector::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NrSector = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + BlockBioRemapFtraceEvent>; + + static constexpr FieldMetadata_NrSector kNrSector{}; + void set_nr_sector(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_NrSector::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_OldDev = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + BlockBioRemapFtraceEvent>; + + static constexpr FieldMetadata_OldDev kOldDev{}; + void set_old_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_OldDev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_OldSector = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + BlockBioRemapFtraceEvent>; + + static constexpr FieldMetadata_OldSector kOldSector{}; + void set_old_sector(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_OldSector::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Rwbs = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + BlockBioRemapFtraceEvent>; + + static constexpr FieldMetadata_Rwbs kRwbs{}; + void set_rwbs(const char* data, size_t size) { + AppendBytes(FieldMetadata_Rwbs::kFieldId, data, size); + } + void set_rwbs(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Rwbs::kFieldId, chars.data, chars.size); + } + void set_rwbs(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Rwbs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class BlockBioQueueFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + BlockBioQueueFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit BlockBioQueueFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit BlockBioQueueFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_sector() const { return at<2>().valid(); } + uint64_t sector() const { return at<2>().as_uint64(); } + bool has_nr_sector() const { return at<3>().valid(); } + uint32_t nr_sector() const { return at<3>().as_uint32(); } + bool has_rwbs() const { return at<4>().valid(); } + ::protozero::ConstChars rwbs() const { return at<4>().as_string(); } + bool has_comm() const { return at<5>().valid(); } + ::protozero::ConstChars comm() const { return at<5>().as_string(); } +}; + +class BlockBioQueueFtraceEvent : public ::protozero::Message { + public: + using Decoder = BlockBioQueueFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kSectorFieldNumber = 2, + kNrSectorFieldNumber = 3, + kRwbsFieldNumber = 4, + kCommFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.BlockBioQueueFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + BlockBioQueueFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Sector = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + BlockBioQueueFtraceEvent>; + + static constexpr FieldMetadata_Sector kSector{}; + void set_sector(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Sector::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NrSector = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + BlockBioQueueFtraceEvent>; + + static constexpr FieldMetadata_NrSector kNrSector{}; + void set_nr_sector(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_NrSector::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Rwbs = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + BlockBioQueueFtraceEvent>; + + static constexpr FieldMetadata_Rwbs kRwbs{}; + void set_rwbs(const char* data, size_t size) { + AppendBytes(FieldMetadata_Rwbs::kFieldId, data, size); + } + void set_rwbs(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Rwbs::kFieldId, chars.data, chars.size); + } + void set_rwbs(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Rwbs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Comm = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + BlockBioQueueFtraceEvent>; + + static constexpr FieldMetadata_Comm kComm{}; + void set_comm(const char* data, size_t size) { + AppendBytes(FieldMetadata_Comm::kFieldId, data, size); + } + void set_comm(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Comm::kFieldId, chars.data, chars.size); + } + void set_comm(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Comm::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class BlockBioFrontmergeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + BlockBioFrontmergeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit BlockBioFrontmergeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit BlockBioFrontmergeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_sector() const { return at<2>().valid(); } + uint64_t sector() const { return at<2>().as_uint64(); } + bool has_nr_sector() const { return at<3>().valid(); } + uint32_t nr_sector() const { return at<3>().as_uint32(); } + bool has_rwbs() const { return at<4>().valid(); } + ::protozero::ConstChars rwbs() const { return at<4>().as_string(); } + bool has_comm() const { return at<5>().valid(); } + ::protozero::ConstChars comm() const { return at<5>().as_string(); } +}; + +class BlockBioFrontmergeFtraceEvent : public ::protozero::Message { + public: + using Decoder = BlockBioFrontmergeFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kSectorFieldNumber = 2, + kNrSectorFieldNumber = 3, + kRwbsFieldNumber = 4, + kCommFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.BlockBioFrontmergeFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + BlockBioFrontmergeFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Sector = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + BlockBioFrontmergeFtraceEvent>; + + static constexpr FieldMetadata_Sector kSector{}; + void set_sector(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Sector::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NrSector = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + BlockBioFrontmergeFtraceEvent>; + + static constexpr FieldMetadata_NrSector kNrSector{}; + void set_nr_sector(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_NrSector::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Rwbs = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + BlockBioFrontmergeFtraceEvent>; + + static constexpr FieldMetadata_Rwbs kRwbs{}; + void set_rwbs(const char* data, size_t size) { + AppendBytes(FieldMetadata_Rwbs::kFieldId, data, size); + } + void set_rwbs(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Rwbs::kFieldId, chars.data, chars.size); + } + void set_rwbs(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Rwbs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Comm = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + BlockBioFrontmergeFtraceEvent>; + + static constexpr FieldMetadata_Comm kComm{}; + void set_comm(const char* data, size_t size) { + AppendBytes(FieldMetadata_Comm::kFieldId, data, size); + } + void set_comm(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Comm::kFieldId, chars.data, chars.size); + } + void set_comm(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Comm::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class BlockBioCompleteFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + BlockBioCompleteFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit BlockBioCompleteFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit BlockBioCompleteFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_sector() const { return at<2>().valid(); } + uint64_t sector() const { return at<2>().as_uint64(); } + bool has_nr_sector() const { return at<3>().valid(); } + uint32_t nr_sector() const { return at<3>().as_uint32(); } + bool has_error() const { return at<4>().valid(); } + int32_t error() const { return at<4>().as_int32(); } + bool has_rwbs() const { return at<5>().valid(); } + ::protozero::ConstChars rwbs() const { return at<5>().as_string(); } +}; + +class BlockBioCompleteFtraceEvent : public ::protozero::Message { + public: + using Decoder = BlockBioCompleteFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kSectorFieldNumber = 2, + kNrSectorFieldNumber = 3, + kErrorFieldNumber = 4, + kRwbsFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.BlockBioCompleteFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + BlockBioCompleteFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Sector = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + BlockBioCompleteFtraceEvent>; + + static constexpr FieldMetadata_Sector kSector{}; + void set_sector(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Sector::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NrSector = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + BlockBioCompleteFtraceEvent>; + + static constexpr FieldMetadata_NrSector kNrSector{}; + void set_nr_sector(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_NrSector::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Error = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + BlockBioCompleteFtraceEvent>; + + static constexpr FieldMetadata_Error kError{}; + void set_error(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Error::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Rwbs = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + BlockBioCompleteFtraceEvent>; + + static constexpr FieldMetadata_Rwbs kRwbs{}; + void set_rwbs(const char* data, size_t size) { + AppendBytes(FieldMetadata_Rwbs::kFieldId, data, size); + } + void set_rwbs(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Rwbs::kFieldId, chars.data, chars.size); + } + void set_rwbs(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Rwbs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class BlockBioBounceFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + BlockBioBounceFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit BlockBioBounceFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit BlockBioBounceFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_sector() const { return at<2>().valid(); } + uint64_t sector() const { return at<2>().as_uint64(); } + bool has_nr_sector() const { return at<3>().valid(); } + uint32_t nr_sector() const { return at<3>().as_uint32(); } + bool has_rwbs() const { return at<4>().valid(); } + ::protozero::ConstChars rwbs() const { return at<4>().as_string(); } + bool has_comm() const { return at<5>().valid(); } + ::protozero::ConstChars comm() const { return at<5>().as_string(); } +}; + +class BlockBioBounceFtraceEvent : public ::protozero::Message { + public: + using Decoder = BlockBioBounceFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kSectorFieldNumber = 2, + kNrSectorFieldNumber = 3, + kRwbsFieldNumber = 4, + kCommFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.BlockBioBounceFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + BlockBioBounceFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Sector = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + BlockBioBounceFtraceEvent>; + + static constexpr FieldMetadata_Sector kSector{}; + void set_sector(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Sector::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NrSector = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + BlockBioBounceFtraceEvent>; + + static constexpr FieldMetadata_NrSector kNrSector{}; + void set_nr_sector(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_NrSector::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Rwbs = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + BlockBioBounceFtraceEvent>; + + static constexpr FieldMetadata_Rwbs kRwbs{}; + void set_rwbs(const char* data, size_t size) { + AppendBytes(FieldMetadata_Rwbs::kFieldId, data, size); + } + void set_rwbs(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Rwbs::kFieldId, chars.data, chars.size); + } + void set_rwbs(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Rwbs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Comm = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + BlockBioBounceFtraceEvent>; + + static constexpr FieldMetadata_Comm kComm{}; + void set_comm(const char* data, size_t size) { + AppendBytes(FieldMetadata_Comm::kFieldId, data, size); + } + void set_comm(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Comm::kFieldId, chars.data, chars.size); + } + void set_comm(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Comm::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class BlockBioBackmergeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + BlockBioBackmergeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit BlockBioBackmergeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit BlockBioBackmergeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_sector() const { return at<2>().valid(); } + uint64_t sector() const { return at<2>().as_uint64(); } + bool has_nr_sector() const { return at<3>().valid(); } + uint32_t nr_sector() const { return at<3>().as_uint32(); } + bool has_rwbs() const { return at<4>().valid(); } + ::protozero::ConstChars rwbs() const { return at<4>().as_string(); } + bool has_comm() const { return at<5>().valid(); } + ::protozero::ConstChars comm() const { return at<5>().as_string(); } +}; + +class BlockBioBackmergeFtraceEvent : public ::protozero::Message { + public: + using Decoder = BlockBioBackmergeFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kSectorFieldNumber = 2, + kNrSectorFieldNumber = 3, + kRwbsFieldNumber = 4, + kCommFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.BlockBioBackmergeFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + BlockBioBackmergeFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Sector = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + BlockBioBackmergeFtraceEvent>; + + static constexpr FieldMetadata_Sector kSector{}; + void set_sector(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Sector::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NrSector = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + BlockBioBackmergeFtraceEvent>; + + static constexpr FieldMetadata_NrSector kNrSector{}; + void set_nr_sector(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_NrSector::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Rwbs = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + BlockBioBackmergeFtraceEvent>; + + static constexpr FieldMetadata_Rwbs kRwbs{}; + void set_rwbs(const char* data, size_t size) { + AppendBytes(FieldMetadata_Rwbs::kFieldId, data, size); + } + void set_rwbs(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Rwbs::kFieldId, chars.data, chars.size); + } + void set_rwbs(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Rwbs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Comm = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + BlockBioBackmergeFtraceEvent>; + + static constexpr FieldMetadata_Comm kComm{}; + void set_comm(const char* data, size_t size) { + AppendBytes(FieldMetadata_Comm::kFieldId, data, size); + } + void set_comm(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Comm::kFieldId, chars.data, chars.size); + } + void set_comm(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Comm::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class BlockRqIssueFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + BlockRqIssueFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit BlockRqIssueFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit BlockRqIssueFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dev() const { return at<1>().valid(); } + uint64_t dev() const { return at<1>().as_uint64(); } + bool has_sector() const { return at<2>().valid(); } + uint64_t sector() const { return at<2>().as_uint64(); } + bool has_nr_sector() const { return at<3>().valid(); } + uint32_t nr_sector() const { return at<3>().as_uint32(); } + bool has_bytes() const { return at<4>().valid(); } + uint32_t bytes() const { return at<4>().as_uint32(); } + bool has_rwbs() const { return at<5>().valid(); } + ::protozero::ConstChars rwbs() const { return at<5>().as_string(); } + bool has_comm() const { return at<6>().valid(); } + ::protozero::ConstChars comm() const { return at<6>().as_string(); } + bool has_cmd() const { return at<7>().valid(); } + ::protozero::ConstChars cmd() const { return at<7>().as_string(); } +}; + +class BlockRqIssueFtraceEvent : public ::protozero::Message { + public: + using Decoder = BlockRqIssueFtraceEvent_Decoder; + enum : int32_t { + kDevFieldNumber = 1, + kSectorFieldNumber = 2, + kNrSectorFieldNumber = 3, + kBytesFieldNumber = 4, + kRwbsFieldNumber = 5, + kCommFieldNumber = 6, + kCmdFieldNumber = 7, + }; + static constexpr const char* GetName() { return ".perfetto.protos.BlockRqIssueFtraceEvent"; } + + + using FieldMetadata_Dev = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + BlockRqIssueFtraceEvent>; + + static constexpr FieldMetadata_Dev kDev{}; + void set_dev(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Dev::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Sector = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + BlockRqIssueFtraceEvent>; + + static constexpr FieldMetadata_Sector kSector{}; + void set_sector(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Sector::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NrSector = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + BlockRqIssueFtraceEvent>; + + static constexpr FieldMetadata_NrSector kNrSector{}; + void set_nr_sector(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_NrSector::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Bytes = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + BlockRqIssueFtraceEvent>; + + static constexpr FieldMetadata_Bytes kBytes{}; + void set_bytes(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Bytes::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Rwbs = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + BlockRqIssueFtraceEvent>; + + static constexpr FieldMetadata_Rwbs kRwbs{}; + void set_rwbs(const char* data, size_t size) { + AppendBytes(FieldMetadata_Rwbs::kFieldId, data, size); + } + void set_rwbs(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Rwbs::kFieldId, chars.data, chars.size); + } + void set_rwbs(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Rwbs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Comm = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + BlockRqIssueFtraceEvent>; + + static constexpr FieldMetadata_Comm kComm{}; + void set_comm(const char* data, size_t size) { + AppendBytes(FieldMetadata_Comm::kFieldId, data, size); + } + void set_comm(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Comm::kFieldId, chars.data, chars.size); + } + void set_comm(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Comm::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Cmd = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + BlockRqIssueFtraceEvent>; + + static constexpr FieldMetadata_Cmd kCmd{}; + void set_cmd(const char* data, size_t size) { + AppendBytes(FieldMetadata_Cmd::kFieldId, data, size); + } + void set_cmd(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Cmd::kFieldId, chars.data, chars.size); + } + void set_cmd(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Cmd::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class BinderReturnFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + BinderReturnFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit BinderReturnFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit BinderReturnFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_cmd() const { return at<1>().valid(); } + uint32_t cmd() const { return at<1>().as_uint32(); } +}; + +class BinderReturnFtraceEvent : public ::protozero::Message { + public: + using Decoder = BinderReturnFtraceEvent_Decoder; + enum : int32_t { + kCmdFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.BinderReturnFtraceEvent"; } + + + using FieldMetadata_Cmd = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + BinderReturnFtraceEvent>; + + static constexpr FieldMetadata_Cmd kCmd{}; + void set_cmd(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Cmd::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class BinderCommandFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + BinderCommandFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit BinderCommandFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit BinderCommandFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_cmd() const { return at<1>().valid(); } + uint32_t cmd() const { return at<1>().as_uint32(); } +}; + +class BinderCommandFtraceEvent : public ::protozero::Message { + public: + using Decoder = BinderCommandFtraceEvent_Decoder; + enum : int32_t { + kCmdFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.BinderCommandFtraceEvent"; } + + + using FieldMetadata_Cmd = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + BinderCommandFtraceEvent>; + + static constexpr FieldMetadata_Cmd kCmd{}; + void set_cmd(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Cmd::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class BinderTransactionAllocBufFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + BinderTransactionAllocBufFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit BinderTransactionAllocBufFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit BinderTransactionAllocBufFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_data_size() const { return at<1>().valid(); } + uint64_t data_size() const { return at<1>().as_uint64(); } + bool has_debug_id() const { return at<2>().valid(); } + int32_t debug_id() const { return at<2>().as_int32(); } + bool has_offsets_size() const { return at<3>().valid(); } + uint64_t offsets_size() const { return at<3>().as_uint64(); } + bool has_extra_buffers_size() const { return at<4>().valid(); } + uint64_t extra_buffers_size() const { return at<4>().as_uint64(); } +}; + +class BinderTransactionAllocBufFtraceEvent : public ::protozero::Message { + public: + using Decoder = BinderTransactionAllocBufFtraceEvent_Decoder; + enum : int32_t { + kDataSizeFieldNumber = 1, + kDebugIdFieldNumber = 2, + kOffsetsSizeFieldNumber = 3, + kExtraBuffersSizeFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.BinderTransactionAllocBufFtraceEvent"; } + + + using FieldMetadata_DataSize = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + BinderTransactionAllocBufFtraceEvent>; + + static constexpr FieldMetadata_DataSize kDataSize{}; + void set_data_size(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_DataSize::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DebugId = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + BinderTransactionAllocBufFtraceEvent>; + + static constexpr FieldMetadata_DebugId kDebugId{}; + void set_debug_id(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_DebugId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_OffsetsSize = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + BinderTransactionAllocBufFtraceEvent>; + + static constexpr FieldMetadata_OffsetsSize kOffsetsSize{}; + void set_offsets_size(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_OffsetsSize::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ExtraBuffersSize = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + BinderTransactionAllocBufFtraceEvent>; + + static constexpr FieldMetadata_ExtraBuffersSize kExtraBuffersSize{}; + void set_extra_buffers_size(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_ExtraBuffersSize::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class BinderUnlockFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + BinderUnlockFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit BinderUnlockFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit BinderUnlockFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_tag() const { return at<1>().valid(); } + ::protozero::ConstChars tag() const { return at<1>().as_string(); } +}; + +class BinderUnlockFtraceEvent : public ::protozero::Message { + public: + using Decoder = BinderUnlockFtraceEvent_Decoder; + enum : int32_t { + kTagFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.BinderUnlockFtraceEvent"; } + + + using FieldMetadata_Tag = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + BinderUnlockFtraceEvent>; + + static constexpr FieldMetadata_Tag kTag{}; + void set_tag(const char* data, size_t size) { + AppendBytes(FieldMetadata_Tag::kFieldId, data, size); + } + void set_tag(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Tag::kFieldId, chars.data, chars.size); + } + void set_tag(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Tag::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class BinderLockedFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + BinderLockedFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit BinderLockedFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit BinderLockedFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_tag() const { return at<1>().valid(); } + ::protozero::ConstChars tag() const { return at<1>().as_string(); } +}; + +class BinderLockedFtraceEvent : public ::protozero::Message { + public: + using Decoder = BinderLockedFtraceEvent_Decoder; + enum : int32_t { + kTagFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.BinderLockedFtraceEvent"; } + + + using FieldMetadata_Tag = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + BinderLockedFtraceEvent>; + + static constexpr FieldMetadata_Tag kTag{}; + void set_tag(const char* data, size_t size) { + AppendBytes(FieldMetadata_Tag::kFieldId, data, size); + } + void set_tag(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Tag::kFieldId, chars.data, chars.size); + } + void set_tag(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Tag::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class BinderLockFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + BinderLockFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit BinderLockFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit BinderLockFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_tag() const { return at<1>().valid(); } + ::protozero::ConstChars tag() const { return at<1>().as_string(); } +}; + +class BinderLockFtraceEvent : public ::protozero::Message { + public: + using Decoder = BinderLockFtraceEvent_Decoder; + enum : int32_t { + kTagFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.BinderLockFtraceEvent"; } + + + using FieldMetadata_Tag = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + BinderLockFtraceEvent>; + + static constexpr FieldMetadata_Tag kTag{}; + void set_tag(const char* data, size_t size) { + AppendBytes(FieldMetadata_Tag::kFieldId, data, size); + } + void set_tag(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Tag::kFieldId, chars.data, chars.size); + } + void set_tag(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Tag::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class BinderSetPriorityFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + BinderSetPriorityFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit BinderSetPriorityFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit BinderSetPriorityFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_proc() const { return at<1>().valid(); } + int32_t proc() const { return at<1>().as_int32(); } + bool has_thread() const { return at<2>().valid(); } + int32_t thread() const { return at<2>().as_int32(); } + bool has_old_prio() const { return at<3>().valid(); } + uint32_t old_prio() const { return at<3>().as_uint32(); } + bool has_new_prio() const { return at<4>().valid(); } + uint32_t new_prio() const { return at<4>().as_uint32(); } + bool has_desired_prio() const { return at<5>().valid(); } + uint32_t desired_prio() const { return at<5>().as_uint32(); } +}; + +class BinderSetPriorityFtraceEvent : public ::protozero::Message { + public: + using Decoder = BinderSetPriorityFtraceEvent_Decoder; + enum : int32_t { + kProcFieldNumber = 1, + kThreadFieldNumber = 2, + kOldPrioFieldNumber = 3, + kNewPrioFieldNumber = 4, + kDesiredPrioFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.BinderSetPriorityFtraceEvent"; } + + + using FieldMetadata_Proc = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + BinderSetPriorityFtraceEvent>; + + static constexpr FieldMetadata_Proc kProc{}; + void set_proc(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Proc::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Thread = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + BinderSetPriorityFtraceEvent>; + + static constexpr FieldMetadata_Thread kThread{}; + void set_thread(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Thread::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_OldPrio = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + BinderSetPriorityFtraceEvent>; + + static constexpr FieldMetadata_OldPrio kOldPrio{}; + void set_old_prio(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_OldPrio::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NewPrio = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + BinderSetPriorityFtraceEvent>; + + static constexpr FieldMetadata_NewPrio kNewPrio{}; + void set_new_prio(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_NewPrio::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DesiredPrio = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + BinderSetPriorityFtraceEvent>; + + static constexpr FieldMetadata_DesiredPrio kDesiredPrio{}; + void set_desired_prio(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_DesiredPrio::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class BinderTransactionReceivedFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + BinderTransactionReceivedFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit BinderTransactionReceivedFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit BinderTransactionReceivedFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_debug_id() const { return at<1>().valid(); } + int32_t debug_id() const { return at<1>().as_int32(); } +}; + +class BinderTransactionReceivedFtraceEvent : public ::protozero::Message { + public: + using Decoder = BinderTransactionReceivedFtraceEvent_Decoder; + enum : int32_t { + kDebugIdFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.BinderTransactionReceivedFtraceEvent"; } + + + using FieldMetadata_DebugId = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + BinderTransactionReceivedFtraceEvent>; + + static constexpr FieldMetadata_DebugId kDebugId{}; + void set_debug_id(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_DebugId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class BinderTransactionFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + BinderTransactionFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit BinderTransactionFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit BinderTransactionFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_debug_id() const { return at<1>().valid(); } + int32_t debug_id() const { return at<1>().as_int32(); } + bool has_target_node() const { return at<2>().valid(); } + int32_t target_node() const { return at<2>().as_int32(); } + bool has_to_proc() const { return at<3>().valid(); } + int32_t to_proc() const { return at<3>().as_int32(); } + bool has_to_thread() const { return at<4>().valid(); } + int32_t to_thread() const { return at<4>().as_int32(); } + bool has_reply() const { return at<5>().valid(); } + int32_t reply() const { return at<5>().as_int32(); } + bool has_code() const { return at<6>().valid(); } + uint32_t code() const { return at<6>().as_uint32(); } + bool has_flags() const { return at<7>().valid(); } + uint32_t flags() const { return at<7>().as_uint32(); } +}; + +class BinderTransactionFtraceEvent : public ::protozero::Message { + public: + using Decoder = BinderTransactionFtraceEvent_Decoder; + enum : int32_t { + kDebugIdFieldNumber = 1, + kTargetNodeFieldNumber = 2, + kToProcFieldNumber = 3, + kToThreadFieldNumber = 4, + kReplyFieldNumber = 5, + kCodeFieldNumber = 6, + kFlagsFieldNumber = 7, + }; + static constexpr const char* GetName() { return ".perfetto.protos.BinderTransactionFtraceEvent"; } + + + using FieldMetadata_DebugId = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + BinderTransactionFtraceEvent>; + + static constexpr FieldMetadata_DebugId kDebugId{}; + void set_debug_id(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_DebugId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TargetNode = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + BinderTransactionFtraceEvent>; + + static constexpr FieldMetadata_TargetNode kTargetNode{}; + void set_target_node(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TargetNode::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ToProc = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + BinderTransactionFtraceEvent>; + + static constexpr FieldMetadata_ToProc kToProc{}; + void set_to_proc(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ToProc::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ToThread = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + BinderTransactionFtraceEvent>; + + static constexpr FieldMetadata_ToThread kToThread{}; + void set_to_thread(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ToThread::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Reply = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + BinderTransactionFtraceEvent>; + + static constexpr FieldMetadata_Reply kReply{}; + void set_reply(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Reply::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Code = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + BinderTransactionFtraceEvent>; + + static constexpr FieldMetadata_Code kCode{}; + void set_code(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Code::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Flags = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + BinderTransactionFtraceEvent>; + + static constexpr FieldMetadata_Flags kFlags{}; + void set_flags(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class AndroidFsFsyncStartFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + AndroidFsFsyncStartFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit AndroidFsFsyncStartFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit AndroidFsFsyncStartFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_cmdline() const { return at<1>().valid(); } + ::protozero::ConstChars cmdline() const { return at<1>().as_string(); } + bool has_i_size() const { return at<2>().valid(); } + int64_t i_size() const { return at<2>().as_int64(); } + bool has_ino() const { return at<3>().valid(); } + uint64_t ino() const { return at<3>().as_uint64(); } + bool has_pathbuf() const { return at<4>().valid(); } + ::protozero::ConstChars pathbuf() const { return at<4>().as_string(); } + bool has_pid() const { return at<5>().valid(); } + int32_t pid() const { return at<5>().as_int32(); } +}; + +class AndroidFsFsyncStartFtraceEvent : public ::protozero::Message { + public: + using Decoder = AndroidFsFsyncStartFtraceEvent_Decoder; + enum : int32_t { + kCmdlineFieldNumber = 1, + kISizeFieldNumber = 2, + kInoFieldNumber = 3, + kPathbufFieldNumber = 4, + kPidFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.AndroidFsFsyncStartFtraceEvent"; } + + + using FieldMetadata_Cmdline = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + AndroidFsFsyncStartFtraceEvent>; + + static constexpr FieldMetadata_Cmdline kCmdline{}; + void set_cmdline(const char* data, size_t size) { + AppendBytes(FieldMetadata_Cmdline::kFieldId, data, size); + } + void set_cmdline(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Cmdline::kFieldId, chars.data, chars.size); + } + void set_cmdline(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Cmdline::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ISize = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + AndroidFsFsyncStartFtraceEvent>; + + static constexpr FieldMetadata_ISize kISize{}; + void set_i_size(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_ISize::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + AndroidFsFsyncStartFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pathbuf = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + AndroidFsFsyncStartFtraceEvent>; + + static constexpr FieldMetadata_Pathbuf kPathbuf{}; + void set_pathbuf(const char* data, size_t size) { + AppendBytes(FieldMetadata_Pathbuf::kFieldId, data, size); + } + void set_pathbuf(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Pathbuf::kFieldId, chars.data, chars.size); + } + void set_pathbuf(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Pathbuf::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pid = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + AndroidFsFsyncStartFtraceEvent>; + + static constexpr FieldMetadata_Pid kPid{}; + void set_pid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class AndroidFsFsyncEndFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + AndroidFsFsyncEndFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit AndroidFsFsyncEndFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit AndroidFsFsyncEndFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_bytes() const { return at<1>().valid(); } + int32_t bytes() const { return at<1>().as_int32(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_offset() const { return at<3>().valid(); } + int64_t offset() const { return at<3>().as_int64(); } +}; + +class AndroidFsFsyncEndFtraceEvent : public ::protozero::Message { + public: + using Decoder = AndroidFsFsyncEndFtraceEvent_Decoder; + enum : int32_t { + kBytesFieldNumber = 1, + kInoFieldNumber = 2, + kOffsetFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.AndroidFsFsyncEndFtraceEvent"; } + + + using FieldMetadata_Bytes = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + AndroidFsFsyncEndFtraceEvent>; + + static constexpr FieldMetadata_Bytes kBytes{}; + void set_bytes(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Bytes::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + AndroidFsFsyncEndFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Offset = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + AndroidFsFsyncEndFtraceEvent>; + + static constexpr FieldMetadata_Offset kOffset{}; + void set_offset(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Offset::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } +}; + +class AndroidFsDatawriteStartFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + AndroidFsDatawriteStartFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit AndroidFsDatawriteStartFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit AndroidFsDatawriteStartFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_bytes() const { return at<1>().valid(); } + int32_t bytes() const { return at<1>().as_int32(); } + bool has_cmdline() const { return at<2>().valid(); } + ::protozero::ConstChars cmdline() const { return at<2>().as_string(); } + bool has_i_size() const { return at<3>().valid(); } + int64_t i_size() const { return at<3>().as_int64(); } + bool has_ino() const { return at<4>().valid(); } + uint64_t ino() const { return at<4>().as_uint64(); } + bool has_offset() const { return at<5>().valid(); } + int64_t offset() const { return at<5>().as_int64(); } + bool has_pathbuf() const { return at<6>().valid(); } + ::protozero::ConstChars pathbuf() const { return at<6>().as_string(); } + bool has_pid() const { return at<7>().valid(); } + int32_t pid() const { return at<7>().as_int32(); } +}; + +class AndroidFsDatawriteStartFtraceEvent : public ::protozero::Message { + public: + using Decoder = AndroidFsDatawriteStartFtraceEvent_Decoder; + enum : int32_t { + kBytesFieldNumber = 1, + kCmdlineFieldNumber = 2, + kISizeFieldNumber = 3, + kInoFieldNumber = 4, + kOffsetFieldNumber = 5, + kPathbufFieldNumber = 6, + kPidFieldNumber = 7, + }; + static constexpr const char* GetName() { return ".perfetto.protos.AndroidFsDatawriteStartFtraceEvent"; } + + + using FieldMetadata_Bytes = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + AndroidFsDatawriteStartFtraceEvent>; + + static constexpr FieldMetadata_Bytes kBytes{}; + void set_bytes(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Bytes::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Cmdline = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + AndroidFsDatawriteStartFtraceEvent>; + + static constexpr FieldMetadata_Cmdline kCmdline{}; + void set_cmdline(const char* data, size_t size) { + AppendBytes(FieldMetadata_Cmdline::kFieldId, data, size); + } + void set_cmdline(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Cmdline::kFieldId, chars.data, chars.size); + } + void set_cmdline(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Cmdline::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ISize = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + AndroidFsDatawriteStartFtraceEvent>; + + static constexpr FieldMetadata_ISize kISize{}; + void set_i_size(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_ISize::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + AndroidFsDatawriteStartFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Offset = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + AndroidFsDatawriteStartFtraceEvent>; + + static constexpr FieldMetadata_Offset kOffset{}; + void set_offset(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Offset::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pathbuf = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + AndroidFsDatawriteStartFtraceEvent>; + + static constexpr FieldMetadata_Pathbuf kPathbuf{}; + void set_pathbuf(const char* data, size_t size) { + AppendBytes(FieldMetadata_Pathbuf::kFieldId, data, size); + } + void set_pathbuf(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Pathbuf::kFieldId, chars.data, chars.size); + } + void set_pathbuf(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Pathbuf::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pid = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + AndroidFsDatawriteStartFtraceEvent>; + + static constexpr FieldMetadata_Pid kPid{}; + void set_pid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class AndroidFsDatawriteEndFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + AndroidFsDatawriteEndFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit AndroidFsDatawriteEndFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit AndroidFsDatawriteEndFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_bytes() const { return at<1>().valid(); } + int32_t bytes() const { return at<1>().as_int32(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_offset() const { return at<3>().valid(); } + int64_t offset() const { return at<3>().as_int64(); } +}; + +class AndroidFsDatawriteEndFtraceEvent : public ::protozero::Message { + public: + using Decoder = AndroidFsDatawriteEndFtraceEvent_Decoder; + enum : int32_t { + kBytesFieldNumber = 1, + kInoFieldNumber = 2, + kOffsetFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.AndroidFsDatawriteEndFtraceEvent"; } + + + using FieldMetadata_Bytes = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + AndroidFsDatawriteEndFtraceEvent>; + + static constexpr FieldMetadata_Bytes kBytes{}; + void set_bytes(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Bytes::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + AndroidFsDatawriteEndFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Offset = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + AndroidFsDatawriteEndFtraceEvent>; + + static constexpr FieldMetadata_Offset kOffset{}; + void set_offset(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Offset::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } +}; + +class AndroidFsDatareadStartFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + AndroidFsDatareadStartFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit AndroidFsDatareadStartFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit AndroidFsDatareadStartFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_bytes() const { return at<1>().valid(); } + int32_t bytes() const { return at<1>().as_int32(); } + bool has_cmdline() const { return at<2>().valid(); } + ::protozero::ConstChars cmdline() const { return at<2>().as_string(); } + bool has_i_size() const { return at<3>().valid(); } + int64_t i_size() const { return at<3>().as_int64(); } + bool has_ino() const { return at<4>().valid(); } + uint64_t ino() const { return at<4>().as_uint64(); } + bool has_offset() const { return at<5>().valid(); } + int64_t offset() const { return at<5>().as_int64(); } + bool has_pathbuf() const { return at<6>().valid(); } + ::protozero::ConstChars pathbuf() const { return at<6>().as_string(); } + bool has_pid() const { return at<7>().valid(); } + int32_t pid() const { return at<7>().as_int32(); } +}; + +class AndroidFsDatareadStartFtraceEvent : public ::protozero::Message { + public: + using Decoder = AndroidFsDatareadStartFtraceEvent_Decoder; + enum : int32_t { + kBytesFieldNumber = 1, + kCmdlineFieldNumber = 2, + kISizeFieldNumber = 3, + kInoFieldNumber = 4, + kOffsetFieldNumber = 5, + kPathbufFieldNumber = 6, + kPidFieldNumber = 7, + }; + static constexpr const char* GetName() { return ".perfetto.protos.AndroidFsDatareadStartFtraceEvent"; } + + + using FieldMetadata_Bytes = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + AndroidFsDatareadStartFtraceEvent>; + + static constexpr FieldMetadata_Bytes kBytes{}; + void set_bytes(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Bytes::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Cmdline = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + AndroidFsDatareadStartFtraceEvent>; + + static constexpr FieldMetadata_Cmdline kCmdline{}; + void set_cmdline(const char* data, size_t size) { + AppendBytes(FieldMetadata_Cmdline::kFieldId, data, size); + } + void set_cmdline(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Cmdline::kFieldId, chars.data, chars.size); + } + void set_cmdline(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Cmdline::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ISize = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + AndroidFsDatareadStartFtraceEvent>; + + static constexpr FieldMetadata_ISize kISize{}; + void set_i_size(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_ISize::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + AndroidFsDatareadStartFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Offset = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + AndroidFsDatareadStartFtraceEvent>; + + static constexpr FieldMetadata_Offset kOffset{}; + void set_offset(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Offset::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pathbuf = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + AndroidFsDatareadStartFtraceEvent>; + + static constexpr FieldMetadata_Pathbuf kPathbuf{}; + void set_pathbuf(const char* data, size_t size) { + AppendBytes(FieldMetadata_Pathbuf::kFieldId, data, size); + } + void set_pathbuf(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Pathbuf::kFieldId, chars.data, chars.size); + } + void set_pathbuf(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Pathbuf::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pid = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + AndroidFsDatareadStartFtraceEvent>; + + static constexpr FieldMetadata_Pid kPid{}; + void set_pid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class AndroidFsDatareadEndFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + AndroidFsDatareadEndFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit AndroidFsDatareadEndFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit AndroidFsDatareadEndFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_bytes() const { return at<1>().valid(); } + int32_t bytes() const { return at<1>().as_int32(); } + bool has_ino() const { return at<2>().valid(); } + uint64_t ino() const { return at<2>().as_uint64(); } + bool has_offset() const { return at<3>().valid(); } + int64_t offset() const { return at<3>().as_int64(); } +}; + +class AndroidFsDatareadEndFtraceEvent : public ::protozero::Message { + public: + using Decoder = AndroidFsDatareadEndFtraceEvent_Decoder; + enum : int32_t { + kBytesFieldNumber = 1, + kInoFieldNumber = 2, + kOffsetFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.AndroidFsDatareadEndFtraceEvent"; } + + + using FieldMetadata_Bytes = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + AndroidFsDatareadEndFtraceEvent>; + + static constexpr FieldMetadata_Bytes kBytes{}; + void set_bytes(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Bytes::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ino = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + AndroidFsDatareadEndFtraceEvent>; + + static constexpr FieldMetadata_Ino kIno{}; + void set_ino(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Ino::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Offset = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + AndroidFsDatareadEndFtraceEvent>; + + static constexpr FieldMetadata_Offset kOffset{}; + void set_offset(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Offset::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } +}; + +class InodeFileMap_Decoder : public ::protozero::TypedProtoDecoder { + public: + InodeFileMap_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit InodeFileMap_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit InodeFileMap_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_block_device_id() const { return at<1>().valid(); } + uint64_t block_device_id() const { return at<1>().as_uint64(); } + bool has_mount_points() const { return at<2>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstChars> mount_points() const { return GetRepeated<::protozero::ConstChars>(2); } + bool has_entries() const { return at<3>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> entries() const { return GetRepeated<::protozero::ConstBytes>(3); } +}; + +class InodeFileMap : public ::protozero::Message { + public: + using Decoder = InodeFileMap_Decoder; + enum : int32_t { + kBlockDeviceIdFieldNumber = 1, + kMountPointsFieldNumber = 2, + kEntriesFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.InodeFileMap"; } + + using Entry = ::perfetto::protos::pbzero::InodeFileMap_Entry; + + using FieldMetadata_BlockDeviceId = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + InodeFileMap>; + + static constexpr FieldMetadata_BlockDeviceId kBlockDeviceId{}; + void set_block_device_id(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_BlockDeviceId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_MountPoints = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + InodeFileMap>; + + static constexpr FieldMetadata_MountPoints kMountPoints{}; + void add_mount_points(const char* data, size_t size) { + AppendBytes(FieldMetadata_MountPoints::kFieldId, data, size); + } + void add_mount_points(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_MountPoints::kFieldId, chars.data, chars.size); + } + void add_mount_points(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_MountPoints::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Entries = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + InodeFileMap_Entry, + InodeFileMap>; + + static constexpr FieldMetadata_Entries kEntries{}; + template T* add_entries() { + return BeginNestedMessage(3); + } + +}; + +class InodeFileMap_Entry_Decoder : public ::protozero::TypedProtoDecoder { + public: + InodeFileMap_Entry_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit InodeFileMap_Entry_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit InodeFileMap_Entry_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_inode_number() const { return at<1>().valid(); } + uint64_t inode_number() const { return at<1>().as_uint64(); } + bool has_paths() const { return at<2>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstChars> paths() const { return GetRepeated<::protozero::ConstChars>(2); } + bool has_type() const { return at<3>().valid(); } + int32_t type() const { return at<3>().as_int32(); } +}; + +class InodeFileMap_Entry : public ::protozero::Message { + public: + using Decoder = InodeFileMap_Entry_Decoder; + enum : int32_t { + kInodeNumberFieldNumber = 1, + kPathsFieldNumber = 2, + kTypeFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.InodeFileMap.Entry"; } + + + using Type = ::perfetto::protos::pbzero::InodeFileMap_Entry_Type; + static inline const char* Type_Name(Type value) { + return ::perfetto::protos::pbzero::InodeFileMap_Entry_Type_Name(value); + } + static inline const Type UNKNOWN = Type::UNKNOWN; + static inline const Type FILE = Type::FILE; + static inline const Type DIRECTORY = Type::DIRECTORY; + + using FieldMetadata_InodeNumber = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + InodeFileMap_Entry>; + + static constexpr FieldMetadata_InodeNumber kInodeNumber{}; + void set_inode_number(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_InodeNumber::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Paths = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + InodeFileMap_Entry>; + + static constexpr FieldMetadata_Paths kPaths{}; + void add_paths(const char* data, size_t size) { + AppendBytes(FieldMetadata_Paths::kFieldId, data, size); + } + void add_paths(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Paths::kFieldId, chars.data, chars.size); + } + void add_paths(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Paths::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Type = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + InodeFileMap_Entry_Type, + InodeFileMap_Entry>; + + static constexpr FieldMetadata_Type kType{}; + void set_type(InodeFileMap_Entry_Type value) { + static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } +}; + +class ExtensionDescriptor_Decoder : public ::protozero::TypedProtoDecoder { + public: + ExtensionDescriptor_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ExtensionDescriptor_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ExtensionDescriptor_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_extension_set() const { return at<1>().valid(); } + ::protozero::ConstBytes extension_set() const { return at<1>().as_bytes(); } +}; + +class ExtensionDescriptor : public ::protozero::Message { + public: + using Decoder = ExtensionDescriptor_Decoder; + enum : int32_t { + kExtensionSetFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ExtensionDescriptor"; } + + + using FieldMetadata_ExtensionSet = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + FileDescriptorSet, + ExtensionDescriptor>; + + static constexpr FieldMetadata_ExtensionSet kExtensionSet{}; + template T* set_extension_set() { + return BeginNestedMessage(1); + } + +}; + +class OneofOptions_Decoder : public ::protozero::TypedProtoDecoder { + public: + OneofOptions_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit OneofOptions_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit OneofOptions_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} +}; + +class OneofOptions : public ::protozero::Message { + public: + using Decoder = OneofOptions_Decoder; + static constexpr const char* GetName() { return ".perfetto.protos.OneofOptions"; } + +}; + +class EnumValueDescriptorProto_Decoder : public ::protozero::TypedProtoDecoder { + public: + EnumValueDescriptorProto_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit EnumValueDescriptorProto_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit EnumValueDescriptorProto_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_name() const { return at<1>().valid(); } + ::protozero::ConstChars name() const { return at<1>().as_string(); } + bool has_number() const { return at<2>().valid(); } + int32_t number() const { return at<2>().as_int32(); } +}; + +class EnumValueDescriptorProto : public ::protozero::Message { + public: + using Decoder = EnumValueDescriptorProto_Decoder; + enum : int32_t { + kNameFieldNumber = 1, + kNumberFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.EnumValueDescriptorProto"; } + + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + EnumValueDescriptorProto>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Number = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + EnumValueDescriptorProto>; + + static constexpr FieldMetadata_Number kNumber{}; + void set_number(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Number::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class EnumDescriptorProto_Decoder : public ::protozero::TypedProtoDecoder { + public: + EnumDescriptorProto_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit EnumDescriptorProto_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit EnumDescriptorProto_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_name() const { return at<1>().valid(); } + ::protozero::ConstChars name() const { return at<1>().as_string(); } + bool has_value() const { return at<2>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> value() const { return GetRepeated<::protozero::ConstBytes>(2); } + bool has_reserved_name() const { return at<5>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstChars> reserved_name() const { return GetRepeated<::protozero::ConstChars>(5); } +}; + +class EnumDescriptorProto : public ::protozero::Message { + public: + using Decoder = EnumDescriptorProto_Decoder; + enum : int32_t { + kNameFieldNumber = 1, + kValueFieldNumber = 2, + kReservedNameFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.EnumDescriptorProto"; } + + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + EnumDescriptorProto>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Value = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + EnumValueDescriptorProto, + EnumDescriptorProto>; + + static constexpr FieldMetadata_Value kValue{}; + template T* add_value() { + return BeginNestedMessage(2); + } + + + using FieldMetadata_ReservedName = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + EnumDescriptorProto>; + + static constexpr FieldMetadata_ReservedName kReservedName{}; + void add_reserved_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_ReservedName::kFieldId, data, size); + } + void add_reserved_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_ReservedName::kFieldId, chars.data, chars.size); + } + void add_reserved_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_ReservedName::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class OneofDescriptorProto_Decoder : public ::protozero::TypedProtoDecoder { + public: + OneofDescriptorProto_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit OneofDescriptorProto_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit OneofDescriptorProto_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_name() const { return at<1>().valid(); } + ::protozero::ConstChars name() const { return at<1>().as_string(); } + bool has_options() const { return at<2>().valid(); } + ::protozero::ConstBytes options() const { return at<2>().as_bytes(); } +}; + +class OneofDescriptorProto : public ::protozero::Message { + public: + using Decoder = OneofDescriptorProto_Decoder; + enum : int32_t { + kNameFieldNumber = 1, + kOptionsFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.OneofDescriptorProto"; } + + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + OneofDescriptorProto>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Options = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + OneofOptions, + OneofDescriptorProto>; + + static constexpr FieldMetadata_Options kOptions{}; + template T* set_options() { + return BeginNestedMessage(2); + } + +}; + +class FieldDescriptorProto_Decoder : public ::protozero::TypedProtoDecoder { + public: + FieldDescriptorProto_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit FieldDescriptorProto_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit FieldDescriptorProto_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_name() const { return at<1>().valid(); } + ::protozero::ConstChars name() const { return at<1>().as_string(); } + bool has_number() const { return at<3>().valid(); } + int32_t number() const { return at<3>().as_int32(); } + bool has_label() const { return at<4>().valid(); } + int32_t label() const { return at<4>().as_int32(); } + bool has_type() const { return at<5>().valid(); } + int32_t type() const { return at<5>().as_int32(); } + bool has_type_name() const { return at<6>().valid(); } + ::protozero::ConstChars type_name() const { return at<6>().as_string(); } + bool has_extendee() const { return at<2>().valid(); } + ::protozero::ConstChars extendee() const { return at<2>().as_string(); } + bool has_default_value() const { return at<7>().valid(); } + ::protozero::ConstChars default_value() const { return at<7>().as_string(); } + bool has_options() const { return at<8>().valid(); } + ::protozero::ConstBytes options() const { return at<8>().as_bytes(); } + bool has_oneof_index() const { return at<9>().valid(); } + int32_t oneof_index() const { return at<9>().as_int32(); } +}; + +class FieldDescriptorProto : public ::protozero::Message { + public: + using Decoder = FieldDescriptorProto_Decoder; + enum : int32_t { + kNameFieldNumber = 1, + kNumberFieldNumber = 3, + kLabelFieldNumber = 4, + kTypeFieldNumber = 5, + kTypeNameFieldNumber = 6, + kExtendeeFieldNumber = 2, + kDefaultValueFieldNumber = 7, + kOptionsFieldNumber = 8, + kOneofIndexFieldNumber = 9, + }; + static constexpr const char* GetName() { return ".perfetto.protos.FieldDescriptorProto"; } + + + using Type = ::perfetto::protos::pbzero::FieldDescriptorProto_Type; + static inline const char* Type_Name(Type value) { + return ::perfetto::protos::pbzero::FieldDescriptorProto_Type_Name(value); + } + + using Label = ::perfetto::protos::pbzero::FieldDescriptorProto_Label; + static inline const char* Label_Name(Label value) { + return ::perfetto::protos::pbzero::FieldDescriptorProto_Label_Name(value); + } + static inline const Type TYPE_DOUBLE = Type::TYPE_DOUBLE; + static inline const Type TYPE_FLOAT = Type::TYPE_FLOAT; + static inline const Type TYPE_INT64 = Type::TYPE_INT64; + static inline const Type TYPE_UINT64 = Type::TYPE_UINT64; + static inline const Type TYPE_INT32 = Type::TYPE_INT32; + static inline const Type TYPE_FIXED64 = Type::TYPE_FIXED64; + static inline const Type TYPE_FIXED32 = Type::TYPE_FIXED32; + static inline const Type TYPE_BOOL = Type::TYPE_BOOL; + static inline const Type TYPE_STRING = Type::TYPE_STRING; + static inline const Type TYPE_GROUP = Type::TYPE_GROUP; + static inline const Type TYPE_MESSAGE = Type::TYPE_MESSAGE; + static inline const Type TYPE_BYTES = Type::TYPE_BYTES; + static inline const Type TYPE_UINT32 = Type::TYPE_UINT32; + static inline const Type TYPE_ENUM = Type::TYPE_ENUM; + static inline const Type TYPE_SFIXED32 = Type::TYPE_SFIXED32; + static inline const Type TYPE_SFIXED64 = Type::TYPE_SFIXED64; + static inline const Type TYPE_SINT32 = Type::TYPE_SINT32; + static inline const Type TYPE_SINT64 = Type::TYPE_SINT64; + static inline const Label LABEL_OPTIONAL = Label::LABEL_OPTIONAL; + static inline const Label LABEL_REQUIRED = Label::LABEL_REQUIRED; + static inline const Label LABEL_REPEATED = Label::LABEL_REPEATED; + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + FieldDescriptorProto>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Number = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + FieldDescriptorProto>; + + static constexpr FieldMetadata_Number kNumber{}; + void set_number(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Number::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Label = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + FieldDescriptorProto_Label, + FieldDescriptorProto>; + + static constexpr FieldMetadata_Label kLabel{}; + void set_label(FieldDescriptorProto_Label value) { + static constexpr uint32_t field_id = FieldMetadata_Label::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Type = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + FieldDescriptorProto_Type, + FieldDescriptorProto>; + + static constexpr FieldMetadata_Type kType{}; + void set_type(FieldDescriptorProto_Type value) { + static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TypeName = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + FieldDescriptorProto>; + + static constexpr FieldMetadata_TypeName kTypeName{}; + void set_type_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_TypeName::kFieldId, data, size); + } + void set_type_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_TypeName::kFieldId, chars.data, chars.size); + } + void set_type_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_TypeName::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Extendee = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + FieldDescriptorProto>; + + static constexpr FieldMetadata_Extendee kExtendee{}; + void set_extendee(const char* data, size_t size) { + AppendBytes(FieldMetadata_Extendee::kFieldId, data, size); + } + void set_extendee(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Extendee::kFieldId, chars.data, chars.size); + } + void set_extendee(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Extendee::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DefaultValue = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + FieldDescriptorProto>; + + static constexpr FieldMetadata_DefaultValue kDefaultValue{}; + void set_default_value(const char* data, size_t size) { + AppendBytes(FieldMetadata_DefaultValue::kFieldId, data, size); + } + void set_default_value(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_DefaultValue::kFieldId, chars.data, chars.size); + } + void set_default_value(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_DefaultValue::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Options = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + FieldOptions, + FieldDescriptorProto>; + + static constexpr FieldMetadata_Options kOptions{}; + template T* set_options() { + return BeginNestedMessage(8); + } + + + using FieldMetadata_OneofIndex = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + FieldDescriptorProto>; + + static constexpr FieldMetadata_OneofIndex kOneofIndex{}; + void set_oneof_index(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_OneofIndex::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class FieldOptions_Decoder : public ::protozero::TypedProtoDecoder { + public: + FieldOptions_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit FieldOptions_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit FieldOptions_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_packed() const { return at<2>().valid(); } + bool packed() const { return at<2>().as_bool(); } + bool has_uninterpreted_option() const { return at<999>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> uninterpreted_option() const { return GetRepeated<::protozero::ConstBytes>(999); } +}; + +class FieldOptions : public ::protozero::Message { + public: + using Decoder = FieldOptions_Decoder; + enum : int32_t { + kPackedFieldNumber = 2, + kUninterpretedOptionFieldNumber = 999, + }; + static constexpr const char* GetName() { return ".perfetto.protos.FieldOptions"; } + + + using FieldMetadata_Packed = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + FieldOptions>; + + static constexpr FieldMetadata_Packed kPacked{}; + void set_packed(bool value) { + static constexpr uint32_t field_id = FieldMetadata_Packed::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_UninterpretedOption = + ::protozero::proto_utils::FieldMetadata< + 999, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + UninterpretedOption, + FieldOptions>; + + static constexpr FieldMetadata_UninterpretedOption kUninterpretedOption{}; + template T* add_uninterpreted_option() { + return BeginNestedMessage(999); + } + +}; + +class UninterpretedOption_Decoder : public ::protozero::TypedProtoDecoder { + public: + UninterpretedOption_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit UninterpretedOption_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit UninterpretedOption_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_name() const { return at<2>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> name() const { return GetRepeated<::protozero::ConstBytes>(2); } + bool has_identifier_value() const { return at<3>().valid(); } + ::protozero::ConstChars identifier_value() const { return at<3>().as_string(); } + bool has_positive_int_value() const { return at<4>().valid(); } + uint64_t positive_int_value() const { return at<4>().as_uint64(); } + bool has_negative_int_value() const { return at<5>().valid(); } + int64_t negative_int_value() const { return at<5>().as_int64(); } + bool has_double_value() const { return at<6>().valid(); } + double double_value() const { return at<6>().as_double(); } + bool has_string_value() const { return at<7>().valid(); } + ::protozero::ConstBytes string_value() const { return at<7>().as_bytes(); } + bool has_aggregate_value() const { return at<8>().valid(); } + ::protozero::ConstChars aggregate_value() const { return at<8>().as_string(); } +}; + +class UninterpretedOption : public ::protozero::Message { + public: + using Decoder = UninterpretedOption_Decoder; + enum : int32_t { + kNameFieldNumber = 2, + kIdentifierValueFieldNumber = 3, + kPositiveIntValueFieldNumber = 4, + kNegativeIntValueFieldNumber = 5, + kDoubleValueFieldNumber = 6, + kStringValueFieldNumber = 7, + kAggregateValueFieldNumber = 8, + }; + static constexpr const char* GetName() { return ".perfetto.protos.UninterpretedOption"; } + + using NamePart = ::perfetto::protos::pbzero::UninterpretedOption_NamePart; + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + UninterpretedOption_NamePart, + UninterpretedOption>; + + static constexpr FieldMetadata_Name kName{}; + template T* add_name() { + return BeginNestedMessage(2); + } + + + using FieldMetadata_IdentifierValue = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + UninterpretedOption>; + + static constexpr FieldMetadata_IdentifierValue kIdentifierValue{}; + void set_identifier_value(const char* data, size_t size) { + AppendBytes(FieldMetadata_IdentifierValue::kFieldId, data, size); + } + void set_identifier_value(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_IdentifierValue::kFieldId, chars.data, chars.size); + } + void set_identifier_value(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_IdentifierValue::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PositiveIntValue = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + UninterpretedOption>; + + static constexpr FieldMetadata_PositiveIntValue kPositiveIntValue{}; + void set_positive_int_value(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_PositiveIntValue::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NegativeIntValue = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + UninterpretedOption>; + + static constexpr FieldMetadata_NegativeIntValue kNegativeIntValue{}; + void set_negative_int_value(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_NegativeIntValue::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DoubleValue = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kDouble, + double, + UninterpretedOption>; + + static constexpr FieldMetadata_DoubleValue kDoubleValue{}; + void set_double_value(double value) { + static constexpr uint32_t field_id = FieldMetadata_DoubleValue::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kDouble> + ::Append(*this, field_id, value); + } + + using FieldMetadata_StringValue = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBytes, + std::string, + UninterpretedOption>; + + static constexpr FieldMetadata_StringValue kStringValue{}; + void set_string_value(const uint8_t* data, size_t size) { + AppendBytes(FieldMetadata_StringValue::kFieldId, data, size); + } + void set_string_value(::protozero::ConstBytes bytes) { + AppendBytes(FieldMetadata_StringValue::kFieldId, bytes.data, bytes.size); + } + void set_string_value(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_StringValue::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBytes> + ::Append(*this, field_id, value); + } + + using FieldMetadata_AggregateValue = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + UninterpretedOption>; + + static constexpr FieldMetadata_AggregateValue kAggregateValue{}; + void set_aggregate_value(const char* data, size_t size) { + AppendBytes(FieldMetadata_AggregateValue::kFieldId, data, size); + } + void set_aggregate_value(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_AggregateValue::kFieldId, chars.data, chars.size); + } + void set_aggregate_value(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_AggregateValue::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class UninterpretedOption_NamePart_Decoder : public ::protozero::TypedProtoDecoder { + public: + UninterpretedOption_NamePart_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit UninterpretedOption_NamePart_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit UninterpretedOption_NamePart_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_name_part() const { return at<1>().valid(); } + ::protozero::ConstChars name_part() const { return at<1>().as_string(); } + bool has_is_extension() const { return at<2>().valid(); } + bool is_extension() const { return at<2>().as_bool(); } +}; + +class UninterpretedOption_NamePart : public ::protozero::Message { + public: + using Decoder = UninterpretedOption_NamePart_Decoder; + enum : int32_t { + kNamePartFieldNumber = 1, + kIsExtensionFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.UninterpretedOption.NamePart"; } + + + using FieldMetadata_NamePart = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + UninterpretedOption_NamePart>; + + static constexpr FieldMetadata_NamePart kNamePart{}; + void set_name_part(const char* data, size_t size) { + AppendBytes(FieldMetadata_NamePart::kFieldId, data, size); + } + void set_name_part(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_NamePart::kFieldId, chars.data, chars.size); + } + void set_name_part(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_NamePart::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_IsExtension = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + UninterpretedOption_NamePart>; + + static constexpr FieldMetadata_IsExtension kIsExtension{}; + void set_is_extension(bool value) { + static constexpr uint32_t field_id = FieldMetadata_IsExtension::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } +}; + +class DescriptorProto_Decoder : public ::protozero::TypedProtoDecoder { + public: + DescriptorProto_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit DescriptorProto_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit DescriptorProto_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_name() const { return at<1>().valid(); } + ::protozero::ConstChars name() const { return at<1>().as_string(); } + bool has_field() const { return at<2>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> field() const { return GetRepeated<::protozero::ConstBytes>(2); } + bool has_extension() const { return at<6>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> extension() const { return GetRepeated<::protozero::ConstBytes>(6); } + bool has_nested_type() const { return at<3>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> nested_type() const { return GetRepeated<::protozero::ConstBytes>(3); } + bool has_enum_type() const { return at<4>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> enum_type() const { return GetRepeated<::protozero::ConstBytes>(4); } + bool has_oneof_decl() const { return at<8>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> oneof_decl() const { return GetRepeated<::protozero::ConstBytes>(8); } + bool has_reserved_range() const { return at<9>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> reserved_range() const { return GetRepeated<::protozero::ConstBytes>(9); } + bool has_reserved_name() const { return at<10>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstChars> reserved_name() const { return GetRepeated<::protozero::ConstChars>(10); } +}; + +class DescriptorProto : public ::protozero::Message { + public: + using Decoder = DescriptorProto_Decoder; + enum : int32_t { + kNameFieldNumber = 1, + kFieldFieldNumber = 2, + kExtensionFieldNumber = 6, + kNestedTypeFieldNumber = 3, + kEnumTypeFieldNumber = 4, + kOneofDeclFieldNumber = 8, + kReservedRangeFieldNumber = 9, + kReservedNameFieldNumber = 10, + }; + static constexpr const char* GetName() { return ".perfetto.protos.DescriptorProto"; } + + using ReservedRange = ::perfetto::protos::pbzero::DescriptorProto_ReservedRange; + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + DescriptorProto>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Field = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + FieldDescriptorProto, + DescriptorProto>; + + static constexpr FieldMetadata_Field kField{}; + template T* add_field() { + return BeginNestedMessage(2); + } + + + using FieldMetadata_Extension = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + FieldDescriptorProto, + DescriptorProto>; + + static constexpr FieldMetadata_Extension kExtension{}; + template T* add_extension() { + return BeginNestedMessage(6); + } + + + using FieldMetadata_NestedType = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + DescriptorProto, + DescriptorProto>; + + static constexpr FieldMetadata_NestedType kNestedType{}; + template T* add_nested_type() { + return BeginNestedMessage(3); + } + + + using FieldMetadata_EnumType = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + EnumDescriptorProto, + DescriptorProto>; + + static constexpr FieldMetadata_EnumType kEnumType{}; + template T* add_enum_type() { + return BeginNestedMessage(4); + } + + + using FieldMetadata_OneofDecl = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + OneofDescriptorProto, + DescriptorProto>; + + static constexpr FieldMetadata_OneofDecl kOneofDecl{}; + template T* add_oneof_decl() { + return BeginNestedMessage(8); + } + + + using FieldMetadata_ReservedRange = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + DescriptorProto_ReservedRange, + DescriptorProto>; + + static constexpr FieldMetadata_ReservedRange kReservedRange{}; + template T* add_reserved_range() { + return BeginNestedMessage(9); + } + + + using FieldMetadata_ReservedName = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + DescriptorProto>; + + static constexpr FieldMetadata_ReservedName kReservedName{}; + void add_reserved_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_ReservedName::kFieldId, data, size); + } + void add_reserved_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_ReservedName::kFieldId, chars.data, chars.size); + } + void add_reserved_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_ReservedName::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class DescriptorProto_ReservedRange_Decoder : public ::protozero::TypedProtoDecoder { + public: + DescriptorProto_ReservedRange_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit DescriptorProto_ReservedRange_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit DescriptorProto_ReservedRange_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_start() const { return at<1>().valid(); } + int32_t start() const { return at<1>().as_int32(); } + bool has_end() const { return at<2>().valid(); } + int32_t end() const { return at<2>().as_int32(); } +}; + +class DescriptorProto_ReservedRange : public ::protozero::Message { + public: + using Decoder = DescriptorProto_ReservedRange_Decoder; + enum : int32_t { + kStartFieldNumber = 1, + kEndFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.DescriptorProto.ReservedRange"; } + + + using FieldMetadata_Start = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + DescriptorProto_ReservedRange>; + + static constexpr FieldMetadata_Start kStart{}; + void set_start(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Start::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_End = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + DescriptorProto_ReservedRange>; + + static constexpr FieldMetadata_End kEnd{}; + void set_end(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_End::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class FileDescriptorProto_Decoder : public ::protozero::TypedProtoDecoder { + public: + FileDescriptorProto_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit FileDescriptorProto_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit FileDescriptorProto_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_name() const { return at<1>().valid(); } + ::protozero::ConstChars name() const { return at<1>().as_string(); } + bool has_package() const { return at<2>().valid(); } + ::protozero::ConstChars package() const { return at<2>().as_string(); } + bool has_dependency() const { return at<3>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstChars> dependency() const { return GetRepeated<::protozero::ConstChars>(3); } + bool has_public_dependency() const { return at<10>().valid(); } + ::protozero::RepeatedFieldIterator public_dependency() const { return GetRepeated(10); } + bool has_weak_dependency() const { return at<11>().valid(); } + ::protozero::RepeatedFieldIterator weak_dependency() const { return GetRepeated(11); } + bool has_message_type() const { return at<4>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> message_type() const { return GetRepeated<::protozero::ConstBytes>(4); } + bool has_enum_type() const { return at<5>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> enum_type() const { return GetRepeated<::protozero::ConstBytes>(5); } + bool has_extension() const { return at<7>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> extension() const { return GetRepeated<::protozero::ConstBytes>(7); } +}; + +class FileDescriptorProto : public ::protozero::Message { + public: + using Decoder = FileDescriptorProto_Decoder; + enum : int32_t { + kNameFieldNumber = 1, + kPackageFieldNumber = 2, + kDependencyFieldNumber = 3, + kPublicDependencyFieldNumber = 10, + kWeakDependencyFieldNumber = 11, + kMessageTypeFieldNumber = 4, + kEnumTypeFieldNumber = 5, + kExtensionFieldNumber = 7, + }; + static constexpr const char* GetName() { return ".perfetto.protos.FileDescriptorProto"; } + + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + FileDescriptorProto>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Package = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + FileDescriptorProto>; + + static constexpr FieldMetadata_Package kPackage{}; + void set_package(const char* data, size_t size) { + AppendBytes(FieldMetadata_Package::kFieldId, data, size); + } + void set_package(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Package::kFieldId, chars.data, chars.size); + } + void set_package(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Package::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Dependency = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + FileDescriptorProto>; + + static constexpr FieldMetadata_Dependency kDependency{}; + void add_dependency(const char* data, size_t size) { + AppendBytes(FieldMetadata_Dependency::kFieldId, data, size); + } + void add_dependency(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Dependency::kFieldId, chars.data, chars.size); + } + void add_dependency(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Dependency::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PublicDependency = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + FileDescriptorProto>; + + static constexpr FieldMetadata_PublicDependency kPublicDependency{}; + void add_public_dependency(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_PublicDependency::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_WeakDependency = + ::protozero::proto_utils::FieldMetadata< + 11, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + FileDescriptorProto>; + + static constexpr FieldMetadata_WeakDependency kWeakDependency{}; + void add_weak_dependency(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_WeakDependency::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_MessageType = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + DescriptorProto, + FileDescriptorProto>; + + static constexpr FieldMetadata_MessageType kMessageType{}; + template T* add_message_type() { + return BeginNestedMessage(4); + } + + + using FieldMetadata_EnumType = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + EnumDescriptorProto, + FileDescriptorProto>; + + static constexpr FieldMetadata_EnumType kEnumType{}; + template T* add_enum_type() { + return BeginNestedMessage(5); + } + + + using FieldMetadata_Extension = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + FieldDescriptorProto, + FileDescriptorProto>; + + static constexpr FieldMetadata_Extension kExtension{}; + template T* add_extension() { + return BeginNestedMessage(7); + } + +}; + +class FileDescriptorSet_Decoder : public ::protozero::TypedProtoDecoder { + public: + FileDescriptorSet_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit FileDescriptorSet_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit FileDescriptorSet_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_file() const { return at<1>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> file() const { return GetRepeated<::protozero::ConstBytes>(1); } +}; + +class FileDescriptorSet : public ::protozero::Message { + public: + using Decoder = FileDescriptorSet_Decoder; + enum : int32_t { + kFileFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.FileDescriptorSet"; } + + + using FieldMetadata_File = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + FileDescriptorProto, + FileDescriptorSet>; + + static constexpr FieldMetadata_File kFile{}; + template T* add_file() { + return BeginNestedMessage(1); + } + +}; + +class EtwTraceEventBundle_Decoder : public ::protozero::TypedProtoDecoder { + public: + EtwTraceEventBundle_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit EtwTraceEventBundle_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit EtwTraceEventBundle_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_cpu() const { return at<1>().valid(); } + uint32_t cpu() const { return at<1>().as_uint32(); } + bool has_event() const { return at<2>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> event() const { return GetRepeated<::protozero::ConstBytes>(2); } +}; + +class EtwTraceEventBundle : public ::protozero::Message { + public: + using Decoder = EtwTraceEventBundle_Decoder; + enum : int32_t { + kCpuFieldNumber = 1, + kEventFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.EtwTraceEventBundle"; } + + + using FieldMetadata_Cpu = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + EtwTraceEventBundle>; + + static constexpr FieldMetadata_Cpu kCpu{}; + void set_cpu(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Cpu::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Event = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + EtwTraceEvent, + EtwTraceEventBundle>; + + static constexpr FieldMetadata_Event kEvent{}; + template T* add_event() { + return BeginNestedMessage(2); + } + +}; + +class EtwTraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + EtwTraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit EtwTraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit EtwTraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_timestamp() const { return at<1>().valid(); } + uint64_t timestamp() const { return at<1>().as_uint64(); } + bool has_cpu() const { return at<4>().valid(); } + uint32_t cpu() const { return at<4>().as_uint32(); } + bool has_c_switch() const { return at<2>().valid(); } + ::protozero::ConstBytes c_switch() const { return at<2>().as_bytes(); } + bool has_ready_thread() const { return at<3>().valid(); } + ::protozero::ConstBytes ready_thread() const { return at<3>().as_bytes(); } +}; + +class EtwTraceEvent : public ::protozero::Message { + public: + using Decoder = EtwTraceEvent_Decoder; + enum : int32_t { + kTimestampFieldNumber = 1, + kCpuFieldNumber = 4, + kCSwitchFieldNumber = 2, + kReadyThreadFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.EtwTraceEvent"; } + + + using FieldMetadata_Timestamp = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + EtwTraceEvent>; + + static constexpr FieldMetadata_Timestamp kTimestamp{}; + void set_timestamp(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Timestamp::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Cpu = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + EtwTraceEvent>; + + static constexpr FieldMetadata_Cpu kCpu{}; + void set_cpu(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Cpu::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CSwitch = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + CSwitchEtwEvent, + EtwTraceEvent>; + + static constexpr FieldMetadata_CSwitch kCSwitch{}; + template T* set_c_switch() { + return BeginNestedMessage(2); + } + + + using FieldMetadata_ReadyThread = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ReadyThreadEtwEvent, + EtwTraceEvent>; + + static constexpr FieldMetadata_ReadyThread kReadyThread{}; + template T* set_ready_thread() { + return BeginNestedMessage(3); + } + +}; + +class ReadyThreadEtwEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + ReadyThreadEtwEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ReadyThreadEtwEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ReadyThreadEtwEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_t_thread_id() const { return at<1>().valid(); } + uint32_t t_thread_id() const { return at<1>().as_uint32(); } + bool has_adjust_reason() const { return at<2>().valid(); } + int32_t adjust_reason() const { return at<2>().as_int32(); } + bool has_adjust_increment() const { return at<3>().valid(); } + int32_t adjust_increment() const { return at<3>().as_sint32(); } + bool has_flag() const { return at<4>().valid(); } + int32_t flag() const { return at<4>().as_int32(); } +}; + +class ReadyThreadEtwEvent : public ::protozero::Message { + public: + using Decoder = ReadyThreadEtwEvent_Decoder; + enum : int32_t { + kTThreadIdFieldNumber = 1, + kAdjustReasonFieldNumber = 2, + kAdjustIncrementFieldNumber = 3, + kFlagFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ReadyThreadEtwEvent"; } + + + using AdjustReason = ::perfetto::protos::pbzero::ReadyThreadEtwEvent_AdjustReason; + static inline const char* AdjustReason_Name(AdjustReason value) { + return ::perfetto::protos::pbzero::ReadyThreadEtwEvent_AdjustReason_Name(value); + } + + using TraceFlag = ::perfetto::protos::pbzero::ReadyThreadEtwEvent_TraceFlag; + static inline const char* TraceFlag_Name(TraceFlag value) { + return ::perfetto::protos::pbzero::ReadyThreadEtwEvent_TraceFlag_Name(value); + } + static inline const AdjustReason IGNORE_THE_INCREMENT = AdjustReason::IGNORE_THE_INCREMENT; + static inline const AdjustReason APPLY_INCREMENT = AdjustReason::APPLY_INCREMENT; + static inline const AdjustReason APPLY_INCREMENT_BOOST = AdjustReason::APPLY_INCREMENT_BOOST; + static inline const TraceFlag TRACE_FLAG_UNSPECIFIED = TraceFlag::TRACE_FLAG_UNSPECIFIED; + static inline const TraceFlag THREAD_READIED = TraceFlag::THREAD_READIED; + static inline const TraceFlag KERNEL_STACK_SWAPPED_OUT = TraceFlag::KERNEL_STACK_SWAPPED_OUT; + static inline const TraceFlag PROCESS_ADDRESS_SWAPPED_OUT = TraceFlag::PROCESS_ADDRESS_SWAPPED_OUT; + + using FieldMetadata_TThreadId = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + ReadyThreadEtwEvent>; + + static constexpr FieldMetadata_TThreadId kTThreadId{}; + void set_t_thread_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TThreadId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_AdjustReason = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + ReadyThreadEtwEvent_AdjustReason, + ReadyThreadEtwEvent>; + + static constexpr FieldMetadata_AdjustReason kAdjustReason{}; + void set_adjust_reason(ReadyThreadEtwEvent_AdjustReason value) { + static constexpr uint32_t field_id = FieldMetadata_AdjustReason::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_AdjustIncrement = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kSint32, + int32_t, + ReadyThreadEtwEvent>; + + static constexpr FieldMetadata_AdjustIncrement kAdjustIncrement{}; + void set_adjust_increment(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_AdjustIncrement::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kSint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Flag = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + ReadyThreadEtwEvent_TraceFlag, + ReadyThreadEtwEvent>; + + static constexpr FieldMetadata_Flag kFlag{}; + void set_flag(ReadyThreadEtwEvent_TraceFlag value) { + static constexpr uint32_t field_id = FieldMetadata_Flag::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } +}; + +class CSwitchEtwEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + CSwitchEtwEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit CSwitchEtwEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit CSwitchEtwEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_new_thread_id() const { return at<1>().valid(); } + uint32_t new_thread_id() const { return at<1>().as_uint32(); } + bool has_old_thread_id() const { return at<2>().valid(); } + uint32_t old_thread_id() const { return at<2>().as_uint32(); } + bool has_new_thread_priority() const { return at<3>().valid(); } + int32_t new_thread_priority() const { return at<3>().as_sint32(); } + bool has_old_thread_priority() const { return at<4>().valid(); } + int32_t old_thread_priority() const { return at<4>().as_sint32(); } + bool has_previous_c_state() const { return at<5>().valid(); } + uint32_t previous_c_state() const { return at<5>().as_uint32(); } + bool has_old_thread_wait_reason() const { return at<6>().valid(); } + int32_t old_thread_wait_reason() const { return at<6>().as_int32(); } + bool has_old_thread_wait_mode() const { return at<7>().valid(); } + int32_t old_thread_wait_mode() const { return at<7>().as_int32(); } + bool has_old_thread_state() const { return at<8>().valid(); } + int32_t old_thread_state() const { return at<8>().as_int32(); } + bool has_old_thread_wait_ideal_processor() const { return at<9>().valid(); } + int32_t old_thread_wait_ideal_processor() const { return at<9>().as_sint32(); } + bool has_new_thread_wait_time() const { return at<10>().valid(); } + uint32_t new_thread_wait_time() const { return at<10>().as_uint32(); } +}; + +class CSwitchEtwEvent : public ::protozero::Message { + public: + using Decoder = CSwitchEtwEvent_Decoder; + enum : int32_t { + kNewThreadIdFieldNumber = 1, + kOldThreadIdFieldNumber = 2, + kNewThreadPriorityFieldNumber = 3, + kOldThreadPriorityFieldNumber = 4, + kPreviousCStateFieldNumber = 5, + kOldThreadWaitReasonFieldNumber = 6, + kOldThreadWaitModeFieldNumber = 7, + kOldThreadStateFieldNumber = 8, + kOldThreadWaitIdealProcessorFieldNumber = 9, + kNewThreadWaitTimeFieldNumber = 10, + }; + static constexpr const char* GetName() { return ".perfetto.protos.CSwitchEtwEvent"; } + + + using OldThreadWaitReason = ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitReason; + static inline const char* OldThreadWaitReason_Name(OldThreadWaitReason value) { + return ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitReason_Name(value); + } + + using OldThreadWaitMode = ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitMode; + static inline const char* OldThreadWaitMode_Name(OldThreadWaitMode value) { + return ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadWaitMode_Name(value); + } + + using OldThreadState = ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadState; + static inline const char* OldThreadState_Name(OldThreadState value) { + return ::perfetto::protos::pbzero::CSwitchEtwEvent_OldThreadState_Name(value); + } + static inline const OldThreadWaitReason EXECUTIVE = OldThreadWaitReason::EXECUTIVE; + static inline const OldThreadWaitReason FREE_PAGE = OldThreadWaitReason::FREE_PAGE; + static inline const OldThreadWaitReason PAGE_IN = OldThreadWaitReason::PAGE_IN; + static inline const OldThreadWaitReason POOL_ALLOCATION = OldThreadWaitReason::POOL_ALLOCATION; + static inline const OldThreadWaitReason DELAY_EXECUTION = OldThreadWaitReason::DELAY_EXECUTION; + static inline const OldThreadWaitReason SUSPEND = OldThreadWaitReason::SUSPEND; + static inline const OldThreadWaitReason USER_REQUEST = OldThreadWaitReason::USER_REQUEST; + static inline const OldThreadWaitReason WR_EXECUTIVE = OldThreadWaitReason::WR_EXECUTIVE; + static inline const OldThreadWaitReason WR_FREE_PAGE = OldThreadWaitReason::WR_FREE_PAGE; + static inline const OldThreadWaitReason WR_PAGE_IN = OldThreadWaitReason::WR_PAGE_IN; + static inline const OldThreadWaitReason WR_POOL_ALLOCATION = OldThreadWaitReason::WR_POOL_ALLOCATION; + static inline const OldThreadWaitReason WR_DELAY_EXECUTION = OldThreadWaitReason::WR_DELAY_EXECUTION; + static inline const OldThreadWaitReason WR_SUSPENDED = OldThreadWaitReason::WR_SUSPENDED; + static inline const OldThreadWaitReason WR_USER_REQUEST = OldThreadWaitReason::WR_USER_REQUEST; + static inline const OldThreadWaitReason WR_EVENT_PAIR = OldThreadWaitReason::WR_EVENT_PAIR; + static inline const OldThreadWaitReason WR_QUEUE = OldThreadWaitReason::WR_QUEUE; + static inline const OldThreadWaitReason WR_LPC_RECEIVER = OldThreadWaitReason::WR_LPC_RECEIVER; + static inline const OldThreadWaitReason WR_LPC_REPLY = OldThreadWaitReason::WR_LPC_REPLY; + static inline const OldThreadWaitReason WR_VIRTUAL_MEMORY = OldThreadWaitReason::WR_VIRTUAL_MEMORY; + static inline const OldThreadWaitReason WR_PAGE_OUT = OldThreadWaitReason::WR_PAGE_OUT; + static inline const OldThreadWaitReason WR_RENDEZ_VOUS = OldThreadWaitReason::WR_RENDEZ_VOUS; + static inline const OldThreadWaitReason WR_KEYED_EVENT = OldThreadWaitReason::WR_KEYED_EVENT; + static inline const OldThreadWaitReason WR_TERMINATED = OldThreadWaitReason::WR_TERMINATED; + static inline const OldThreadWaitReason WR_PROCESS_IN_SWAP = OldThreadWaitReason::WR_PROCESS_IN_SWAP; + static inline const OldThreadWaitReason WR_CPU_RATE_CONTROL = OldThreadWaitReason::WR_CPU_RATE_CONTROL; + static inline const OldThreadWaitReason WR_CALLOUT_STACK = OldThreadWaitReason::WR_CALLOUT_STACK; + static inline const OldThreadWaitReason WR_KERNEL = OldThreadWaitReason::WR_KERNEL; + static inline const OldThreadWaitReason WR_RESOURCE = OldThreadWaitReason::WR_RESOURCE; + static inline const OldThreadWaitReason WR_PUSH_LOCK = OldThreadWaitReason::WR_PUSH_LOCK; + static inline const OldThreadWaitReason WR_MUTEX = OldThreadWaitReason::WR_MUTEX; + static inline const OldThreadWaitReason WR_QUANTUM_END = OldThreadWaitReason::WR_QUANTUM_END; + static inline const OldThreadWaitReason WR_DISPATCH_INT = OldThreadWaitReason::WR_DISPATCH_INT; + static inline const OldThreadWaitReason WR_PREEMPTED = OldThreadWaitReason::WR_PREEMPTED; + static inline const OldThreadWaitReason WR_YIELD_EXECUTION = OldThreadWaitReason::WR_YIELD_EXECUTION; + static inline const OldThreadWaitReason WR_FAST_MUTEX = OldThreadWaitReason::WR_FAST_MUTEX; + static inline const OldThreadWaitReason WR_GUARD_MUTEX = OldThreadWaitReason::WR_GUARD_MUTEX; + static inline const OldThreadWaitReason WR_RUNDOWN = OldThreadWaitReason::WR_RUNDOWN; + static inline const OldThreadWaitReason MAXIMUM_WAIT_REASON = OldThreadWaitReason::MAXIMUM_WAIT_REASON; + static inline const OldThreadWaitMode KERNEL_MODE = OldThreadWaitMode::KERNEL_MODE; + static inline const OldThreadWaitMode USER_MODE = OldThreadWaitMode::USER_MODE; + static inline const OldThreadState INITIALIZED = OldThreadState::INITIALIZED; + static inline const OldThreadState READY = OldThreadState::READY; + static inline const OldThreadState RUNNING = OldThreadState::RUNNING; + static inline const OldThreadState STANDBY = OldThreadState::STANDBY; + static inline const OldThreadState TERMINATED = OldThreadState::TERMINATED; + static inline const OldThreadState WAITING = OldThreadState::WAITING; + static inline const OldThreadState TRANSITION = OldThreadState::TRANSITION; + static inline const OldThreadState DEFERRED_READY = OldThreadState::DEFERRED_READY; + + using FieldMetadata_NewThreadId = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + CSwitchEtwEvent>; + + static constexpr FieldMetadata_NewThreadId kNewThreadId{}; + void set_new_thread_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_NewThreadId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_OldThreadId = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + CSwitchEtwEvent>; + + static constexpr FieldMetadata_OldThreadId kOldThreadId{}; + void set_old_thread_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_OldThreadId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NewThreadPriority = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kSint32, + int32_t, + CSwitchEtwEvent>; + + static constexpr FieldMetadata_NewThreadPriority kNewThreadPriority{}; + void set_new_thread_priority(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_NewThreadPriority::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kSint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_OldThreadPriority = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kSint32, + int32_t, + CSwitchEtwEvent>; + + static constexpr FieldMetadata_OldThreadPriority kOldThreadPriority{}; + void set_old_thread_priority(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_OldThreadPriority::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kSint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PreviousCState = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + CSwitchEtwEvent>; + + static constexpr FieldMetadata_PreviousCState kPreviousCState{}; + void set_previous_c_state(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_PreviousCState::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_OldThreadWaitReason = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + CSwitchEtwEvent_OldThreadWaitReason, + CSwitchEtwEvent>; + + static constexpr FieldMetadata_OldThreadWaitReason kOldThreadWaitReason{}; + void set_old_thread_wait_reason(CSwitchEtwEvent_OldThreadWaitReason value) { + static constexpr uint32_t field_id = FieldMetadata_OldThreadWaitReason::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_OldThreadWaitMode = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + CSwitchEtwEvent_OldThreadWaitMode, + CSwitchEtwEvent>; + + static constexpr FieldMetadata_OldThreadWaitMode kOldThreadWaitMode{}; + void set_old_thread_wait_mode(CSwitchEtwEvent_OldThreadWaitMode value) { + static constexpr uint32_t field_id = FieldMetadata_OldThreadWaitMode::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_OldThreadState = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + CSwitchEtwEvent_OldThreadState, + CSwitchEtwEvent>; + + static constexpr FieldMetadata_OldThreadState kOldThreadState{}; + void set_old_thread_state(CSwitchEtwEvent_OldThreadState value) { + static constexpr uint32_t field_id = FieldMetadata_OldThreadState::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_OldThreadWaitIdealProcessor = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kSint32, + int32_t, + CSwitchEtwEvent>; + + static constexpr FieldMetadata_OldThreadWaitIdealProcessor kOldThreadWaitIdealProcessor{}; + void set_old_thread_wait_ideal_processor(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_OldThreadWaitIdealProcessor::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kSint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NewThreadWaitTime = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + CSwitchEtwEvent>; + + static constexpr FieldMetadata_NewThreadWaitTime kNewThreadWaitTime{}; + void set_new_thread_wait_time(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_NewThreadWaitTime::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class ClockSnapshot_Decoder : public ::protozero::TypedProtoDecoder { + public: + ClockSnapshot_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ClockSnapshot_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ClockSnapshot_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_clocks() const { return at<1>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> clocks() const { return GetRepeated<::protozero::ConstBytes>(1); } + bool has_primary_trace_clock() const { return at<2>().valid(); } + int32_t primary_trace_clock() const { return at<2>().as_int32(); } +}; + +class ClockSnapshot : public ::protozero::Message { + public: + using Decoder = ClockSnapshot_Decoder; + enum : int32_t { + kClocksFieldNumber = 1, + kPrimaryTraceClockFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ClockSnapshot"; } + + using Clock = ::perfetto::protos::pbzero::ClockSnapshot_Clock; + + using FieldMetadata_Clocks = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ClockSnapshot_Clock, + ClockSnapshot>; + + static constexpr FieldMetadata_Clocks kClocks{}; + template T* add_clocks() { + return BeginNestedMessage(1); + } + + + using FieldMetadata_PrimaryTraceClock = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + BuiltinClock, + ClockSnapshot>; + + static constexpr FieldMetadata_PrimaryTraceClock kPrimaryTraceClock{}; + void set_primary_trace_clock(BuiltinClock value) { + static constexpr uint32_t field_id = FieldMetadata_PrimaryTraceClock::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } +}; + +class ClockSnapshot_Clock_Decoder : public ::protozero::TypedProtoDecoder { + public: + ClockSnapshot_Clock_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ClockSnapshot_Clock_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ClockSnapshot_Clock_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_clock_id() const { return at<1>().valid(); } + uint32_t clock_id() const { return at<1>().as_uint32(); } + bool has_timestamp() const { return at<2>().valid(); } + uint64_t timestamp() const { return at<2>().as_uint64(); } + bool has_is_incremental() const { return at<3>().valid(); } + bool is_incremental() const { return at<3>().as_bool(); } + bool has_unit_multiplier_ns() const { return at<4>().valid(); } + uint64_t unit_multiplier_ns() const { return at<4>().as_uint64(); } +}; + +class ClockSnapshot_Clock : public ::protozero::Message { + public: + using Decoder = ClockSnapshot_Clock_Decoder; + enum : int32_t { + kClockIdFieldNumber = 1, + kTimestampFieldNumber = 2, + kIsIncrementalFieldNumber = 3, + kUnitMultiplierNsFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ClockSnapshot.Clock"; } + + + using BuiltinClocks = ::perfetto::protos::pbzero::ClockSnapshot_Clock_BuiltinClocks; + static inline const char* BuiltinClocks_Name(BuiltinClocks value) { + return ::perfetto::protos::pbzero::ClockSnapshot_Clock_BuiltinClocks_Name(value); + } + static inline const BuiltinClocks UNKNOWN = BuiltinClocks::UNKNOWN; + static inline const BuiltinClocks REALTIME = BuiltinClocks::REALTIME; + static inline const BuiltinClocks REALTIME_COARSE = BuiltinClocks::REALTIME_COARSE; + static inline const BuiltinClocks MONOTONIC = BuiltinClocks::MONOTONIC; + static inline const BuiltinClocks MONOTONIC_COARSE = BuiltinClocks::MONOTONIC_COARSE; + static inline const BuiltinClocks MONOTONIC_RAW = BuiltinClocks::MONOTONIC_RAW; + static inline const BuiltinClocks BOOTTIME = BuiltinClocks::BOOTTIME; + static inline const BuiltinClocks BUILTIN_CLOCK_MAX_ID = BuiltinClocks::BUILTIN_CLOCK_MAX_ID; + + using FieldMetadata_ClockId = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + ClockSnapshot_Clock>; + + static constexpr FieldMetadata_ClockId kClockId{}; + void set_clock_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ClockId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Timestamp = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + ClockSnapshot_Clock>; + + static constexpr FieldMetadata_Timestamp kTimestamp{}; + void set_timestamp(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Timestamp::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_IsIncremental = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + ClockSnapshot_Clock>; + + static constexpr FieldMetadata_IsIncremental kIsIncremental{}; + void set_is_incremental(bool value) { + static constexpr uint32_t field_id = FieldMetadata_IsIncremental::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_UnitMultiplierNs = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + ClockSnapshot_Clock>; + + static constexpr FieldMetadata_UnitMultiplierNs kUnitMultiplierNs{}; + void set_unit_multiplier_ns(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_UnitMultiplierNs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class V8CodeDefaults_Decoder : public ::protozero::TypedProtoDecoder { + public: + V8CodeDefaults_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit V8CodeDefaults_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit V8CodeDefaults_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_tid() const { return at<1>().valid(); } + uint32_t tid() const { return at<1>().as_uint32(); } +}; + +class V8CodeDefaults : public ::protozero::Message { + public: + using Decoder = V8CodeDefaults_Decoder; + enum : int32_t { + kTidFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.V8CodeDefaults"; } + + + using FieldMetadata_Tid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + V8CodeDefaults>; + + static constexpr FieldMetadata_Tid kTid{}; + void set_tid(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Tid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class V8CodeMove_Decoder : public ::protozero::TypedProtoDecoder { + public: + V8CodeMove_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit V8CodeMove_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit V8CodeMove_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_isolate_iid() const { return at<1>().valid(); } + uint64_t isolate_iid() const { return at<1>().as_uint64(); } + bool has_tid() const { return at<2>().valid(); } + uint32_t tid() const { return at<2>().as_uint32(); } + bool has_from_instruction_start_address() const { return at<3>().valid(); } + uint64_t from_instruction_start_address() const { return at<3>().as_uint64(); } + bool has_to_instruction_start_address() const { return at<4>().valid(); } + uint64_t to_instruction_start_address() const { return at<4>().as_uint64(); } + bool has_instruction_size_bytes() const { return at<5>().valid(); } + uint64_t instruction_size_bytes() const { return at<5>().as_uint64(); } + bool has_to_machine_code() const { return at<6>().valid(); } + ::protozero::ConstBytes to_machine_code() const { return at<6>().as_bytes(); } + bool has_to_bytecode() const { return at<7>().valid(); } + ::protozero::ConstBytes to_bytecode() const { return at<7>().as_bytes(); } +}; + +class V8CodeMove : public ::protozero::Message { + public: + using Decoder = V8CodeMove_Decoder; + enum : int32_t { + kIsolateIidFieldNumber = 1, + kTidFieldNumber = 2, + kFromInstructionStartAddressFieldNumber = 3, + kToInstructionStartAddressFieldNumber = 4, + kInstructionSizeBytesFieldNumber = 5, + kToMachineCodeFieldNumber = 6, + kToBytecodeFieldNumber = 7, + }; + static constexpr const char* GetName() { return ".perfetto.protos.V8CodeMove"; } + + + using FieldMetadata_IsolateIid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + V8CodeMove>; + + static constexpr FieldMetadata_IsolateIid kIsolateIid{}; + void set_isolate_iid(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_IsolateIid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Tid = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + V8CodeMove>; + + static constexpr FieldMetadata_Tid kTid{}; + void set_tid(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Tid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FromInstructionStartAddress = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + V8CodeMove>; + + static constexpr FieldMetadata_FromInstructionStartAddress kFromInstructionStartAddress{}; + void set_from_instruction_start_address(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_FromInstructionStartAddress::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ToInstructionStartAddress = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + V8CodeMove>; + + static constexpr FieldMetadata_ToInstructionStartAddress kToInstructionStartAddress{}; + void set_to_instruction_start_address(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_ToInstructionStartAddress::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_InstructionSizeBytes = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + V8CodeMove>; + + static constexpr FieldMetadata_InstructionSizeBytes kInstructionSizeBytes{}; + void set_instruction_size_bytes(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_InstructionSizeBytes::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ToMachineCode = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBytes, + std::string, + V8CodeMove>; + + static constexpr FieldMetadata_ToMachineCode kToMachineCode{}; + void set_to_machine_code(const uint8_t* data, size_t size) { + AppendBytes(FieldMetadata_ToMachineCode::kFieldId, data, size); + } + void set_to_machine_code(::protozero::ConstBytes bytes) { + AppendBytes(FieldMetadata_ToMachineCode::kFieldId, bytes.data, bytes.size); + } + void set_to_machine_code(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_ToMachineCode::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBytes> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ToBytecode = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBytes, + std::string, + V8CodeMove>; + + static constexpr FieldMetadata_ToBytecode kToBytecode{}; + void set_to_bytecode(const uint8_t* data, size_t size) { + AppendBytes(FieldMetadata_ToBytecode::kFieldId, data, size); + } + void set_to_bytecode(::protozero::ConstBytes bytes) { + AppendBytes(FieldMetadata_ToBytecode::kFieldId, bytes.data, bytes.size); + } + void set_to_bytecode(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_ToBytecode::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBytes> + ::Append(*this, field_id, value); + } +}; + +class V8RegExpCode_Decoder : public ::protozero::TypedProtoDecoder { + public: + V8RegExpCode_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit V8RegExpCode_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit V8RegExpCode_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_v8_isolate_iid() const { return at<1>().valid(); } + uint64_t v8_isolate_iid() const { return at<1>().as_uint64(); } + bool has_tid() const { return at<2>().valid(); } + uint32_t tid() const { return at<2>().as_uint32(); } + bool has_pattern() const { return at<3>().valid(); } + ::protozero::ConstBytes pattern() const { return at<3>().as_bytes(); } + bool has_instruction_start() const { return at<4>().valid(); } + uint64_t instruction_start() const { return at<4>().as_uint64(); } + bool has_instruction_size_bytes() const { return at<5>().valid(); } + uint64_t instruction_size_bytes() const { return at<5>().as_uint64(); } + bool has_machine_code() const { return at<6>().valid(); } + ::protozero::ConstBytes machine_code() const { return at<6>().as_bytes(); } +}; + +class V8RegExpCode : public ::protozero::Message { + public: + using Decoder = V8RegExpCode_Decoder; + enum : int32_t { + kV8IsolateIidFieldNumber = 1, + kTidFieldNumber = 2, + kPatternFieldNumber = 3, + kInstructionStartFieldNumber = 4, + kInstructionSizeBytesFieldNumber = 5, + kMachineCodeFieldNumber = 6, + }; + static constexpr const char* GetName() { return ".perfetto.protos.V8RegExpCode"; } + + + using FieldMetadata_V8IsolateIid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + V8RegExpCode>; + + static constexpr FieldMetadata_V8IsolateIid kV8IsolateIid{}; + void set_v8_isolate_iid(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_V8IsolateIid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Tid = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + V8RegExpCode>; + + static constexpr FieldMetadata_Tid kTid{}; + void set_tid(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Tid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pattern = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + V8String, + V8RegExpCode>; + + static constexpr FieldMetadata_Pattern kPattern{}; + template T* set_pattern() { + return BeginNestedMessage(3); + } + + + using FieldMetadata_InstructionStart = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + V8RegExpCode>; + + static constexpr FieldMetadata_InstructionStart kInstructionStart{}; + void set_instruction_start(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_InstructionStart::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_InstructionSizeBytes = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + V8RegExpCode>; + + static constexpr FieldMetadata_InstructionSizeBytes kInstructionSizeBytes{}; + void set_instruction_size_bytes(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_InstructionSizeBytes::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_MachineCode = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBytes, + std::string, + V8RegExpCode>; + + static constexpr FieldMetadata_MachineCode kMachineCode{}; + void set_machine_code(const uint8_t* data, size_t size) { + AppendBytes(FieldMetadata_MachineCode::kFieldId, data, size); + } + void set_machine_code(::protozero::ConstBytes bytes) { + AppendBytes(FieldMetadata_MachineCode::kFieldId, bytes.data, bytes.size); + } + void set_machine_code(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_MachineCode::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBytes> + ::Append(*this, field_id, value); + } +}; + +class V8WasmCode_Decoder : public ::protozero::TypedProtoDecoder { + public: + V8WasmCode_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit V8WasmCode_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit V8WasmCode_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_v8_isolate_iid() const { return at<1>().valid(); } + uint64_t v8_isolate_iid() const { return at<1>().as_uint64(); } + bool has_tid() const { return at<2>().valid(); } + uint32_t tid() const { return at<2>().as_uint32(); } + bool has_v8_wasm_script_iid() const { return at<3>().valid(); } + uint64_t v8_wasm_script_iid() const { return at<3>().as_uint64(); } + bool has_function_name() const { return at<4>().valid(); } + ::protozero::ConstChars function_name() const { return at<4>().as_string(); } + bool has_tier() const { return at<5>().valid(); } + int32_t tier() const { return at<5>().as_int32(); } + bool has_code_offset_in_module() const { return at<6>().valid(); } + int32_t code_offset_in_module() const { return at<6>().as_int32(); } + bool has_instruction_start() const { return at<7>().valid(); } + uint64_t instruction_start() const { return at<7>().as_uint64(); } + bool has_instruction_size_bytes() const { return at<8>().valid(); } + uint64_t instruction_size_bytes() const { return at<8>().as_uint64(); } + bool has_machine_code() const { return at<9>().valid(); } + ::protozero::ConstBytes machine_code() const { return at<9>().as_bytes(); } +}; + +class V8WasmCode : public ::protozero::Message { + public: + using Decoder = V8WasmCode_Decoder; + enum : int32_t { + kV8IsolateIidFieldNumber = 1, + kTidFieldNumber = 2, + kV8WasmScriptIidFieldNumber = 3, + kFunctionNameFieldNumber = 4, + kTierFieldNumber = 5, + kCodeOffsetInModuleFieldNumber = 6, + kInstructionStartFieldNumber = 7, + kInstructionSizeBytesFieldNumber = 8, + kMachineCodeFieldNumber = 9, + }; + static constexpr const char* GetName() { return ".perfetto.protos.V8WasmCode"; } + + + using Tier = ::perfetto::protos::pbzero::V8WasmCode_Tier; + static inline const char* Tier_Name(Tier value) { + return ::perfetto::protos::pbzero::V8WasmCode_Tier_Name(value); + } + static inline const Tier TIER_UNKNOWN = Tier::TIER_UNKNOWN; + static inline const Tier TIER_LIFTOFF = Tier::TIER_LIFTOFF; + static inline const Tier TIER_TURBOFAN = Tier::TIER_TURBOFAN; + + using FieldMetadata_V8IsolateIid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + V8WasmCode>; + + static constexpr FieldMetadata_V8IsolateIid kV8IsolateIid{}; + void set_v8_isolate_iid(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_V8IsolateIid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Tid = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + V8WasmCode>; + + static constexpr FieldMetadata_Tid kTid{}; + void set_tid(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Tid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_V8WasmScriptIid = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + V8WasmCode>; + + static constexpr FieldMetadata_V8WasmScriptIid kV8WasmScriptIid{}; + void set_v8_wasm_script_iid(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_V8WasmScriptIid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FunctionName = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + V8WasmCode>; + + static constexpr FieldMetadata_FunctionName kFunctionName{}; + void set_function_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_FunctionName::kFieldId, data, size); + } + void set_function_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_FunctionName::kFieldId, chars.data, chars.size); + } + void set_function_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_FunctionName::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Tier = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + V8WasmCode_Tier, + V8WasmCode>; + + static constexpr FieldMetadata_Tier kTier{}; + void set_tier(V8WasmCode_Tier value) { + static constexpr uint32_t field_id = FieldMetadata_Tier::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CodeOffsetInModule = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + V8WasmCode>; + + static constexpr FieldMetadata_CodeOffsetInModule kCodeOffsetInModule{}; + void set_code_offset_in_module(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_CodeOffsetInModule::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_InstructionStart = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + V8WasmCode>; + + static constexpr FieldMetadata_InstructionStart kInstructionStart{}; + void set_instruction_start(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_InstructionStart::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_InstructionSizeBytes = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + V8WasmCode>; + + static constexpr FieldMetadata_InstructionSizeBytes kInstructionSizeBytes{}; + void set_instruction_size_bytes(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_InstructionSizeBytes::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_MachineCode = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBytes, + std::string, + V8WasmCode>; + + static constexpr FieldMetadata_MachineCode kMachineCode{}; + void set_machine_code(const uint8_t* data, size_t size) { + AppendBytes(FieldMetadata_MachineCode::kFieldId, data, size); + } + void set_machine_code(::protozero::ConstBytes bytes) { + AppendBytes(FieldMetadata_MachineCode::kFieldId, bytes.data, bytes.size); + } + void set_machine_code(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_MachineCode::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBytes> + ::Append(*this, field_id, value); + } +}; + +class V8InternalCode_Decoder : public ::protozero::TypedProtoDecoder { + public: + V8InternalCode_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit V8InternalCode_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit V8InternalCode_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_v8_isolate_iid() const { return at<1>().valid(); } + uint64_t v8_isolate_iid() const { return at<1>().as_uint64(); } + bool has_tid() const { return at<2>().valid(); } + uint32_t tid() const { return at<2>().as_uint32(); } + bool has_name() const { return at<3>().valid(); } + ::protozero::ConstChars name() const { return at<3>().as_string(); } + bool has_type() const { return at<4>().valid(); } + int32_t type() const { return at<4>().as_int32(); } + bool has_builtin_id() const { return at<5>().valid(); } + int32_t builtin_id() const { return at<5>().as_int32(); } + bool has_instruction_start() const { return at<6>().valid(); } + uint64_t instruction_start() const { return at<6>().as_uint64(); } + bool has_instruction_size_bytes() const { return at<7>().valid(); } + uint64_t instruction_size_bytes() const { return at<7>().as_uint64(); } + bool has_machine_code() const { return at<8>().valid(); } + ::protozero::ConstBytes machine_code() const { return at<8>().as_bytes(); } +}; + +class V8InternalCode : public ::protozero::Message { + public: + using Decoder = V8InternalCode_Decoder; + enum : int32_t { + kV8IsolateIidFieldNumber = 1, + kTidFieldNumber = 2, + kNameFieldNumber = 3, + kTypeFieldNumber = 4, + kBuiltinIdFieldNumber = 5, + kInstructionStartFieldNumber = 6, + kInstructionSizeBytesFieldNumber = 7, + kMachineCodeFieldNumber = 8, + }; + static constexpr const char* GetName() { return ".perfetto.protos.V8InternalCode"; } + + + using Type = ::perfetto::protos::pbzero::V8InternalCode_Type; + static inline const char* Type_Name(Type value) { + return ::perfetto::protos::pbzero::V8InternalCode_Type_Name(value); + } + static inline const Type TYPE_UNKNOWN = Type::TYPE_UNKNOWN; + static inline const Type TYPE_BYTECODE_HANDLER = Type::TYPE_BYTECODE_HANDLER; + static inline const Type TYPE_FOR_TESTING = Type::TYPE_FOR_TESTING; + static inline const Type TYPE_BUILTIN = Type::TYPE_BUILTIN; + static inline const Type TYPE_WASM_FUNCTION = Type::TYPE_WASM_FUNCTION; + static inline const Type TYPE_WASM_TO_CAPI_FUNCTION = Type::TYPE_WASM_TO_CAPI_FUNCTION; + static inline const Type TYPE_WASM_TO_JS_FUNCTION = Type::TYPE_WASM_TO_JS_FUNCTION; + static inline const Type TYPE_JS_TO_WASM_FUNCTION = Type::TYPE_JS_TO_WASM_FUNCTION; + static inline const Type TYPE_JS_TO_JS_FUNCTION = Type::TYPE_JS_TO_JS_FUNCTION; + static inline const Type TYPE_C_WASM_ENTRY = Type::TYPE_C_WASM_ENTRY; + + using FieldMetadata_V8IsolateIid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + V8InternalCode>; + + static constexpr FieldMetadata_V8IsolateIid kV8IsolateIid{}; + void set_v8_isolate_iid(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_V8IsolateIid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Tid = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + V8InternalCode>; + + static constexpr FieldMetadata_Tid kTid{}; + void set_tid(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Tid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + V8InternalCode>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Type = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + V8InternalCode_Type, + V8InternalCode>; + + static constexpr FieldMetadata_Type kType{}; + void set_type(V8InternalCode_Type value) { + static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_BuiltinId = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + V8InternalCode>; + + static constexpr FieldMetadata_BuiltinId kBuiltinId{}; + void set_builtin_id(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_BuiltinId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_InstructionStart = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + V8InternalCode>; + + static constexpr FieldMetadata_InstructionStart kInstructionStart{}; + void set_instruction_start(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_InstructionStart::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_InstructionSizeBytes = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + V8InternalCode>; + + static constexpr FieldMetadata_InstructionSizeBytes kInstructionSizeBytes{}; + void set_instruction_size_bytes(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_InstructionSizeBytes::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_MachineCode = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBytes, + std::string, + V8InternalCode>; + + static constexpr FieldMetadata_MachineCode kMachineCode{}; + void set_machine_code(const uint8_t* data, size_t size) { + AppendBytes(FieldMetadata_MachineCode::kFieldId, data, size); + } + void set_machine_code(::protozero::ConstBytes bytes) { + AppendBytes(FieldMetadata_MachineCode::kFieldId, bytes.data, bytes.size); + } + void set_machine_code(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_MachineCode::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBytes> + ::Append(*this, field_id, value); + } +}; + +class V8JsCode_Decoder : public ::protozero::TypedProtoDecoder { + public: + V8JsCode_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit V8JsCode_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit V8JsCode_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_v8_isolate_iid() const { return at<1>().valid(); } + uint64_t v8_isolate_iid() const { return at<1>().as_uint64(); } + bool has_tid() const { return at<2>().valid(); } + uint32_t tid() const { return at<2>().as_uint32(); } + bool has_v8_js_function_iid() const { return at<3>().valid(); } + uint64_t v8_js_function_iid() const { return at<3>().as_uint64(); } + bool has_tier() const { return at<4>().valid(); } + int32_t tier() const { return at<4>().as_int32(); } + bool has_instruction_start() const { return at<5>().valid(); } + uint64_t instruction_start() const { return at<5>().as_uint64(); } + bool has_instruction_size_bytes() const { return at<6>().valid(); } + uint64_t instruction_size_bytes() const { return at<6>().as_uint64(); } + bool has_machine_code() const { return at<7>().valid(); } + ::protozero::ConstBytes machine_code() const { return at<7>().as_bytes(); } + bool has_bytecode() const { return at<8>().valid(); } + ::protozero::ConstBytes bytecode() const { return at<8>().as_bytes(); } +}; + +class V8JsCode : public ::protozero::Message { + public: + using Decoder = V8JsCode_Decoder; + enum : int32_t { + kV8IsolateIidFieldNumber = 1, + kTidFieldNumber = 2, + kV8JsFunctionIidFieldNumber = 3, + kTierFieldNumber = 4, + kInstructionStartFieldNumber = 5, + kInstructionSizeBytesFieldNumber = 6, + kMachineCodeFieldNumber = 7, + kBytecodeFieldNumber = 8, + }; + static constexpr const char* GetName() { return ".perfetto.protos.V8JsCode"; } + + + using Tier = ::perfetto::protos::pbzero::V8JsCode_Tier; + static inline const char* Tier_Name(Tier value) { + return ::perfetto::protos::pbzero::V8JsCode_Tier_Name(value); + } + static inline const Tier TIER_UNKNOWN = Tier::TIER_UNKNOWN; + static inline const Tier TIER_IGNITION = Tier::TIER_IGNITION; + static inline const Tier TIER_SPARKPLUG = Tier::TIER_SPARKPLUG; + static inline const Tier TIER_MAGLEV = Tier::TIER_MAGLEV; + static inline const Tier TIER_TURBOSHAFT = Tier::TIER_TURBOSHAFT; + static inline const Tier TIER_TURBOFAN = Tier::TIER_TURBOFAN; + + using FieldMetadata_V8IsolateIid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + V8JsCode>; + + static constexpr FieldMetadata_V8IsolateIid kV8IsolateIid{}; + void set_v8_isolate_iid(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_V8IsolateIid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Tid = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + V8JsCode>; + + static constexpr FieldMetadata_Tid kTid{}; + void set_tid(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Tid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_V8JsFunctionIid = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + V8JsCode>; + + static constexpr FieldMetadata_V8JsFunctionIid kV8JsFunctionIid{}; + void set_v8_js_function_iid(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_V8JsFunctionIid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Tier = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + V8JsCode_Tier, + V8JsCode>; + + static constexpr FieldMetadata_Tier kTier{}; + void set_tier(V8JsCode_Tier value) { + static constexpr uint32_t field_id = FieldMetadata_Tier::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_InstructionStart = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + V8JsCode>; + + static constexpr FieldMetadata_InstructionStart kInstructionStart{}; + void set_instruction_start(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_InstructionStart::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_InstructionSizeBytes = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + V8JsCode>; + + static constexpr FieldMetadata_InstructionSizeBytes kInstructionSizeBytes{}; + void set_instruction_size_bytes(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_InstructionSizeBytes::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_MachineCode = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBytes, + std::string, + V8JsCode>; + + static constexpr FieldMetadata_MachineCode kMachineCode{}; + void set_machine_code(const uint8_t* data, size_t size) { + AppendBytes(FieldMetadata_MachineCode::kFieldId, data, size); + } + void set_machine_code(::protozero::ConstBytes bytes) { + AppendBytes(FieldMetadata_MachineCode::kFieldId, bytes.data, bytes.size); + } + void set_machine_code(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_MachineCode::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBytes> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Bytecode = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBytes, + std::string, + V8JsCode>; + + static constexpr FieldMetadata_Bytecode kBytecode{}; + void set_bytecode(const uint8_t* data, size_t size) { + AppendBytes(FieldMetadata_Bytecode::kFieldId, data, size); + } + void set_bytecode(::protozero::ConstBytes bytes) { + AppendBytes(FieldMetadata_Bytecode::kFieldId, bytes.data, bytes.size); + } + void set_bytecode(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Bytecode::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBytes> + ::Append(*this, field_id, value); + } +}; + +class InternedV8Isolate_Decoder : public ::protozero::TypedProtoDecoder { + public: + InternedV8Isolate_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit InternedV8Isolate_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit InternedV8Isolate_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_iid() const { return at<1>().valid(); } + uint64_t iid() const { return at<1>().as_uint64(); } + bool has_pid() const { return at<2>().valid(); } + uint32_t pid() const { return at<2>().as_uint32(); } + bool has_isolate_id() const { return at<3>().valid(); } + int32_t isolate_id() const { return at<3>().as_int32(); } + bool has_code_range() const { return at<4>().valid(); } + ::protozero::ConstBytes code_range() const { return at<4>().as_bytes(); } + bool has_embedded_blob_code_start_address() const { return at<5>().valid(); } + uint64_t embedded_blob_code_start_address() const { return at<5>().as_uint64(); } + bool has_embedded_blob_code_size() const { return at<6>().valid(); } + uint64_t embedded_blob_code_size() const { return at<6>().as_uint64(); } +}; + +class InternedV8Isolate : public ::protozero::Message { + public: + using Decoder = InternedV8Isolate_Decoder; + enum : int32_t { + kIidFieldNumber = 1, + kPidFieldNumber = 2, + kIsolateIdFieldNumber = 3, + kCodeRangeFieldNumber = 4, + kEmbeddedBlobCodeStartAddressFieldNumber = 5, + kEmbeddedBlobCodeSizeFieldNumber = 6, + }; + static constexpr const char* GetName() { return ".perfetto.protos.InternedV8Isolate"; } + + using CodeRange = ::perfetto::protos::pbzero::InternedV8Isolate_CodeRange; + + using FieldMetadata_Iid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + InternedV8Isolate>; + + static constexpr FieldMetadata_Iid kIid{}; + void set_iid(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Iid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pid = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + InternedV8Isolate>; + + static constexpr FieldMetadata_Pid kPid{}; + void set_pid(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_IsolateId = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + InternedV8Isolate>; + + static constexpr FieldMetadata_IsolateId kIsolateId{}; + void set_isolate_id(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_IsolateId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CodeRange = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + InternedV8Isolate_CodeRange, + InternedV8Isolate>; + + static constexpr FieldMetadata_CodeRange kCodeRange{}; + template T* set_code_range() { + return BeginNestedMessage(4); + } + + + using FieldMetadata_EmbeddedBlobCodeStartAddress = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + InternedV8Isolate>; + + static constexpr FieldMetadata_EmbeddedBlobCodeStartAddress kEmbeddedBlobCodeStartAddress{}; + void set_embedded_blob_code_start_address(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_EmbeddedBlobCodeStartAddress::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_EmbeddedBlobCodeSize = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + InternedV8Isolate>; + + static constexpr FieldMetadata_EmbeddedBlobCodeSize kEmbeddedBlobCodeSize{}; + void set_embedded_blob_code_size(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_EmbeddedBlobCodeSize::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class InternedV8Isolate_CodeRange_Decoder : public ::protozero::TypedProtoDecoder { + public: + InternedV8Isolate_CodeRange_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit InternedV8Isolate_CodeRange_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit InternedV8Isolate_CodeRange_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_base_address() const { return at<1>().valid(); } + uint64_t base_address() const { return at<1>().as_uint64(); } + bool has_size() const { return at<2>().valid(); } + uint64_t size() const { return at<2>().as_uint64(); } + bool has_embedded_blob_code_copy_start_address() const { return at<3>().valid(); } + uint64_t embedded_blob_code_copy_start_address() const { return at<3>().as_uint64(); } + bool has_is_process_wide() const { return at<4>().valid(); } + bool is_process_wide() const { return at<4>().as_bool(); } +}; + +class InternedV8Isolate_CodeRange : public ::protozero::Message { + public: + using Decoder = InternedV8Isolate_CodeRange_Decoder; + enum : int32_t { + kBaseAddressFieldNumber = 1, + kSizeFieldNumber = 2, + kEmbeddedBlobCodeCopyStartAddressFieldNumber = 3, + kIsProcessWideFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.InternedV8Isolate.CodeRange"; } + + + using FieldMetadata_BaseAddress = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + InternedV8Isolate_CodeRange>; + + static constexpr FieldMetadata_BaseAddress kBaseAddress{}; + void set_base_address(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_BaseAddress::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Size = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + InternedV8Isolate_CodeRange>; + + static constexpr FieldMetadata_Size kSize{}; + void set_size(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Size::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_EmbeddedBlobCodeCopyStartAddress = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + InternedV8Isolate_CodeRange>; + + static constexpr FieldMetadata_EmbeddedBlobCodeCopyStartAddress kEmbeddedBlobCodeCopyStartAddress{}; + void set_embedded_blob_code_copy_start_address(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_EmbeddedBlobCodeCopyStartAddress::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_IsProcessWide = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + InternedV8Isolate_CodeRange>; + + static constexpr FieldMetadata_IsProcessWide kIsProcessWide{}; + void set_is_process_wide(bool value) { + static constexpr uint32_t field_id = FieldMetadata_IsProcessWide::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } +}; + +class InternedV8JsFunction_Decoder : public ::protozero::TypedProtoDecoder { + public: + InternedV8JsFunction_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit InternedV8JsFunction_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit InternedV8JsFunction_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_iid() const { return at<1>().valid(); } + uint64_t iid() const { return at<1>().as_uint64(); } + bool has_v8_js_function_name_iid() const { return at<2>().valid(); } + uint64_t v8_js_function_name_iid() const { return at<2>().as_uint64(); } + bool has_v8_js_script_iid() const { return at<3>().valid(); } + uint64_t v8_js_script_iid() const { return at<3>().as_uint64(); } + bool has_is_toplevel() const { return at<4>().valid(); } + bool is_toplevel() const { return at<4>().as_bool(); } + bool has_kind() const { return at<5>().valid(); } + int32_t kind() const { return at<5>().as_int32(); } + bool has_byte_offset() const { return at<6>().valid(); } + uint32_t byte_offset() const { return at<6>().as_uint32(); } +}; + +class InternedV8JsFunction : public ::protozero::Message { + public: + using Decoder = InternedV8JsFunction_Decoder; + enum : int32_t { + kIidFieldNumber = 1, + kV8JsFunctionNameIidFieldNumber = 2, + kV8JsScriptIidFieldNumber = 3, + kIsToplevelFieldNumber = 4, + kKindFieldNumber = 5, + kByteOffsetFieldNumber = 6, + }; + static constexpr const char* GetName() { return ".perfetto.protos.InternedV8JsFunction"; } + + + using Kind = ::perfetto::protos::pbzero::InternedV8JsFunction_Kind; + static inline const char* Kind_Name(Kind value) { + return ::perfetto::protos::pbzero::InternedV8JsFunction_Kind_Name(value); + } + static inline const Kind KIND_UNKNOWN = Kind::KIND_UNKNOWN; + static inline const Kind KIND_NORMAL_FUNCTION = Kind::KIND_NORMAL_FUNCTION; + static inline const Kind KIND_MODULE = Kind::KIND_MODULE; + static inline const Kind KIND_ASYNC_MODULE = Kind::KIND_ASYNC_MODULE; + static inline const Kind KIND_BASE_CONSTRUCTOR = Kind::KIND_BASE_CONSTRUCTOR; + static inline const Kind KIND_DEFAULT_BASE_CONSTRUCTOR = Kind::KIND_DEFAULT_BASE_CONSTRUCTOR; + static inline const Kind KIND_DEFAULT_DERIVED_CONSTRUCTOR = Kind::KIND_DEFAULT_DERIVED_CONSTRUCTOR; + static inline const Kind KIND_DERIVED_CONSTRUCTOR = Kind::KIND_DERIVED_CONSTRUCTOR; + static inline const Kind KIND_GETTER_FUNCTION = Kind::KIND_GETTER_FUNCTION; + static inline const Kind KIND_STATIC_GETTER_FUNCTION = Kind::KIND_STATIC_GETTER_FUNCTION; + static inline const Kind KIND_SETTER_FUNCTION = Kind::KIND_SETTER_FUNCTION; + static inline const Kind KIND_STATIC_SETTER_FUNCTION = Kind::KIND_STATIC_SETTER_FUNCTION; + static inline const Kind KIND_ARROW_FUNCTION = Kind::KIND_ARROW_FUNCTION; + static inline const Kind KIND_ASYNC_ARROW_FUNCTION = Kind::KIND_ASYNC_ARROW_FUNCTION; + static inline const Kind KIND_ASYNC_FUNCTION = Kind::KIND_ASYNC_FUNCTION; + static inline const Kind KIND_ASYNC_CONCISE_METHOD = Kind::KIND_ASYNC_CONCISE_METHOD; + static inline const Kind KIND_STATIC_ASYNC_CONCISE_METHOD = Kind::KIND_STATIC_ASYNC_CONCISE_METHOD; + static inline const Kind KIND_ASYNC_CONCISE_GENERATOR_METHOD = Kind::KIND_ASYNC_CONCISE_GENERATOR_METHOD; + static inline const Kind KIND_STATIC_ASYNC_CONCISE_GENERATOR_METHOD = Kind::KIND_STATIC_ASYNC_CONCISE_GENERATOR_METHOD; + static inline const Kind KIND_ASYNC_GENERATOR_FUNCTION = Kind::KIND_ASYNC_GENERATOR_FUNCTION; + static inline const Kind KIND_GENERATOR_FUNCTION = Kind::KIND_GENERATOR_FUNCTION; + static inline const Kind KIND_CONCISE_GENERATOR_METHOD = Kind::KIND_CONCISE_GENERATOR_METHOD; + static inline const Kind KIND_STATIC_CONCISE_GENERATOR_METHOD = Kind::KIND_STATIC_CONCISE_GENERATOR_METHOD; + static inline const Kind KIND_CONCISE_METHOD = Kind::KIND_CONCISE_METHOD; + static inline const Kind KIND_STATIC_CONCISE_METHOD = Kind::KIND_STATIC_CONCISE_METHOD; + static inline const Kind KIND_CLASS_MEMBERS_INITIALIZER_FUNCTION = Kind::KIND_CLASS_MEMBERS_INITIALIZER_FUNCTION; + static inline const Kind KIND_CLASS_STATIC_INITIALIZER_FUNCTION = Kind::KIND_CLASS_STATIC_INITIALIZER_FUNCTION; + static inline const Kind KIND_INVALID = Kind::KIND_INVALID; + + using FieldMetadata_Iid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + InternedV8JsFunction>; + + static constexpr FieldMetadata_Iid kIid{}; + void set_iid(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Iid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_V8JsFunctionNameIid = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + InternedV8JsFunction>; + + static constexpr FieldMetadata_V8JsFunctionNameIid kV8JsFunctionNameIid{}; + void set_v8_js_function_name_iid(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_V8JsFunctionNameIid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_V8JsScriptIid = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + InternedV8JsFunction>; + + static constexpr FieldMetadata_V8JsScriptIid kV8JsScriptIid{}; + void set_v8_js_script_iid(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_V8JsScriptIid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_IsToplevel = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + InternedV8JsFunction>; + + static constexpr FieldMetadata_IsToplevel kIsToplevel{}; + void set_is_toplevel(bool value) { + static constexpr uint32_t field_id = FieldMetadata_IsToplevel::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Kind = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + InternedV8JsFunction_Kind, + InternedV8JsFunction>; + + static constexpr FieldMetadata_Kind kKind{}; + void set_kind(InternedV8JsFunction_Kind value) { + static constexpr uint32_t field_id = FieldMetadata_Kind::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ByteOffset = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + InternedV8JsFunction>; + + static constexpr FieldMetadata_ByteOffset kByteOffset{}; + void set_byte_offset(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ByteOffset::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class InternedV8WasmScript_Decoder : public ::protozero::TypedProtoDecoder { + public: + InternedV8WasmScript_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit InternedV8WasmScript_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit InternedV8WasmScript_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_iid() const { return at<1>().valid(); } + uint64_t iid() const { return at<1>().as_uint64(); } + bool has_script_id() const { return at<2>().valid(); } + int32_t script_id() const { return at<2>().as_int32(); } + bool has_url() const { return at<3>().valid(); } + ::protozero::ConstChars url() const { return at<3>().as_string(); } +}; + +class InternedV8WasmScript : public ::protozero::Message { + public: + using Decoder = InternedV8WasmScript_Decoder; + enum : int32_t { + kIidFieldNumber = 1, + kScriptIdFieldNumber = 2, + kUrlFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.InternedV8WasmScript"; } + + + using FieldMetadata_Iid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + InternedV8WasmScript>; + + static constexpr FieldMetadata_Iid kIid{}; + void set_iid(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Iid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ScriptId = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + InternedV8WasmScript>; + + static constexpr FieldMetadata_ScriptId kScriptId{}; + void set_script_id(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ScriptId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Url = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + InternedV8WasmScript>; + + static constexpr FieldMetadata_Url kUrl{}; + void set_url(const char* data, size_t size) { + AppendBytes(FieldMetadata_Url::kFieldId, data, size); + } + void set_url(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Url::kFieldId, chars.data, chars.size); + } + void set_url(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Url::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class InternedV8JsScript_Decoder : public ::protozero::TypedProtoDecoder { + public: + InternedV8JsScript_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit InternedV8JsScript_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit InternedV8JsScript_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_iid() const { return at<1>().valid(); } + uint64_t iid() const { return at<1>().as_uint64(); } + bool has_script_id() const { return at<2>().valid(); } + int32_t script_id() const { return at<2>().as_int32(); } + bool has_type() const { return at<3>().valid(); } + int32_t type() const { return at<3>().as_int32(); } + bool has_name() const { return at<4>().valid(); } + ::protozero::ConstBytes name() const { return at<4>().as_bytes(); } + bool has_source() const { return at<5>().valid(); } + ::protozero::ConstBytes source() const { return at<5>().as_bytes(); } +}; + +class InternedV8JsScript : public ::protozero::Message { + public: + using Decoder = InternedV8JsScript_Decoder; + enum : int32_t { + kIidFieldNumber = 1, + kScriptIdFieldNumber = 2, + kTypeFieldNumber = 3, + kNameFieldNumber = 4, + kSourceFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.InternedV8JsScript"; } + + + using Type = ::perfetto::protos::pbzero::InternedV8JsScript_Type; + static inline const char* Type_Name(Type value) { + return ::perfetto::protos::pbzero::InternedV8JsScript_Type_Name(value); + } + static inline const Type TYPE_UNKNOWN = Type::TYPE_UNKNOWN; + static inline const Type TYPE_NORMAL = Type::TYPE_NORMAL; + static inline const Type TYPE_EVAL = Type::TYPE_EVAL; + static inline const Type TYPE_MODULE = Type::TYPE_MODULE; + static inline const Type TYPE_NATIVE = Type::TYPE_NATIVE; + static inline const Type TYPE_EXTENSION = Type::TYPE_EXTENSION; + static inline const Type TYPE_INSPECTOR = Type::TYPE_INSPECTOR; + + using FieldMetadata_Iid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + InternedV8JsScript>; + + static constexpr FieldMetadata_Iid kIid{}; + void set_iid(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Iid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ScriptId = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + InternedV8JsScript>; + + static constexpr FieldMetadata_ScriptId kScriptId{}; + void set_script_id(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ScriptId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Type = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + InternedV8JsScript_Type, + InternedV8JsScript>; + + static constexpr FieldMetadata_Type kType{}; + void set_type(InternedV8JsScript_Type value) { + static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + V8String, + InternedV8JsScript>; + + static constexpr FieldMetadata_Name kName{}; + template T* set_name() { + return BeginNestedMessage(4); + } + + + using FieldMetadata_Source = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + V8String, + InternedV8JsScript>; + + static constexpr FieldMetadata_Source kSource{}; + template T* set_source() { + return BeginNestedMessage(5); + } + +}; + +class InternedV8String_Decoder : public ::protozero::TypedProtoDecoder { + public: + InternedV8String_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit InternedV8String_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit InternedV8String_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_iid() const { return at<1>().valid(); } + uint64_t iid() const { return at<1>().as_uint64(); } + bool has_latin1() const { return at<2>().valid(); } + ::protozero::ConstBytes latin1() const { return at<2>().as_bytes(); } + bool has_utf16_le() const { return at<3>().valid(); } + ::protozero::ConstBytes utf16_le() const { return at<3>().as_bytes(); } + bool has_utf16_be() const { return at<4>().valid(); } + ::protozero::ConstBytes utf16_be() const { return at<4>().as_bytes(); } +}; + +class InternedV8String : public ::protozero::Message { + public: + using Decoder = InternedV8String_Decoder; + enum : int32_t { + kIidFieldNumber = 1, + kLatin1FieldNumber = 2, + kUtf16LeFieldNumber = 3, + kUtf16BeFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.InternedV8String"; } + + + using FieldMetadata_Iid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + InternedV8String>; + + static constexpr FieldMetadata_Iid kIid{}; + void set_iid(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Iid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Latin1 = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBytes, + std::string, + InternedV8String>; + + static constexpr FieldMetadata_Latin1 kLatin1{}; + void set_latin1(const uint8_t* data, size_t size) { + AppendBytes(FieldMetadata_Latin1::kFieldId, data, size); + } + void set_latin1(::protozero::ConstBytes bytes) { + AppendBytes(FieldMetadata_Latin1::kFieldId, bytes.data, bytes.size); + } + void set_latin1(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Latin1::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBytes> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Utf16Le = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBytes, + std::string, + InternedV8String>; + + static constexpr FieldMetadata_Utf16Le kUtf16Le{}; + void set_utf16_le(const uint8_t* data, size_t size) { + AppendBytes(FieldMetadata_Utf16Le::kFieldId, data, size); + } + void set_utf16_le(::protozero::ConstBytes bytes) { + AppendBytes(FieldMetadata_Utf16Le::kFieldId, bytes.data, bytes.size); + } + void set_utf16_le(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Utf16Le::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBytes> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Utf16Be = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBytes, + std::string, + InternedV8String>; + + static constexpr FieldMetadata_Utf16Be kUtf16Be{}; + void set_utf16_be(const uint8_t* data, size_t size) { + AppendBytes(FieldMetadata_Utf16Be::kFieldId, data, size); + } + void set_utf16_be(::protozero::ConstBytes bytes) { + AppendBytes(FieldMetadata_Utf16Be::kFieldId, bytes.data, bytes.size); + } + void set_utf16_be(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Utf16Be::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBytes> + ::Append(*this, field_id, value); + } +}; + +class V8String_Decoder : public ::protozero::TypedProtoDecoder { + public: + V8String_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit V8String_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit V8String_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_latin1() const { return at<1>().valid(); } + ::protozero::ConstBytes latin1() const { return at<1>().as_bytes(); } + bool has_utf16_le() const { return at<2>().valid(); } + ::protozero::ConstBytes utf16_le() const { return at<2>().as_bytes(); } + bool has_utf16_be() const { return at<3>().valid(); } + ::protozero::ConstBytes utf16_be() const { return at<3>().as_bytes(); } +}; + +class V8String : public ::protozero::Message { + public: + using Decoder = V8String_Decoder; + enum : int32_t { + kLatin1FieldNumber = 1, + kUtf16LeFieldNumber = 2, + kUtf16BeFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.V8String"; } + + + using FieldMetadata_Latin1 = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBytes, + std::string, + V8String>; + + static constexpr FieldMetadata_Latin1 kLatin1{}; + void set_latin1(const uint8_t* data, size_t size) { + AppendBytes(FieldMetadata_Latin1::kFieldId, data, size); + } + void set_latin1(::protozero::ConstBytes bytes) { + AppendBytes(FieldMetadata_Latin1::kFieldId, bytes.data, bytes.size); + } + void set_latin1(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Latin1::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBytes> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Utf16Le = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBytes, + std::string, + V8String>; + + static constexpr FieldMetadata_Utf16Le kUtf16Le{}; + void set_utf16_le(const uint8_t* data, size_t size) { + AppendBytes(FieldMetadata_Utf16Le::kFieldId, data, size); + } + void set_utf16_le(::protozero::ConstBytes bytes) { + AppendBytes(FieldMetadata_Utf16Le::kFieldId, bytes.data, bytes.size); + } + void set_utf16_le(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Utf16Le::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBytes> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Utf16Be = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBytes, + std::string, + V8String>; + + static constexpr FieldMetadata_Utf16Be kUtf16Be{}; + void set_utf16_be(const uint8_t* data, size_t size) { + AppendBytes(FieldMetadata_Utf16Be::kFieldId, data, size); + } + void set_utf16_be(::protozero::ConstBytes bytes) { + AppendBytes(FieldMetadata_Utf16Be::kFieldId, bytes.data, bytes.size); + } + void set_utf16_be(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Utf16Be::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBytes> + ::Append(*this, field_id, value); + } +}; + +class ChromeTrigger_Decoder : public ::protozero::TypedProtoDecoder { + public: + ChromeTrigger_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ChromeTrigger_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ChromeTrigger_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_trigger_name() const { return at<1>().valid(); } + ::protozero::ConstChars trigger_name() const { return at<1>().as_string(); } + bool has_trigger_hash() const { return at<2>().valid(); } + ::protozero::ConstChars trigger_hash() const { return at<2>().as_string(); } +}; + +class ChromeTrigger : public ::protozero::Message { + public: + using Decoder = ChromeTrigger_Decoder; + enum : int32_t { + kTriggerNameFieldNumber = 1, + kTriggerHashFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ChromeTrigger"; } + + + using FieldMetadata_TriggerName = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + ChromeTrigger>; + + static constexpr FieldMetadata_TriggerName kTriggerName{}; + void set_trigger_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_TriggerName::kFieldId, data, size); + } + void set_trigger_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_TriggerName::kFieldId, chars.data, chars.size); + } + void set_trigger_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_TriggerName::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TriggerHash = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + ChromeTrigger>; + + static constexpr FieldMetadata_TriggerHash kTriggerHash{}; + void set_trigger_hash(const char* data, size_t size) { + AppendBytes(FieldMetadata_TriggerHash::kFieldId, data, size); + } + void set_trigger_hash(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_TriggerHash::kFieldId, chars.data, chars.size); + } + void set_trigger_hash(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_TriggerHash::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class ChromeEventBundle_Decoder : public ::protozero::TypedProtoDecoder { + public: + ChromeEventBundle_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ChromeEventBundle_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ChromeEventBundle_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_trace_events() const { return at<1>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> trace_events() const { return GetRepeated<::protozero::ConstBytes>(1); } + bool has_metadata() const { return at<2>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> metadata() const { return GetRepeated<::protozero::ConstBytes>(2); } + bool has_legacy_ftrace_output() const { return at<4>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstChars> legacy_ftrace_output() const { return GetRepeated<::protozero::ConstChars>(4); } + bool has_legacy_json_trace() const { return at<5>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> legacy_json_trace() const { return GetRepeated<::protozero::ConstBytes>(5); } + bool has_string_table() const { return at<3>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> string_table() const { return GetRepeated<::protozero::ConstBytes>(3); } +}; + +class ChromeEventBundle : public ::protozero::Message { + public: + using Decoder = ChromeEventBundle_Decoder; + enum : int32_t { + kTraceEventsFieldNumber = 1, + kMetadataFieldNumber = 2, + kLegacyFtraceOutputFieldNumber = 4, + kLegacyJsonTraceFieldNumber = 5, + kStringTableFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ChromeEventBundle"; } + + + using FieldMetadata_TraceEvents = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ChromeTraceEvent, + ChromeEventBundle>; + + static constexpr FieldMetadata_TraceEvents kTraceEvents{}; + template T* add_trace_events() { + return BeginNestedMessage(1); + } + + + using FieldMetadata_Metadata = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ChromeMetadata, + ChromeEventBundle>; + + static constexpr FieldMetadata_Metadata kMetadata{}; + template T* add_metadata() { + return BeginNestedMessage(2); + } + + + using FieldMetadata_LegacyFtraceOutput = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + ChromeEventBundle>; + + static constexpr FieldMetadata_LegacyFtraceOutput kLegacyFtraceOutput{}; + void add_legacy_ftrace_output(const char* data, size_t size) { + AppendBytes(FieldMetadata_LegacyFtraceOutput::kFieldId, data, size); + } + void add_legacy_ftrace_output(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_LegacyFtraceOutput::kFieldId, chars.data, chars.size); + } + void add_legacy_ftrace_output(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_LegacyFtraceOutput::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_LegacyJsonTrace = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ChromeLegacyJsonTrace, + ChromeEventBundle>; + + static constexpr FieldMetadata_LegacyJsonTrace kLegacyJsonTrace{}; + template T* add_legacy_json_trace() { + return BeginNestedMessage(5); + } + + + using FieldMetadata_StringTable = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ChromeStringTableEntry, + ChromeEventBundle>; + + static constexpr FieldMetadata_StringTable kStringTable{}; + template T* add_string_table() { + return BeginNestedMessage(3); + } + +}; + +class ChromeLegacyJsonTrace_Decoder : public ::protozero::TypedProtoDecoder { + public: + ChromeLegacyJsonTrace_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ChromeLegacyJsonTrace_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ChromeLegacyJsonTrace_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_type() const { return at<1>().valid(); } + int32_t type() const { return at<1>().as_int32(); } + bool has_data() const { return at<2>().valid(); } + ::protozero::ConstChars data() const { return at<2>().as_string(); } +}; + +class ChromeLegacyJsonTrace : public ::protozero::Message { + public: + using Decoder = ChromeLegacyJsonTrace_Decoder; + enum : int32_t { + kTypeFieldNumber = 1, + kDataFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ChromeLegacyJsonTrace"; } + + + using TraceType = ::perfetto::protos::pbzero::ChromeLegacyJsonTrace_TraceType; + static inline const char* TraceType_Name(TraceType value) { + return ::perfetto::protos::pbzero::ChromeLegacyJsonTrace_TraceType_Name(value); + } + static inline const TraceType USER_TRACE = TraceType::USER_TRACE; + static inline const TraceType SYSTEM_TRACE = TraceType::SYSTEM_TRACE; + + using FieldMetadata_Type = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + ChromeLegacyJsonTrace_TraceType, + ChromeLegacyJsonTrace>; + + static constexpr FieldMetadata_Type kType{}; + void set_type(ChromeLegacyJsonTrace_TraceType value) { + static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Data = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + ChromeLegacyJsonTrace>; + + static constexpr FieldMetadata_Data kData{}; + void set_data(const char* data, size_t size) { + AppendBytes(FieldMetadata_Data::kFieldId, data, size); + } + void set_data(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Data::kFieldId, chars.data, chars.size); + } + void set_data(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Data::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class ChromeMetadata_Decoder : public ::protozero::TypedProtoDecoder { + public: + ChromeMetadata_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ChromeMetadata_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ChromeMetadata_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_name() const { return at<1>().valid(); } + ::protozero::ConstChars name() const { return at<1>().as_string(); } + bool has_string_value() const { return at<2>().valid(); } + ::protozero::ConstChars string_value() const { return at<2>().as_string(); } + bool has_bool_value() const { return at<3>().valid(); } + bool bool_value() const { return at<3>().as_bool(); } + bool has_int_value() const { return at<4>().valid(); } + int64_t int_value() const { return at<4>().as_int64(); } + bool has_json_value() const { return at<5>().valid(); } + ::protozero::ConstChars json_value() const { return at<5>().as_string(); } +}; + +class ChromeMetadata : public ::protozero::Message { + public: + using Decoder = ChromeMetadata_Decoder; + enum : int32_t { + kNameFieldNumber = 1, + kStringValueFieldNumber = 2, + kBoolValueFieldNumber = 3, + kIntValueFieldNumber = 4, + kJsonValueFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ChromeMetadata"; } + + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + ChromeMetadata>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_StringValue = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + ChromeMetadata>; + + static constexpr FieldMetadata_StringValue kStringValue{}; + void set_string_value(const char* data, size_t size) { + AppendBytes(FieldMetadata_StringValue::kFieldId, data, size); + } + void set_string_value(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_StringValue::kFieldId, chars.data, chars.size); + } + void set_string_value(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_StringValue::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_BoolValue = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + ChromeMetadata>; + + static constexpr FieldMetadata_BoolValue kBoolValue{}; + void set_bool_value(bool value) { + static constexpr uint32_t field_id = FieldMetadata_BoolValue::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_IntValue = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + ChromeMetadata>; + + static constexpr FieldMetadata_IntValue kIntValue{}; + void set_int_value(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_IntValue::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_JsonValue = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + ChromeMetadata>; + + static constexpr FieldMetadata_JsonValue kJsonValue{}; + void set_json_value(const char* data, size_t size) { + AppendBytes(FieldMetadata_JsonValue::kFieldId, data, size); + } + void set_json_value(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_JsonValue::kFieldId, chars.data, chars.size); + } + void set_json_value(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_JsonValue::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class ChromeTraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + ChromeTraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ChromeTraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ChromeTraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_name() const { return at<1>().valid(); } + ::protozero::ConstChars name() const { return at<1>().as_string(); } + bool has_timestamp() const { return at<2>().valid(); } + int64_t timestamp() const { return at<2>().as_int64(); } + bool has_phase() const { return at<3>().valid(); } + int32_t phase() const { return at<3>().as_int32(); } + bool has_thread_id() const { return at<4>().valid(); } + int32_t thread_id() const { return at<4>().as_int32(); } + bool has_duration() const { return at<5>().valid(); } + int64_t duration() const { return at<5>().as_int64(); } + bool has_thread_duration() const { return at<6>().valid(); } + int64_t thread_duration() const { return at<6>().as_int64(); } + bool has_scope() const { return at<7>().valid(); } + ::protozero::ConstChars scope() const { return at<7>().as_string(); } + bool has_id() const { return at<8>().valid(); } + uint64_t id() const { return at<8>().as_uint64(); } + bool has_flags() const { return at<9>().valid(); } + uint32_t flags() const { return at<9>().as_uint32(); } + bool has_category_group_name() const { return at<10>().valid(); } + ::protozero::ConstChars category_group_name() const { return at<10>().as_string(); } + bool has_process_id() const { return at<11>().valid(); } + int32_t process_id() const { return at<11>().as_int32(); } + bool has_thread_timestamp() const { return at<12>().valid(); } + int64_t thread_timestamp() const { return at<12>().as_int64(); } + bool has_bind_id() const { return at<13>().valid(); } + uint64_t bind_id() const { return at<13>().as_uint64(); } + bool has_args() const { return at<14>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> args() const { return GetRepeated<::protozero::ConstBytes>(14); } + bool has_name_index() const { return at<15>().valid(); } + uint32_t name_index() const { return at<15>().as_uint32(); } + bool has_category_group_name_index() const { return at<16>().valid(); } + uint32_t category_group_name_index() const { return at<16>().as_uint32(); } +}; + +class ChromeTraceEvent : public ::protozero::Message { + public: + using Decoder = ChromeTraceEvent_Decoder; + enum : int32_t { + kNameFieldNumber = 1, + kTimestampFieldNumber = 2, + kPhaseFieldNumber = 3, + kThreadIdFieldNumber = 4, + kDurationFieldNumber = 5, + kThreadDurationFieldNumber = 6, + kScopeFieldNumber = 7, + kIdFieldNumber = 8, + kFlagsFieldNumber = 9, + kCategoryGroupNameFieldNumber = 10, + kProcessIdFieldNumber = 11, + kThreadTimestampFieldNumber = 12, + kBindIdFieldNumber = 13, + kArgsFieldNumber = 14, + kNameIndexFieldNumber = 15, + kCategoryGroupNameIndexFieldNumber = 16, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ChromeTraceEvent"; } + + using Arg = ::perfetto::protos::pbzero::ChromeTraceEvent_Arg; + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + ChromeTraceEvent>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Timestamp = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + ChromeTraceEvent>; + + static constexpr FieldMetadata_Timestamp kTimestamp{}; + void set_timestamp(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Timestamp::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Phase = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + ChromeTraceEvent>; + + static constexpr FieldMetadata_Phase kPhase{}; + void set_phase(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Phase::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ThreadId = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + ChromeTraceEvent>; + + static constexpr FieldMetadata_ThreadId kThreadId{}; + void set_thread_id(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ThreadId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Duration = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + ChromeTraceEvent>; + + static constexpr FieldMetadata_Duration kDuration{}; + void set_duration(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Duration::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ThreadDuration = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + ChromeTraceEvent>; + + static constexpr FieldMetadata_ThreadDuration kThreadDuration{}; + void set_thread_duration(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_ThreadDuration::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Scope = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + ChromeTraceEvent>; + + static constexpr FieldMetadata_Scope kScope{}; + void set_scope(const char* data, size_t size) { + AppendBytes(FieldMetadata_Scope::kFieldId, data, size); + } + void set_scope(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Scope::kFieldId, chars.data, chars.size); + } + void set_scope(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Scope::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Id = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + ChromeTraceEvent>; + + static constexpr FieldMetadata_Id kId{}; + void set_id(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Flags = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + ChromeTraceEvent>; + + static constexpr FieldMetadata_Flags kFlags{}; + void set_flags(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CategoryGroupName = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + ChromeTraceEvent>; + + static constexpr FieldMetadata_CategoryGroupName kCategoryGroupName{}; + void set_category_group_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_CategoryGroupName::kFieldId, data, size); + } + void set_category_group_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_CategoryGroupName::kFieldId, chars.data, chars.size); + } + void set_category_group_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_CategoryGroupName::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ProcessId = + ::protozero::proto_utils::FieldMetadata< + 11, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + ChromeTraceEvent>; + + static constexpr FieldMetadata_ProcessId kProcessId{}; + void set_process_id(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ProcessId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ThreadTimestamp = + ::protozero::proto_utils::FieldMetadata< + 12, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + ChromeTraceEvent>; + + static constexpr FieldMetadata_ThreadTimestamp kThreadTimestamp{}; + void set_thread_timestamp(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_ThreadTimestamp::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_BindId = + ::protozero::proto_utils::FieldMetadata< + 13, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + ChromeTraceEvent>; + + static constexpr FieldMetadata_BindId kBindId{}; + void set_bind_id(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_BindId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Args = + ::protozero::proto_utils::FieldMetadata< + 14, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ChromeTraceEvent_Arg, + ChromeTraceEvent>; + + static constexpr FieldMetadata_Args kArgs{}; + template T* add_args() { + return BeginNestedMessage(14); + } + + + using FieldMetadata_NameIndex = + ::protozero::proto_utils::FieldMetadata< + 15, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + ChromeTraceEvent>; + + static constexpr FieldMetadata_NameIndex kNameIndex{}; + void set_name_index(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_NameIndex::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CategoryGroupNameIndex = + ::protozero::proto_utils::FieldMetadata< + 16, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + ChromeTraceEvent>; + + static constexpr FieldMetadata_CategoryGroupNameIndex kCategoryGroupNameIndex{}; + void set_category_group_name_index(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_CategoryGroupNameIndex::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class ChromeTraceEvent_Arg_Decoder : public ::protozero::TypedProtoDecoder { + public: + ChromeTraceEvent_Arg_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ChromeTraceEvent_Arg_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ChromeTraceEvent_Arg_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_name() const { return at<1>().valid(); } + ::protozero::ConstChars name() const { return at<1>().as_string(); } + bool has_bool_value() const { return at<2>().valid(); } + bool bool_value() const { return at<2>().as_bool(); } + bool has_uint_value() const { return at<3>().valid(); } + uint64_t uint_value() const { return at<3>().as_uint64(); } + bool has_int_value() const { return at<4>().valid(); } + int64_t int_value() const { return at<4>().as_int64(); } + bool has_double_value() const { return at<5>().valid(); } + double double_value() const { return at<5>().as_double(); } + bool has_string_value() const { return at<6>().valid(); } + ::protozero::ConstChars string_value() const { return at<6>().as_string(); } + bool has_pointer_value() const { return at<7>().valid(); } + uint64_t pointer_value() const { return at<7>().as_uint64(); } + bool has_json_value() const { return at<8>().valid(); } + ::protozero::ConstChars json_value() const { return at<8>().as_string(); } + bool has_traced_value() const { return at<10>().valid(); } + ::protozero::ConstBytes traced_value() const { return at<10>().as_bytes(); } + bool has_name_index() const { return at<9>().valid(); } + uint32_t name_index() const { return at<9>().as_uint32(); } +}; + +class ChromeTraceEvent_Arg : public ::protozero::Message { + public: + using Decoder = ChromeTraceEvent_Arg_Decoder; + enum : int32_t { + kNameFieldNumber = 1, + kBoolValueFieldNumber = 2, + kUintValueFieldNumber = 3, + kIntValueFieldNumber = 4, + kDoubleValueFieldNumber = 5, + kStringValueFieldNumber = 6, + kPointerValueFieldNumber = 7, + kJsonValueFieldNumber = 8, + kTracedValueFieldNumber = 10, + kNameIndexFieldNumber = 9, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ChromeTraceEvent.Arg"; } + + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + ChromeTraceEvent_Arg>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_BoolValue = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + ChromeTraceEvent_Arg>; + + static constexpr FieldMetadata_BoolValue kBoolValue{}; + void set_bool_value(bool value) { + static constexpr uint32_t field_id = FieldMetadata_BoolValue::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_UintValue = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + ChromeTraceEvent_Arg>; + + static constexpr FieldMetadata_UintValue kUintValue{}; + void set_uint_value(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_UintValue::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_IntValue = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + ChromeTraceEvent_Arg>; + + static constexpr FieldMetadata_IntValue kIntValue{}; + void set_int_value(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_IntValue::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DoubleValue = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kDouble, + double, + ChromeTraceEvent_Arg>; + + static constexpr FieldMetadata_DoubleValue kDoubleValue{}; + void set_double_value(double value) { + static constexpr uint32_t field_id = FieldMetadata_DoubleValue::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kDouble> + ::Append(*this, field_id, value); + } + + using FieldMetadata_StringValue = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + ChromeTraceEvent_Arg>; + + static constexpr FieldMetadata_StringValue kStringValue{}; + void set_string_value(const char* data, size_t size) { + AppendBytes(FieldMetadata_StringValue::kFieldId, data, size); + } + void set_string_value(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_StringValue::kFieldId, chars.data, chars.size); + } + void set_string_value(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_StringValue::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PointerValue = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + ChromeTraceEvent_Arg>; + + static constexpr FieldMetadata_PointerValue kPointerValue{}; + void set_pointer_value(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_PointerValue::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_JsonValue = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + ChromeTraceEvent_Arg>; + + static constexpr FieldMetadata_JsonValue kJsonValue{}; + void set_json_value(const char* data, size_t size) { + AppendBytes(FieldMetadata_JsonValue::kFieldId, data, size); + } + void set_json_value(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_JsonValue::kFieldId, chars.data, chars.size); + } + void set_json_value(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_JsonValue::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TracedValue = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ChromeTracedValue, + ChromeTraceEvent_Arg>; + + static constexpr FieldMetadata_TracedValue kTracedValue{}; + template T* set_traced_value() { + return BeginNestedMessage(10); + } + + + using FieldMetadata_NameIndex = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + ChromeTraceEvent_Arg>; + + static constexpr FieldMetadata_NameIndex kNameIndex{}; + void set_name_index(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_NameIndex::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class ChromeStringTableEntry_Decoder : public ::protozero::TypedProtoDecoder { + public: + ChromeStringTableEntry_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ChromeStringTableEntry_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ChromeStringTableEntry_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_value() const { return at<1>().valid(); } + ::protozero::ConstChars value() const { return at<1>().as_string(); } + bool has_index() const { return at<2>().valid(); } + int32_t index() const { return at<2>().as_int32(); } +}; + +class ChromeStringTableEntry : public ::protozero::Message { + public: + using Decoder = ChromeStringTableEntry_Decoder; + enum : int32_t { + kValueFieldNumber = 1, + kIndexFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ChromeStringTableEntry"; } + + + using FieldMetadata_Value = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + ChromeStringTableEntry>; + + static constexpr FieldMetadata_Value kValue{}; + void set_value(const char* data, size_t size) { + AppendBytes(FieldMetadata_Value::kFieldId, data, size); + } + void set_value(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Value::kFieldId, chars.data, chars.size); + } + void set_value(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Index = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + ChromeStringTableEntry>; + + static constexpr FieldMetadata_Index kIndex{}; + void set_index(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Index::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class ChromeTracedValue_Decoder : public ::protozero::TypedProtoDecoder { + public: + ChromeTracedValue_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ChromeTracedValue_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ChromeTracedValue_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_nested_type() const { return at<1>().valid(); } + int32_t nested_type() const { return at<1>().as_int32(); } + bool has_dict_keys() const { return at<2>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstChars> dict_keys() const { return GetRepeated<::protozero::ConstChars>(2); } + bool has_dict_values() const { return at<3>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> dict_values() const { return GetRepeated<::protozero::ConstBytes>(3); } + bool has_array_values() const { return at<4>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> array_values() const { return GetRepeated<::protozero::ConstBytes>(4); } + bool has_int_value() const { return at<5>().valid(); } + int32_t int_value() const { return at<5>().as_int32(); } + bool has_double_value() const { return at<6>().valid(); } + double double_value() const { return at<6>().as_double(); } + bool has_bool_value() const { return at<7>().valid(); } + bool bool_value() const { return at<7>().as_bool(); } + bool has_string_value() const { return at<8>().valid(); } + ::protozero::ConstChars string_value() const { return at<8>().as_string(); } +}; + +class ChromeTracedValue : public ::protozero::Message { + public: + using Decoder = ChromeTracedValue_Decoder; + enum : int32_t { + kNestedTypeFieldNumber = 1, + kDictKeysFieldNumber = 2, + kDictValuesFieldNumber = 3, + kArrayValuesFieldNumber = 4, + kIntValueFieldNumber = 5, + kDoubleValueFieldNumber = 6, + kBoolValueFieldNumber = 7, + kStringValueFieldNumber = 8, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ChromeTracedValue"; } + + + using NestedType = ::perfetto::protos::pbzero::ChromeTracedValue_NestedType; + static inline const char* NestedType_Name(NestedType value) { + return ::perfetto::protos::pbzero::ChromeTracedValue_NestedType_Name(value); + } + static inline const NestedType DICT = NestedType::DICT; + static inline const NestedType ARRAY = NestedType::ARRAY; + + using FieldMetadata_NestedType = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + ChromeTracedValue_NestedType, + ChromeTracedValue>; + + static constexpr FieldMetadata_NestedType kNestedType{}; + void set_nested_type(ChromeTracedValue_NestedType value) { + static constexpr uint32_t field_id = FieldMetadata_NestedType::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DictKeys = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + ChromeTracedValue>; + + static constexpr FieldMetadata_DictKeys kDictKeys{}; + void add_dict_keys(const char* data, size_t size) { + AppendBytes(FieldMetadata_DictKeys::kFieldId, data, size); + } + void add_dict_keys(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_DictKeys::kFieldId, chars.data, chars.size); + } + void add_dict_keys(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_DictKeys::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DictValues = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ChromeTracedValue, + ChromeTracedValue>; + + static constexpr FieldMetadata_DictValues kDictValues{}; + template T* add_dict_values() { + return BeginNestedMessage(3); + } + + + using FieldMetadata_ArrayValues = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ChromeTracedValue, + ChromeTracedValue>; + + static constexpr FieldMetadata_ArrayValues kArrayValues{}; + template T* add_array_values() { + return BeginNestedMessage(4); + } + + + using FieldMetadata_IntValue = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + ChromeTracedValue>; + + static constexpr FieldMetadata_IntValue kIntValue{}; + void set_int_value(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_IntValue::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DoubleValue = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kDouble, + double, + ChromeTracedValue>; + + static constexpr FieldMetadata_DoubleValue kDoubleValue{}; + void set_double_value(double value) { + static constexpr uint32_t field_id = FieldMetadata_DoubleValue::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kDouble> + ::Append(*this, field_id, value); + } + + using FieldMetadata_BoolValue = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + ChromeTracedValue>; + + static constexpr FieldMetadata_BoolValue kBoolValue{}; + void set_bool_value(bool value) { + static constexpr uint32_t field_id = FieldMetadata_BoolValue::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_StringValue = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + ChromeTracedValue>; + + static constexpr FieldMetadata_StringValue kStringValue{}; + void set_string_value(const char* data, size_t size) { + AppendBytes(FieldMetadata_StringValue::kFieldId, data, size); + } + void set_string_value(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_StringValue::kFieldId, chars.data, chars.size); + } + void set_string_value(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_StringValue::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class BackgroundTracingMetadata_Decoder : public ::protozero::TypedProtoDecoder { + public: + BackgroundTracingMetadata_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit BackgroundTracingMetadata_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit BackgroundTracingMetadata_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_triggered_rule() const { return at<1>().valid(); } + ::protozero::ConstBytes triggered_rule() const { return at<1>().as_bytes(); } + bool has_active_rules() const { return at<2>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> active_rules() const { return GetRepeated<::protozero::ConstBytes>(2); } + bool has_scenario_name_hash() const { return at<3>().valid(); } + uint32_t scenario_name_hash() const { return at<3>().as_uint32(); } +}; + +class BackgroundTracingMetadata : public ::protozero::Message { + public: + using Decoder = BackgroundTracingMetadata_Decoder; + enum : int32_t { + kTriggeredRuleFieldNumber = 1, + kActiveRulesFieldNumber = 2, + kScenarioNameHashFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.BackgroundTracingMetadata"; } + + using TriggerRule = ::perfetto::protos::pbzero::BackgroundTracingMetadata_TriggerRule; + + using FieldMetadata_TriggeredRule = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + BackgroundTracingMetadata_TriggerRule, + BackgroundTracingMetadata>; + + static constexpr FieldMetadata_TriggeredRule kTriggeredRule{}; + template T* set_triggered_rule() { + return BeginNestedMessage(1); + } + + + using FieldMetadata_ActiveRules = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + BackgroundTracingMetadata_TriggerRule, + BackgroundTracingMetadata>; + + static constexpr FieldMetadata_ActiveRules kActiveRules{}; + template T* add_active_rules() { + return BeginNestedMessage(2); + } + + + using FieldMetadata_ScenarioNameHash = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFixed32, + uint32_t, + BackgroundTracingMetadata>; + + static constexpr FieldMetadata_ScenarioNameHash kScenarioNameHash{}; + void set_scenario_name_hash(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ScenarioNameHash::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFixed32> + ::Append(*this, field_id, value); + } +}; + +class BackgroundTracingMetadata_TriggerRule_Decoder : public ::protozero::TypedProtoDecoder { + public: + BackgroundTracingMetadata_TriggerRule_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit BackgroundTracingMetadata_TriggerRule_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit BackgroundTracingMetadata_TriggerRule_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_trigger_type() const { return at<1>().valid(); } + int32_t trigger_type() const { return at<1>().as_int32(); } + bool has_histogram_rule() const { return at<2>().valid(); } + ::protozero::ConstBytes histogram_rule() const { return at<2>().as_bytes(); } + bool has_named_rule() const { return at<3>().valid(); } + ::protozero::ConstBytes named_rule() const { return at<3>().as_bytes(); } + bool has_name_hash() const { return at<4>().valid(); } + uint32_t name_hash() const { return at<4>().as_uint32(); } +}; + +class BackgroundTracingMetadata_TriggerRule : public ::protozero::Message { + public: + using Decoder = BackgroundTracingMetadata_TriggerRule_Decoder; + enum : int32_t { + kTriggerTypeFieldNumber = 1, + kHistogramRuleFieldNumber = 2, + kNamedRuleFieldNumber = 3, + kNameHashFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.BackgroundTracingMetadata.TriggerRule"; } + + using HistogramRule = ::perfetto::protos::pbzero::BackgroundTracingMetadata_TriggerRule_HistogramRule; + using NamedRule = ::perfetto::protos::pbzero::BackgroundTracingMetadata_TriggerRule_NamedRule; + + using TriggerType = ::perfetto::protos::pbzero::BackgroundTracingMetadata_TriggerRule_TriggerType; + static inline const char* TriggerType_Name(TriggerType value) { + return ::perfetto::protos::pbzero::BackgroundTracingMetadata_TriggerRule_TriggerType_Name(value); + } + static inline const TriggerType TRIGGER_UNSPECIFIED = TriggerType::TRIGGER_UNSPECIFIED; + static inline const TriggerType MONITOR_AND_DUMP_WHEN_SPECIFIC_HISTOGRAM_AND_VALUE = TriggerType::MONITOR_AND_DUMP_WHEN_SPECIFIC_HISTOGRAM_AND_VALUE; + static inline const TriggerType MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED = TriggerType::MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED; + + using FieldMetadata_TriggerType = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + BackgroundTracingMetadata_TriggerRule_TriggerType, + BackgroundTracingMetadata_TriggerRule>; + + static constexpr FieldMetadata_TriggerType kTriggerType{}; + void set_trigger_type(BackgroundTracingMetadata_TriggerRule_TriggerType value) { + static constexpr uint32_t field_id = FieldMetadata_TriggerType::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_HistogramRule = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + BackgroundTracingMetadata_TriggerRule_HistogramRule, + BackgroundTracingMetadata_TriggerRule>; + + static constexpr FieldMetadata_HistogramRule kHistogramRule{}; + template T* set_histogram_rule() { + return BeginNestedMessage(2); + } + + + using FieldMetadata_NamedRule = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + BackgroundTracingMetadata_TriggerRule_NamedRule, + BackgroundTracingMetadata_TriggerRule>; + + static constexpr FieldMetadata_NamedRule kNamedRule{}; + template T* set_named_rule() { + return BeginNestedMessage(3); + } + + + using FieldMetadata_NameHash = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFixed32, + uint32_t, + BackgroundTracingMetadata_TriggerRule>; + + static constexpr FieldMetadata_NameHash kNameHash{}; + void set_name_hash(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_NameHash::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFixed32> + ::Append(*this, field_id, value); + } +}; + +class BackgroundTracingMetadata_TriggerRule_NamedRule_Decoder : public ::protozero::TypedProtoDecoder { + public: + BackgroundTracingMetadata_TriggerRule_NamedRule_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit BackgroundTracingMetadata_TriggerRule_NamedRule_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit BackgroundTracingMetadata_TriggerRule_NamedRule_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_event_type() const { return at<1>().valid(); } + int32_t event_type() const { return at<1>().as_int32(); } + bool has_content_trigger_name_hash() const { return at<2>().valid(); } + uint64_t content_trigger_name_hash() const { return at<2>().as_uint64(); } +}; + +class BackgroundTracingMetadata_TriggerRule_NamedRule : public ::protozero::Message { + public: + using Decoder = BackgroundTracingMetadata_TriggerRule_NamedRule_Decoder; + enum : int32_t { + kEventTypeFieldNumber = 1, + kContentTriggerNameHashFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.BackgroundTracingMetadata.TriggerRule.NamedRule"; } + + + using EventType = ::perfetto::protos::pbzero::BackgroundTracingMetadata_TriggerRule_NamedRule_EventType; + static inline const char* EventType_Name(EventType value) { + return ::perfetto::protos::pbzero::BackgroundTracingMetadata_TriggerRule_NamedRule_EventType_Name(value); + } + static inline const EventType UNSPECIFIED = EventType::UNSPECIFIED; + static inline const EventType SESSION_RESTORE = EventType::SESSION_RESTORE; + static inline const EventType NAVIGATION = EventType::NAVIGATION; + static inline const EventType STARTUP = EventType::STARTUP; + static inline const EventType REACHED_CODE = EventType::REACHED_CODE; + static inline const EventType CONTENT_TRIGGER = EventType::CONTENT_TRIGGER; + static inline const EventType TEST_RULE = EventType::TEST_RULE; + + using FieldMetadata_EventType = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + BackgroundTracingMetadata_TriggerRule_NamedRule_EventType, + BackgroundTracingMetadata_TriggerRule_NamedRule>; + + static constexpr FieldMetadata_EventType kEventType{}; + void set_event_type(BackgroundTracingMetadata_TriggerRule_NamedRule_EventType value) { + static constexpr uint32_t field_id = FieldMetadata_EventType::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ContentTriggerNameHash = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFixed64, + uint64_t, + BackgroundTracingMetadata_TriggerRule_NamedRule>; + + static constexpr FieldMetadata_ContentTriggerNameHash kContentTriggerNameHash{}; + void set_content_trigger_name_hash(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_ContentTriggerNameHash::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFixed64> + ::Append(*this, field_id, value); + } +}; + +class BackgroundTracingMetadata_TriggerRule_HistogramRule_Decoder : public ::protozero::TypedProtoDecoder { + public: + BackgroundTracingMetadata_TriggerRule_HistogramRule_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit BackgroundTracingMetadata_TriggerRule_HistogramRule_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit BackgroundTracingMetadata_TriggerRule_HistogramRule_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_histogram_name_hash() const { return at<1>().valid(); } + uint64_t histogram_name_hash() const { return at<1>().as_uint64(); } + bool has_histogram_min_trigger() const { return at<2>().valid(); } + int64_t histogram_min_trigger() const { return at<2>().as_int64(); } + bool has_histogram_max_trigger() const { return at<3>().valid(); } + int64_t histogram_max_trigger() const { return at<3>().as_int64(); } +}; + +class BackgroundTracingMetadata_TriggerRule_HistogramRule : public ::protozero::Message { + public: + using Decoder = BackgroundTracingMetadata_TriggerRule_HistogramRule_Decoder; + enum : int32_t { + kHistogramNameHashFieldNumber = 1, + kHistogramMinTriggerFieldNumber = 2, + kHistogramMaxTriggerFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.BackgroundTracingMetadata.TriggerRule.HistogramRule"; } + + + using FieldMetadata_HistogramNameHash = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFixed64, + uint64_t, + BackgroundTracingMetadata_TriggerRule_HistogramRule>; + + static constexpr FieldMetadata_HistogramNameHash kHistogramNameHash{}; + void set_histogram_name_hash(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_HistogramNameHash::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFixed64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_HistogramMinTrigger = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + BackgroundTracingMetadata_TriggerRule_HistogramRule>; + + static constexpr FieldMetadata_HistogramMinTrigger kHistogramMinTrigger{}; + void set_histogram_min_trigger(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_HistogramMinTrigger::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_HistogramMaxTrigger = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + BackgroundTracingMetadata_TriggerRule_HistogramRule>; + + static constexpr FieldMetadata_HistogramMaxTrigger kHistogramMaxTrigger{}; + void set_histogram_max_trigger(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_HistogramMaxTrigger::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } +}; + +class ChromeMetadataPacket_Decoder : public ::protozero::TypedProtoDecoder { + public: + ChromeMetadataPacket_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ChromeMetadataPacket_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ChromeMetadataPacket_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_background_tracing_metadata() const { return at<1>().valid(); } + ::protozero::ConstBytes background_tracing_metadata() const { return at<1>().as_bytes(); } + bool has_chrome_version_code() const { return at<2>().valid(); } + int32_t chrome_version_code() const { return at<2>().as_int32(); } + bool has_enabled_categories() const { return at<3>().valid(); } + ::protozero::ConstChars enabled_categories() const { return at<3>().as_string(); } + bool has_field_trial_hashes() const { return at<4>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> field_trial_hashes() const { return GetRepeated<::protozero::ConstBytes>(4); } +}; + +class ChromeMetadataPacket : public ::protozero::Message { + public: + using Decoder = ChromeMetadataPacket_Decoder; + enum : int32_t { + kBackgroundTracingMetadataFieldNumber = 1, + kChromeVersionCodeFieldNumber = 2, + kEnabledCategoriesFieldNumber = 3, + kFieldTrialHashesFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ChromeMetadataPacket"; } + + using FinchHash = ::perfetto::protos::pbzero::ChromeMetadataPacket_FinchHash; + + using FieldMetadata_BackgroundTracingMetadata = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + BackgroundTracingMetadata, + ChromeMetadataPacket>; + + static constexpr FieldMetadata_BackgroundTracingMetadata kBackgroundTracingMetadata{}; + template T* set_background_tracing_metadata() { + return BeginNestedMessage(1); + } + + + using FieldMetadata_ChromeVersionCode = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + ChromeMetadataPacket>; + + static constexpr FieldMetadata_ChromeVersionCode kChromeVersionCode{}; + void set_chrome_version_code(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ChromeVersionCode::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_EnabledCategories = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + ChromeMetadataPacket>; + + static constexpr FieldMetadata_EnabledCategories kEnabledCategories{}; + void set_enabled_categories(const char* data, size_t size) { + AppendBytes(FieldMetadata_EnabledCategories::kFieldId, data, size); + } + void set_enabled_categories(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_EnabledCategories::kFieldId, chars.data, chars.size); + } + void set_enabled_categories(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_EnabledCategories::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FieldTrialHashes = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ChromeMetadataPacket_FinchHash, + ChromeMetadataPacket>; + + static constexpr FieldMetadata_FieldTrialHashes kFieldTrialHashes{}; + template T* add_field_trial_hashes() { + return BeginNestedMessage(4); + } + +}; + +class ChromeMetadataPacket_FinchHash_Decoder : public ::protozero::TypedProtoDecoder { + public: + ChromeMetadataPacket_FinchHash_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ChromeMetadataPacket_FinchHash_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ChromeMetadataPacket_FinchHash_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_name() const { return at<1>().valid(); } + uint32_t name() const { return at<1>().as_uint32(); } + bool has_group() const { return at<2>().valid(); } + uint32_t group() const { return at<2>().as_uint32(); } +}; + +class ChromeMetadataPacket_FinchHash : public ::protozero::Message { + public: + using Decoder = ChromeMetadataPacket_FinchHash_Decoder; + enum : int32_t { + kNameFieldNumber = 1, + kGroupFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ChromeMetadataPacket.FinchHash"; } + + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + ChromeMetadataPacket_FinchHash>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Group = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + ChromeMetadataPacket_FinchHash>; + + static constexpr FieldMetadata_Group kGroup{}; + void set_group(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Group::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class ChromeBenchmarkMetadata_Decoder : public ::protozero::TypedProtoDecoder { + public: + ChromeBenchmarkMetadata_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ChromeBenchmarkMetadata_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ChromeBenchmarkMetadata_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_benchmark_start_time_us() const { return at<1>().valid(); } + int64_t benchmark_start_time_us() const { return at<1>().as_int64(); } + bool has_story_run_time_us() const { return at<2>().valid(); } + int64_t story_run_time_us() const { return at<2>().as_int64(); } + bool has_benchmark_name() const { return at<3>().valid(); } + ::protozero::ConstChars benchmark_name() const { return at<3>().as_string(); } + bool has_benchmark_description() const { return at<4>().valid(); } + ::protozero::ConstChars benchmark_description() const { return at<4>().as_string(); } + bool has_label() const { return at<5>().valid(); } + ::protozero::ConstChars label() const { return at<5>().as_string(); } + bool has_story_name() const { return at<6>().valid(); } + ::protozero::ConstChars story_name() const { return at<6>().as_string(); } + bool has_story_tags() const { return at<7>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstChars> story_tags() const { return GetRepeated<::protozero::ConstChars>(7); } + bool has_story_run_index() const { return at<8>().valid(); } + int32_t story_run_index() const { return at<8>().as_int32(); } + bool has_had_failures() const { return at<9>().valid(); } + bool had_failures() const { return at<9>().as_bool(); } +}; + +class ChromeBenchmarkMetadata : public ::protozero::Message { + public: + using Decoder = ChromeBenchmarkMetadata_Decoder; + enum : int32_t { + kBenchmarkStartTimeUsFieldNumber = 1, + kStoryRunTimeUsFieldNumber = 2, + kBenchmarkNameFieldNumber = 3, + kBenchmarkDescriptionFieldNumber = 4, + kLabelFieldNumber = 5, + kStoryNameFieldNumber = 6, + kStoryTagsFieldNumber = 7, + kStoryRunIndexFieldNumber = 8, + kHadFailuresFieldNumber = 9, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ChromeBenchmarkMetadata"; } + + + using FieldMetadata_BenchmarkStartTimeUs = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + ChromeBenchmarkMetadata>; + + static constexpr FieldMetadata_BenchmarkStartTimeUs kBenchmarkStartTimeUs{}; + void set_benchmark_start_time_us(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_BenchmarkStartTimeUs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_StoryRunTimeUs = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + ChromeBenchmarkMetadata>; + + static constexpr FieldMetadata_StoryRunTimeUs kStoryRunTimeUs{}; + void set_story_run_time_us(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_StoryRunTimeUs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_BenchmarkName = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + ChromeBenchmarkMetadata>; + + static constexpr FieldMetadata_BenchmarkName kBenchmarkName{}; + void set_benchmark_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_BenchmarkName::kFieldId, data, size); + } + void set_benchmark_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_BenchmarkName::kFieldId, chars.data, chars.size); + } + void set_benchmark_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_BenchmarkName::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_BenchmarkDescription = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + ChromeBenchmarkMetadata>; + + static constexpr FieldMetadata_BenchmarkDescription kBenchmarkDescription{}; + void set_benchmark_description(const char* data, size_t size) { + AppendBytes(FieldMetadata_BenchmarkDescription::kFieldId, data, size); + } + void set_benchmark_description(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_BenchmarkDescription::kFieldId, chars.data, chars.size); + } + void set_benchmark_description(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_BenchmarkDescription::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Label = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + ChromeBenchmarkMetadata>; + + static constexpr FieldMetadata_Label kLabel{}; + void set_label(const char* data, size_t size) { + AppendBytes(FieldMetadata_Label::kFieldId, data, size); + } + void set_label(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Label::kFieldId, chars.data, chars.size); + } + void set_label(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Label::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_StoryName = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + ChromeBenchmarkMetadata>; + + static constexpr FieldMetadata_StoryName kStoryName{}; + void set_story_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_StoryName::kFieldId, data, size); + } + void set_story_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_StoryName::kFieldId, chars.data, chars.size); + } + void set_story_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_StoryName::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_StoryTags = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + ChromeBenchmarkMetadata>; + + static constexpr FieldMetadata_StoryTags kStoryTags{}; + void add_story_tags(const char* data, size_t size) { + AppendBytes(FieldMetadata_StoryTags::kFieldId, data, size); + } + void add_story_tags(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_StoryTags::kFieldId, chars.data, chars.size); + } + void add_story_tags(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_StoryTags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_StoryRunIndex = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + ChromeBenchmarkMetadata>; + + static constexpr FieldMetadata_StoryRunIndex kStoryRunIndex{}; + void set_story_run_index(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_StoryRunIndex::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_HadFailures = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + ChromeBenchmarkMetadata>; + + static constexpr FieldMetadata_HadFailures kHadFailures{}; + void set_had_failures(bool value) { + static constexpr uint32_t field_id = FieldMetadata_HadFailures::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } +}; + +class DisplayState_Decoder : public ::protozero::TypedProtoDecoder { + public: + DisplayState_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit DisplayState_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit DisplayState_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_id() const { return at<1>().valid(); } + int32_t id() const { return at<1>().as_int32(); } + bool has_what() const { return at<2>().valid(); } + uint32_t what() const { return at<2>().as_uint32(); } + bool has_flags() const { return at<3>().valid(); } + uint32_t flags() const { return at<3>().as_uint32(); } + bool has_layer_stack() const { return at<4>().valid(); } + uint32_t layer_stack() const { return at<4>().as_uint32(); } + bool has_orientation() const { return at<5>().valid(); } + uint32_t orientation() const { return at<5>().as_uint32(); } + bool has_layer_stack_space_rect() const { return at<6>().valid(); } + ::protozero::ConstBytes layer_stack_space_rect() const { return at<6>().as_bytes(); } + bool has_oriented_display_space_rect() const { return at<7>().valid(); } + ::protozero::ConstBytes oriented_display_space_rect() const { return at<7>().as_bytes(); } + bool has_width() const { return at<8>().valid(); } + uint32_t width() const { return at<8>().as_uint32(); } + bool has_height() const { return at<9>().valid(); } + uint32_t height() const { return at<9>().as_uint32(); } +}; + +class DisplayState : public ::protozero::Message { + public: + using Decoder = DisplayState_Decoder; + enum : int32_t { + kIdFieldNumber = 1, + kWhatFieldNumber = 2, + kFlagsFieldNumber = 3, + kLayerStackFieldNumber = 4, + kOrientationFieldNumber = 5, + kLayerStackSpaceRectFieldNumber = 6, + kOrientedDisplaySpaceRectFieldNumber = 7, + kWidthFieldNumber = 8, + kHeightFieldNumber = 9, + }; + static constexpr const char* GetName() { return ".perfetto.protos.DisplayState"; } + + + using Changes = ::perfetto::protos::pbzero::DisplayState_Changes; + static inline const char* Changes_Name(Changes value) { + return ::perfetto::protos::pbzero::DisplayState_Changes_Name(value); + } + static inline const Changes eChangesNone = Changes::eChangesNone; + static inline const Changes eSurfaceChanged = Changes::eSurfaceChanged; + static inline const Changes eLayerStackChanged = Changes::eLayerStackChanged; + static inline const Changes eDisplayProjectionChanged = Changes::eDisplayProjectionChanged; + static inline const Changes eDisplaySizeChanged = Changes::eDisplaySizeChanged; + static inline const Changes eFlagsChanged = Changes::eFlagsChanged; + + using FieldMetadata_Id = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + DisplayState>; + + static constexpr FieldMetadata_Id kId{}; + void set_id(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_What = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + DisplayState>; + + static constexpr FieldMetadata_What kWhat{}; + void set_what(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_What::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Flags = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + DisplayState>; + + static constexpr FieldMetadata_Flags kFlags{}; + void set_flags(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_LayerStack = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + DisplayState>; + + static constexpr FieldMetadata_LayerStack kLayerStack{}; + void set_layer_stack(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_LayerStack::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Orientation = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + DisplayState>; + + static constexpr FieldMetadata_Orientation kOrientation{}; + void set_orientation(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Orientation::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_LayerStackSpaceRect = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + RectProto, + DisplayState>; + + static constexpr FieldMetadata_LayerStackSpaceRect kLayerStackSpaceRect{}; + template T* set_layer_stack_space_rect() { + return BeginNestedMessage(6); + } + + + using FieldMetadata_OrientedDisplaySpaceRect = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + RectProto, + DisplayState>; + + static constexpr FieldMetadata_OrientedDisplaySpaceRect kOrientedDisplaySpaceRect{}; + template T* set_oriented_display_space_rect() { + return BeginNestedMessage(7); + } + + + using FieldMetadata_Width = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + DisplayState>; + + static constexpr FieldMetadata_Width kWidth{}; + void set_width(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Width::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Height = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + DisplayState>; + + static constexpr FieldMetadata_Height kHeight{}; + void set_height(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Height::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class LayerState_Decoder : public ::protozero::TypedProtoDecoder { + public: + LayerState_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit LayerState_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit LayerState_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_layer_id() const { return at<1>().valid(); } + uint32_t layer_id() const { return at<1>().as_uint32(); } + bool has_what() const { return at<2>().valid(); } + uint64_t what() const { return at<2>().as_uint64(); } + bool has_x() const { return at<3>().valid(); } + float x() const { return at<3>().as_float(); } + bool has_y() const { return at<4>().valid(); } + float y() const { return at<4>().as_float(); } + bool has_z() const { return at<5>().valid(); } + int32_t z() const { return at<5>().as_int32(); } + bool has_w() const { return at<6>().valid(); } + uint32_t w() const { return at<6>().as_uint32(); } + bool has_h() const { return at<7>().valid(); } + uint32_t h() const { return at<7>().as_uint32(); } + bool has_layer_stack() const { return at<8>().valid(); } + uint32_t layer_stack() const { return at<8>().as_uint32(); } + bool has_flags() const { return at<9>().valid(); } + uint32_t flags() const { return at<9>().as_uint32(); } + bool has_mask() const { return at<10>().valid(); } + uint32_t mask() const { return at<10>().as_uint32(); } + bool has_matrix() const { return at<11>().valid(); } + ::protozero::ConstBytes matrix() const { return at<11>().as_bytes(); } + bool has_corner_radius() const { return at<12>().valid(); } + float corner_radius() const { return at<12>().as_float(); } + bool has_background_blur_radius() const { return at<13>().valid(); } + uint32_t background_blur_radius() const { return at<13>().as_uint32(); } + bool has_parent_id() const { return at<14>().valid(); } + uint32_t parent_id() const { return at<14>().as_uint32(); } + bool has_relative_parent_id() const { return at<15>().valid(); } + uint32_t relative_parent_id() const { return at<15>().as_uint32(); } + bool has_alpha() const { return at<16>().valid(); } + float alpha() const { return at<16>().as_float(); } + bool has_color() const { return at<17>().valid(); } + ::protozero::ConstBytes color() const { return at<17>().as_bytes(); } + bool has_transparent_region() const { return at<18>().valid(); } + ::protozero::ConstBytes transparent_region() const { return at<18>().as_bytes(); } + bool has_transform() const { return at<19>().valid(); } + uint32_t transform() const { return at<19>().as_uint32(); } + bool has_transform_to_display_inverse() const { return at<20>().valid(); } + bool transform_to_display_inverse() const { return at<20>().as_bool(); } + bool has_crop() const { return at<21>().valid(); } + ::protozero::ConstBytes crop() const { return at<21>().as_bytes(); } + bool has_buffer_data() const { return at<22>().valid(); } + ::protozero::ConstBytes buffer_data() const { return at<22>().as_bytes(); } + bool has_api() const { return at<23>().valid(); } + int32_t api() const { return at<23>().as_int32(); } + bool has_has_sideband_stream() const { return at<24>().valid(); } + bool has_sideband_stream() const { return at<24>().as_bool(); } + bool has_color_transform() const { return at<25>().valid(); } + ::protozero::ConstBytes color_transform() const { return at<25>().as_bytes(); } + bool has_blur_regions() const { return at<26>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> blur_regions() const { return GetRepeated<::protozero::ConstBytes>(26); } + bool has_window_info_handle() const { return at<27>().valid(); } + ::protozero::ConstBytes window_info_handle() const { return at<27>().as_bytes(); } + bool has_bg_color_alpha() const { return at<28>().valid(); } + float bg_color_alpha() const { return at<28>().as_float(); } + bool has_bg_color_dataspace() const { return at<29>().valid(); } + int32_t bg_color_dataspace() const { return at<29>().as_int32(); } + bool has_color_space_agnostic() const { return at<30>().valid(); } + bool color_space_agnostic() const { return at<30>().as_bool(); } + bool has_shadow_radius() const { return at<31>().valid(); } + float shadow_radius() const { return at<31>().as_float(); } + bool has_frame_rate_selection_priority() const { return at<32>().valid(); } + int32_t frame_rate_selection_priority() const { return at<32>().as_int32(); } + bool has_frame_rate() const { return at<33>().valid(); } + float frame_rate() const { return at<33>().as_float(); } + bool has_frame_rate_compatibility() const { return at<34>().valid(); } + int32_t frame_rate_compatibility() const { return at<34>().as_int32(); } + bool has_change_frame_rate_strategy() const { return at<35>().valid(); } + int32_t change_frame_rate_strategy() const { return at<35>().as_int32(); } + bool has_fixed_transform_hint() const { return at<36>().valid(); } + uint32_t fixed_transform_hint() const { return at<36>().as_uint32(); } + bool has_frame_number() const { return at<37>().valid(); } + uint64_t frame_number() const { return at<37>().as_uint64(); } + bool has_auto_refresh() const { return at<38>().valid(); } + bool auto_refresh() const { return at<38>().as_bool(); } + bool has_is_trusted_overlay() const { return at<39>().valid(); } + bool is_trusted_overlay() const { return at<39>().as_bool(); } + bool has_buffer_crop() const { return at<40>().valid(); } + ::protozero::ConstBytes buffer_crop() const { return at<40>().as_bytes(); } + bool has_destination_frame() const { return at<41>().valid(); } + ::protozero::ConstBytes destination_frame() const { return at<41>().as_bytes(); } + bool has_drop_input_mode() const { return at<42>().valid(); } + int32_t drop_input_mode() const { return at<42>().as_int32(); } +}; + +class LayerState : public ::protozero::Message { + public: + using Decoder = LayerState_Decoder; + enum : int32_t { + kLayerIdFieldNumber = 1, + kWhatFieldNumber = 2, + kXFieldNumber = 3, + kYFieldNumber = 4, + kZFieldNumber = 5, + kWFieldNumber = 6, + kHFieldNumber = 7, + kLayerStackFieldNumber = 8, + kFlagsFieldNumber = 9, + kMaskFieldNumber = 10, + kMatrixFieldNumber = 11, + kCornerRadiusFieldNumber = 12, + kBackgroundBlurRadiusFieldNumber = 13, + kParentIdFieldNumber = 14, + kRelativeParentIdFieldNumber = 15, + kAlphaFieldNumber = 16, + kColorFieldNumber = 17, + kTransparentRegionFieldNumber = 18, + kTransformFieldNumber = 19, + kTransformToDisplayInverseFieldNumber = 20, + kCropFieldNumber = 21, + kBufferDataFieldNumber = 22, + kApiFieldNumber = 23, + kHasSidebandStreamFieldNumber = 24, + kColorTransformFieldNumber = 25, + kBlurRegionsFieldNumber = 26, + kWindowInfoHandleFieldNumber = 27, + kBgColorAlphaFieldNumber = 28, + kBgColorDataspaceFieldNumber = 29, + kColorSpaceAgnosticFieldNumber = 30, + kShadowRadiusFieldNumber = 31, + kFrameRateSelectionPriorityFieldNumber = 32, + kFrameRateFieldNumber = 33, + kFrameRateCompatibilityFieldNumber = 34, + kChangeFrameRateStrategyFieldNumber = 35, + kFixedTransformHintFieldNumber = 36, + kFrameNumberFieldNumber = 37, + kAutoRefreshFieldNumber = 38, + kIsTrustedOverlayFieldNumber = 39, + kBufferCropFieldNumber = 40, + kDestinationFrameFieldNumber = 41, + kDropInputModeFieldNumber = 42, + }; + static constexpr const char* GetName() { return ".perfetto.protos.LayerState"; } + + using Matrix22 = ::perfetto::protos::pbzero::LayerState_Matrix22; + using Color3 = ::perfetto::protos::pbzero::LayerState_Color3; + using BufferData = ::perfetto::protos::pbzero::LayerState_BufferData; + using WindowInfo = ::perfetto::protos::pbzero::LayerState_WindowInfo; + + using ChangesLsb = ::perfetto::protos::pbzero::LayerState_ChangesLsb; + static inline const char* ChangesLsb_Name(ChangesLsb value) { + return ::perfetto::protos::pbzero::LayerState_ChangesLsb_Name(value); + } + + using ChangesMsb = ::perfetto::protos::pbzero::LayerState_ChangesMsb; + static inline const char* ChangesMsb_Name(ChangesMsb value) { + return ::perfetto::protos::pbzero::LayerState_ChangesMsb_Name(value); + } + + using Flags = ::perfetto::protos::pbzero::LayerState_Flags; + static inline const char* Flags_Name(Flags value) { + return ::perfetto::protos::pbzero::LayerState_Flags_Name(value); + } + + using DropInputMode = ::perfetto::protos::pbzero::LayerState_DropInputMode; + static inline const char* DropInputMode_Name(DropInputMode value) { + return ::perfetto::protos::pbzero::LayerState_DropInputMode_Name(value); + } + static inline const ChangesLsb eChangesLsbNone = ChangesLsb::eChangesLsbNone; + static inline const ChangesLsb ePositionChanged = ChangesLsb::ePositionChanged; + static inline const ChangesLsb eLayerChanged = ChangesLsb::eLayerChanged; + static inline const ChangesLsb eAlphaChanged = ChangesLsb::eAlphaChanged; + static inline const ChangesLsb eMatrixChanged = ChangesLsb::eMatrixChanged; + static inline const ChangesLsb eTransparentRegionChanged = ChangesLsb::eTransparentRegionChanged; + static inline const ChangesLsb eFlagsChanged = ChangesLsb::eFlagsChanged; + static inline const ChangesLsb eLayerStackChanged = ChangesLsb::eLayerStackChanged; + static inline const ChangesLsb eReleaseBufferListenerChanged = ChangesLsb::eReleaseBufferListenerChanged; + static inline const ChangesLsb eShadowRadiusChanged = ChangesLsb::eShadowRadiusChanged; + static inline const ChangesLsb eBufferCropChanged = ChangesLsb::eBufferCropChanged; + static inline const ChangesLsb eRelativeLayerChanged = ChangesLsb::eRelativeLayerChanged; + static inline const ChangesLsb eReparent = ChangesLsb::eReparent; + static inline const ChangesLsb eColorChanged = ChangesLsb::eColorChanged; + static inline const ChangesLsb eBufferTransformChanged = ChangesLsb::eBufferTransformChanged; + static inline const ChangesLsb eTransformToDisplayInverseChanged = ChangesLsb::eTransformToDisplayInverseChanged; + static inline const ChangesLsb eCropChanged = ChangesLsb::eCropChanged; + static inline const ChangesLsb eBufferChanged = ChangesLsb::eBufferChanged; + static inline const ChangesLsb eAcquireFenceChanged = ChangesLsb::eAcquireFenceChanged; + static inline const ChangesLsb eDataspaceChanged = ChangesLsb::eDataspaceChanged; + static inline const ChangesLsb eHdrMetadataChanged = ChangesLsb::eHdrMetadataChanged; + static inline const ChangesLsb eSurfaceDamageRegionChanged = ChangesLsb::eSurfaceDamageRegionChanged; + static inline const ChangesLsb eApiChanged = ChangesLsb::eApiChanged; + static inline const ChangesLsb eSidebandStreamChanged = ChangesLsb::eSidebandStreamChanged; + static inline const ChangesLsb eColorTransformChanged = ChangesLsb::eColorTransformChanged; + static inline const ChangesLsb eHasListenerCallbacksChanged = ChangesLsb::eHasListenerCallbacksChanged; + static inline const ChangesLsb eInputInfoChanged = ChangesLsb::eInputInfoChanged; + static inline const ChangesLsb eCornerRadiusChanged = ChangesLsb::eCornerRadiusChanged; + static inline const ChangesMsb eChangesMsbNone = ChangesMsb::eChangesMsbNone; + static inline const ChangesMsb eDestinationFrameChanged = ChangesMsb::eDestinationFrameChanged; + static inline const ChangesMsb eCachedBufferChanged = ChangesMsb::eCachedBufferChanged; + static inline const ChangesMsb eBackgroundColorChanged = ChangesMsb::eBackgroundColorChanged; + static inline const ChangesMsb eMetadataChanged = ChangesMsb::eMetadataChanged; + static inline const ChangesMsb eColorSpaceAgnosticChanged = ChangesMsb::eColorSpaceAgnosticChanged; + static inline const ChangesMsb eFrameRateSelectionPriority = ChangesMsb::eFrameRateSelectionPriority; + static inline const ChangesMsb eFrameRateChanged = ChangesMsb::eFrameRateChanged; + static inline const ChangesMsb eBackgroundBlurRadiusChanged = ChangesMsb::eBackgroundBlurRadiusChanged; + static inline const ChangesMsb eProducerDisconnect = ChangesMsb::eProducerDisconnect; + static inline const ChangesMsb eFixedTransformHintChanged = ChangesMsb::eFixedTransformHintChanged; + static inline const ChangesMsb eFrameNumberChanged = ChangesMsb::eFrameNumberChanged; + static inline const ChangesMsb eBlurRegionsChanged = ChangesMsb::eBlurRegionsChanged; + static inline const ChangesMsb eAutoRefreshChanged = ChangesMsb::eAutoRefreshChanged; + static inline const ChangesMsb eStretchChanged = ChangesMsb::eStretchChanged; + static inline const ChangesMsb eTrustedOverlayChanged = ChangesMsb::eTrustedOverlayChanged; + static inline const ChangesMsb eDropInputModeChanged = ChangesMsb::eDropInputModeChanged; + static inline const Flags eFlagsNone = Flags::eFlagsNone; + static inline const Flags eLayerHidden = Flags::eLayerHidden; + static inline const Flags eLayerOpaque = Flags::eLayerOpaque; + static inline const Flags eLayerSkipScreenshot = Flags::eLayerSkipScreenshot; + static inline const Flags eLayerSecure = Flags::eLayerSecure; + static inline const Flags eEnableBackpressure = Flags::eEnableBackpressure; + static inline const Flags eLayerIsDisplayDecoration = Flags::eLayerIsDisplayDecoration; + static inline const DropInputMode NONE = DropInputMode::NONE; + static inline const DropInputMode ALL = DropInputMode::ALL; + static inline const DropInputMode OBSCURED = DropInputMode::OBSCURED; + + using FieldMetadata_LayerId = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + LayerState>; + + static constexpr FieldMetadata_LayerId kLayerId{}; + void set_layer_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_LayerId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_What = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + LayerState>; + + static constexpr FieldMetadata_What kWhat{}; + void set_what(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_What::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_X = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + LayerState>; + + static constexpr FieldMetadata_X kX{}; + void set_x(float value) { + static constexpr uint32_t field_id = FieldMetadata_X::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Y = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + LayerState>; + + static constexpr FieldMetadata_Y kY{}; + void set_y(float value) { + static constexpr uint32_t field_id = FieldMetadata_Y::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Z = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + LayerState>; + + static constexpr FieldMetadata_Z kZ{}; + void set_z(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Z::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_W = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + LayerState>; + + static constexpr FieldMetadata_W kW{}; + void set_w(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_W::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_H = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + LayerState>; + + static constexpr FieldMetadata_H kH{}; + void set_h(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_H::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_LayerStack = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + LayerState>; + + static constexpr FieldMetadata_LayerStack kLayerStack{}; + void set_layer_stack(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_LayerStack::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Flags = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + LayerState>; + + static constexpr FieldMetadata_Flags kFlags{}; + void set_flags(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Mask = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + LayerState>; + + static constexpr FieldMetadata_Mask kMask{}; + void set_mask(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Mask::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Matrix = + ::protozero::proto_utils::FieldMetadata< + 11, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + LayerState_Matrix22, + LayerState>; + + static constexpr FieldMetadata_Matrix kMatrix{}; + template T* set_matrix() { + return BeginNestedMessage(11); + } + + + using FieldMetadata_CornerRadius = + ::protozero::proto_utils::FieldMetadata< + 12, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + LayerState>; + + static constexpr FieldMetadata_CornerRadius kCornerRadius{}; + void set_corner_radius(float value) { + static constexpr uint32_t field_id = FieldMetadata_CornerRadius::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } + + using FieldMetadata_BackgroundBlurRadius = + ::protozero::proto_utils::FieldMetadata< + 13, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + LayerState>; + + static constexpr FieldMetadata_BackgroundBlurRadius kBackgroundBlurRadius{}; + void set_background_blur_radius(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_BackgroundBlurRadius::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ParentId = + ::protozero::proto_utils::FieldMetadata< + 14, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + LayerState>; + + static constexpr FieldMetadata_ParentId kParentId{}; + void set_parent_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ParentId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_RelativeParentId = + ::protozero::proto_utils::FieldMetadata< + 15, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + LayerState>; + + static constexpr FieldMetadata_RelativeParentId kRelativeParentId{}; + void set_relative_parent_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_RelativeParentId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Alpha = + ::protozero::proto_utils::FieldMetadata< + 16, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + LayerState>; + + static constexpr FieldMetadata_Alpha kAlpha{}; + void set_alpha(float value) { + static constexpr uint32_t field_id = FieldMetadata_Alpha::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Color = + ::protozero::proto_utils::FieldMetadata< + 17, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + LayerState_Color3, + LayerState>; + + static constexpr FieldMetadata_Color kColor{}; + template T* set_color() { + return BeginNestedMessage(17); + } + + + using FieldMetadata_TransparentRegion = + ::protozero::proto_utils::FieldMetadata< + 18, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + RegionProto, + LayerState>; + + static constexpr FieldMetadata_TransparentRegion kTransparentRegion{}; + template T* set_transparent_region() { + return BeginNestedMessage(18); + } + + + using FieldMetadata_Transform = + ::protozero::proto_utils::FieldMetadata< + 19, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + LayerState>; + + static constexpr FieldMetadata_Transform kTransform{}; + void set_transform(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Transform::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TransformToDisplayInverse = + ::protozero::proto_utils::FieldMetadata< + 20, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + LayerState>; + + static constexpr FieldMetadata_TransformToDisplayInverse kTransformToDisplayInverse{}; + void set_transform_to_display_inverse(bool value) { + static constexpr uint32_t field_id = FieldMetadata_TransformToDisplayInverse::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Crop = + ::protozero::proto_utils::FieldMetadata< + 21, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + RectProto, + LayerState>; + + static constexpr FieldMetadata_Crop kCrop{}; + template T* set_crop() { + return BeginNestedMessage(21); + } + + + using FieldMetadata_BufferData = + ::protozero::proto_utils::FieldMetadata< + 22, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + LayerState_BufferData, + LayerState>; + + static constexpr FieldMetadata_BufferData kBufferData{}; + template T* set_buffer_data() { + return BeginNestedMessage(22); + } + + + using FieldMetadata_Api = + ::protozero::proto_utils::FieldMetadata< + 23, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + LayerState>; + + static constexpr FieldMetadata_Api kApi{}; + void set_api(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Api::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_HasSidebandStream = + ::protozero::proto_utils::FieldMetadata< + 24, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + LayerState>; + + static constexpr FieldMetadata_HasSidebandStream kHasSidebandStream{}; + void set_has_sideband_stream(bool value) { + static constexpr uint32_t field_id = FieldMetadata_HasSidebandStream::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ColorTransform = + ::protozero::proto_utils::FieldMetadata< + 25, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ColorTransformProto, + LayerState>; + + static constexpr FieldMetadata_ColorTransform kColorTransform{}; + template T* set_color_transform() { + return BeginNestedMessage(25); + } + + + using FieldMetadata_BlurRegions = + ::protozero::proto_utils::FieldMetadata< + 26, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + BlurRegion, + LayerState>; + + static constexpr FieldMetadata_BlurRegions kBlurRegions{}; + template T* add_blur_regions() { + return BeginNestedMessage(26); + } + + + using FieldMetadata_WindowInfoHandle = + ::protozero::proto_utils::FieldMetadata< + 27, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + LayerState_WindowInfo, + LayerState>; + + static constexpr FieldMetadata_WindowInfoHandle kWindowInfoHandle{}; + template T* set_window_info_handle() { + return BeginNestedMessage(27); + } + + + using FieldMetadata_BgColorAlpha = + ::protozero::proto_utils::FieldMetadata< + 28, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + LayerState>; + + static constexpr FieldMetadata_BgColorAlpha kBgColorAlpha{}; + void set_bg_color_alpha(float value) { + static constexpr uint32_t field_id = FieldMetadata_BgColorAlpha::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } + + using FieldMetadata_BgColorDataspace = + ::protozero::proto_utils::FieldMetadata< + 29, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + LayerState>; + + static constexpr FieldMetadata_BgColorDataspace kBgColorDataspace{}; + void set_bg_color_dataspace(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_BgColorDataspace::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ColorSpaceAgnostic = + ::protozero::proto_utils::FieldMetadata< + 30, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + LayerState>; + + static constexpr FieldMetadata_ColorSpaceAgnostic kColorSpaceAgnostic{}; + void set_color_space_agnostic(bool value) { + static constexpr uint32_t field_id = FieldMetadata_ColorSpaceAgnostic::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ShadowRadius = + ::protozero::proto_utils::FieldMetadata< + 31, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + LayerState>; + + static constexpr FieldMetadata_ShadowRadius kShadowRadius{}; + void set_shadow_radius(float value) { + static constexpr uint32_t field_id = FieldMetadata_ShadowRadius::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FrameRateSelectionPriority = + ::protozero::proto_utils::FieldMetadata< + 32, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + LayerState>; + + static constexpr FieldMetadata_FrameRateSelectionPriority kFrameRateSelectionPriority{}; + void set_frame_rate_selection_priority(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_FrameRateSelectionPriority::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FrameRate = + ::protozero::proto_utils::FieldMetadata< + 33, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + LayerState>; + + static constexpr FieldMetadata_FrameRate kFrameRate{}; + void set_frame_rate(float value) { + static constexpr uint32_t field_id = FieldMetadata_FrameRate::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FrameRateCompatibility = + ::protozero::proto_utils::FieldMetadata< + 34, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + LayerState>; + + static constexpr FieldMetadata_FrameRateCompatibility kFrameRateCompatibility{}; + void set_frame_rate_compatibility(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_FrameRateCompatibility::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ChangeFrameRateStrategy = + ::protozero::proto_utils::FieldMetadata< + 35, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + LayerState>; + + static constexpr FieldMetadata_ChangeFrameRateStrategy kChangeFrameRateStrategy{}; + void set_change_frame_rate_strategy(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ChangeFrameRateStrategy::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FixedTransformHint = + ::protozero::proto_utils::FieldMetadata< + 36, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + LayerState>; + + static constexpr FieldMetadata_FixedTransformHint kFixedTransformHint{}; + void set_fixed_transform_hint(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_FixedTransformHint::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FrameNumber = + ::protozero::proto_utils::FieldMetadata< + 37, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + LayerState>; + + static constexpr FieldMetadata_FrameNumber kFrameNumber{}; + void set_frame_number(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_FrameNumber::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_AutoRefresh = + ::protozero::proto_utils::FieldMetadata< + 38, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + LayerState>; + + static constexpr FieldMetadata_AutoRefresh kAutoRefresh{}; + void set_auto_refresh(bool value) { + static constexpr uint32_t field_id = FieldMetadata_AutoRefresh::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_IsTrustedOverlay = + ::protozero::proto_utils::FieldMetadata< + 39, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + LayerState>; + + static constexpr FieldMetadata_IsTrustedOverlay kIsTrustedOverlay{}; + void set_is_trusted_overlay(bool value) { + static constexpr uint32_t field_id = FieldMetadata_IsTrustedOverlay::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_BufferCrop = + ::protozero::proto_utils::FieldMetadata< + 40, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + RectProto, + LayerState>; + + static constexpr FieldMetadata_BufferCrop kBufferCrop{}; + template T* set_buffer_crop() { + return BeginNestedMessage(40); + } + + + using FieldMetadata_DestinationFrame = + ::protozero::proto_utils::FieldMetadata< + 41, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + RectProto, + LayerState>; + + static constexpr FieldMetadata_DestinationFrame kDestinationFrame{}; + template T* set_destination_frame() { + return BeginNestedMessage(41); + } + + + using FieldMetadata_DropInputMode = + ::protozero::proto_utils::FieldMetadata< + 42, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + LayerState_DropInputMode, + LayerState>; + + static constexpr FieldMetadata_DropInputMode kDropInputMode{}; + void set_drop_input_mode(LayerState_DropInputMode value) { + static constexpr uint32_t field_id = FieldMetadata_DropInputMode::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } +}; + +class LayerState_WindowInfo_Decoder : public ::protozero::TypedProtoDecoder { + public: + LayerState_WindowInfo_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit LayerState_WindowInfo_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit LayerState_WindowInfo_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_layout_params_flags() const { return at<1>().valid(); } + uint32_t layout_params_flags() const { return at<1>().as_uint32(); } + bool has_layout_params_type() const { return at<2>().valid(); } + int32_t layout_params_type() const { return at<2>().as_int32(); } + bool has_touchable_region() const { return at<3>().valid(); } + ::protozero::ConstBytes touchable_region() const { return at<3>().as_bytes(); } + bool has_surface_inset() const { return at<4>().valid(); } + int32_t surface_inset() const { return at<4>().as_int32(); } + bool has_focusable() const { return at<5>().valid(); } + bool focusable() const { return at<5>().as_bool(); } + bool has_has_wallpaper() const { return at<6>().valid(); } + bool has_wallpaper() const { return at<6>().as_bool(); } + bool has_global_scale_factor() const { return at<7>().valid(); } + float global_scale_factor() const { return at<7>().as_float(); } + bool has_crop_layer_id() const { return at<8>().valid(); } + uint32_t crop_layer_id() const { return at<8>().as_uint32(); } + bool has_replace_touchable_region_with_crop() const { return at<9>().valid(); } + bool replace_touchable_region_with_crop() const { return at<9>().as_bool(); } + bool has_touchable_region_crop() const { return at<10>().valid(); } + ::protozero::ConstBytes touchable_region_crop() const { return at<10>().as_bytes(); } + bool has_transform() const { return at<11>().valid(); } + ::protozero::ConstBytes transform() const { return at<11>().as_bytes(); } + bool has_input_config() const { return at<12>().valid(); } + uint32_t input_config() const { return at<12>().as_uint32(); } +}; + +class LayerState_WindowInfo : public ::protozero::Message { + public: + using Decoder = LayerState_WindowInfo_Decoder; + enum : int32_t { + kLayoutParamsFlagsFieldNumber = 1, + kLayoutParamsTypeFieldNumber = 2, + kTouchableRegionFieldNumber = 3, + kSurfaceInsetFieldNumber = 4, + kFocusableFieldNumber = 5, + kHasWallpaperFieldNumber = 6, + kGlobalScaleFactorFieldNumber = 7, + kCropLayerIdFieldNumber = 8, + kReplaceTouchableRegionWithCropFieldNumber = 9, + kTouchableRegionCropFieldNumber = 10, + kTransformFieldNumber = 11, + kInputConfigFieldNumber = 12, + }; + static constexpr const char* GetName() { return ".perfetto.protos.LayerState.WindowInfo"; } + + + using FieldMetadata_LayoutParamsFlags = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + LayerState_WindowInfo>; + + static constexpr FieldMetadata_LayoutParamsFlags kLayoutParamsFlags{}; + void set_layout_params_flags(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_LayoutParamsFlags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_LayoutParamsType = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + LayerState_WindowInfo>; + + static constexpr FieldMetadata_LayoutParamsType kLayoutParamsType{}; + void set_layout_params_type(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_LayoutParamsType::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TouchableRegion = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + RegionProto, + LayerState_WindowInfo>; + + static constexpr FieldMetadata_TouchableRegion kTouchableRegion{}; + template T* set_touchable_region() { + return BeginNestedMessage(3); + } + + + using FieldMetadata_SurfaceInset = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + LayerState_WindowInfo>; + + static constexpr FieldMetadata_SurfaceInset kSurfaceInset{}; + void set_surface_inset(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_SurfaceInset::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Focusable = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + LayerState_WindowInfo>; + + static constexpr FieldMetadata_Focusable kFocusable{}; + void set_focusable(bool value) { + static constexpr uint32_t field_id = FieldMetadata_Focusable::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_HasWallpaper = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + LayerState_WindowInfo>; + + static constexpr FieldMetadata_HasWallpaper kHasWallpaper{}; + void set_has_wallpaper(bool value) { + static constexpr uint32_t field_id = FieldMetadata_HasWallpaper::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_GlobalScaleFactor = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + LayerState_WindowInfo>; + + static constexpr FieldMetadata_GlobalScaleFactor kGlobalScaleFactor{}; + void set_global_scale_factor(float value) { + static constexpr uint32_t field_id = FieldMetadata_GlobalScaleFactor::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CropLayerId = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + LayerState_WindowInfo>; + + static constexpr FieldMetadata_CropLayerId kCropLayerId{}; + void set_crop_layer_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_CropLayerId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ReplaceTouchableRegionWithCrop = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + LayerState_WindowInfo>; + + static constexpr FieldMetadata_ReplaceTouchableRegionWithCrop kReplaceTouchableRegionWithCrop{}; + void set_replace_touchable_region_with_crop(bool value) { + static constexpr uint32_t field_id = FieldMetadata_ReplaceTouchableRegionWithCrop::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TouchableRegionCrop = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + RectProto, + LayerState_WindowInfo>; + + static constexpr FieldMetadata_TouchableRegionCrop kTouchableRegionCrop{}; + template T* set_touchable_region_crop() { + return BeginNestedMessage(10); + } + + + using FieldMetadata_Transform = + ::protozero::proto_utils::FieldMetadata< + 11, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Transform, + LayerState_WindowInfo>; + + static constexpr FieldMetadata_Transform kTransform{}; + template T* set_transform() { + return BeginNestedMessage(11); + } + + + using FieldMetadata_InputConfig = + ::protozero::proto_utils::FieldMetadata< + 12, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + LayerState_WindowInfo>; + + static constexpr FieldMetadata_InputConfig kInputConfig{}; + void set_input_config(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_InputConfig::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class LayerState_BufferData_Decoder : public ::protozero::TypedProtoDecoder { + public: + LayerState_BufferData_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit LayerState_BufferData_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit LayerState_BufferData_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_buffer_id() const { return at<1>().valid(); } + uint64_t buffer_id() const { return at<1>().as_uint64(); } + bool has_width() const { return at<2>().valid(); } + uint32_t width() const { return at<2>().as_uint32(); } + bool has_height() const { return at<3>().valid(); } + uint32_t height() const { return at<3>().as_uint32(); } + bool has_frame_number() const { return at<4>().valid(); } + uint64_t frame_number() const { return at<4>().as_uint64(); } + bool has_flags() const { return at<5>().valid(); } + uint32_t flags() const { return at<5>().as_uint32(); } + bool has_cached_buffer_id() const { return at<6>().valid(); } + uint64_t cached_buffer_id() const { return at<6>().as_uint64(); } + bool has_pixel_format() const { return at<7>().valid(); } + int32_t pixel_format() const { return at<7>().as_int32(); } + bool has_usage() const { return at<8>().valid(); } + uint64_t usage() const { return at<8>().as_uint64(); } +}; + +class LayerState_BufferData : public ::protozero::Message { + public: + using Decoder = LayerState_BufferData_Decoder; + enum : int32_t { + kBufferIdFieldNumber = 1, + kWidthFieldNumber = 2, + kHeightFieldNumber = 3, + kFrameNumberFieldNumber = 4, + kFlagsFieldNumber = 5, + kCachedBufferIdFieldNumber = 6, + kPixelFormatFieldNumber = 7, + kUsageFieldNumber = 8, + }; + static constexpr const char* GetName() { return ".perfetto.protos.LayerState.BufferData"; } + + + using BufferDataChange = ::perfetto::protos::pbzero::LayerState_BufferData_BufferDataChange; + static inline const char* BufferDataChange_Name(BufferDataChange value) { + return ::perfetto::protos::pbzero::LayerState_BufferData_BufferDataChange_Name(value); + } + + using PixelFormat = ::perfetto::protos::pbzero::LayerState_BufferData_PixelFormat; + static inline const char* PixelFormat_Name(PixelFormat value) { + return ::perfetto::protos::pbzero::LayerState_BufferData_PixelFormat_Name(value); + } + static inline const BufferDataChange BufferDataChangeNone = BufferDataChange::BufferDataChangeNone; + static inline const BufferDataChange fenceChanged = BufferDataChange::fenceChanged; + static inline const BufferDataChange frameNumberChanged = BufferDataChange::frameNumberChanged; + static inline const BufferDataChange cachedBufferChanged = BufferDataChange::cachedBufferChanged; + static inline const PixelFormat PIXEL_FORMAT_UNKNOWN = PixelFormat::PIXEL_FORMAT_UNKNOWN; + static inline const PixelFormat PIXEL_FORMAT_CUSTOM = PixelFormat::PIXEL_FORMAT_CUSTOM; + static inline const PixelFormat PIXEL_FORMAT_TRANSLUCENT = PixelFormat::PIXEL_FORMAT_TRANSLUCENT; + static inline const PixelFormat PIXEL_FORMAT_TRANSPARENT = PixelFormat::PIXEL_FORMAT_TRANSPARENT; + static inline const PixelFormat PIXEL_FORMAT_OPAQUE = PixelFormat::PIXEL_FORMAT_OPAQUE; + static inline const PixelFormat PIXEL_FORMAT_RGBA_8888 = PixelFormat::PIXEL_FORMAT_RGBA_8888; + static inline const PixelFormat PIXEL_FORMAT_RGBX_8888 = PixelFormat::PIXEL_FORMAT_RGBX_8888; + static inline const PixelFormat PIXEL_FORMAT_RGB_888 = PixelFormat::PIXEL_FORMAT_RGB_888; + static inline const PixelFormat PIXEL_FORMAT_RGB_565 = PixelFormat::PIXEL_FORMAT_RGB_565; + static inline const PixelFormat PIXEL_FORMAT_BGRA_8888 = PixelFormat::PIXEL_FORMAT_BGRA_8888; + static inline const PixelFormat PIXEL_FORMAT_RGBA_5551 = PixelFormat::PIXEL_FORMAT_RGBA_5551; + static inline const PixelFormat PIXEL_FORMAT_RGBA_4444 = PixelFormat::PIXEL_FORMAT_RGBA_4444; + static inline const PixelFormat PIXEL_FORMAT_RGBA_FP16 = PixelFormat::PIXEL_FORMAT_RGBA_FP16; + static inline const PixelFormat PIXEL_FORMAT_RGBA_1010102 = PixelFormat::PIXEL_FORMAT_RGBA_1010102; + static inline const PixelFormat PIXEL_FORMAT_R_8 = PixelFormat::PIXEL_FORMAT_R_8; + + using FieldMetadata_BufferId = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + LayerState_BufferData>; + + static constexpr FieldMetadata_BufferId kBufferId{}; + void set_buffer_id(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_BufferId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Width = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + LayerState_BufferData>; + + static constexpr FieldMetadata_Width kWidth{}; + void set_width(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Width::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Height = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + LayerState_BufferData>; + + static constexpr FieldMetadata_Height kHeight{}; + void set_height(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Height::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FrameNumber = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + LayerState_BufferData>; + + static constexpr FieldMetadata_FrameNumber kFrameNumber{}; + void set_frame_number(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_FrameNumber::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Flags = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + LayerState_BufferData>; + + static constexpr FieldMetadata_Flags kFlags{}; + void set_flags(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CachedBufferId = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + LayerState_BufferData>; + + static constexpr FieldMetadata_CachedBufferId kCachedBufferId{}; + void set_cached_buffer_id(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_CachedBufferId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PixelFormat = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + LayerState_BufferData_PixelFormat, + LayerState_BufferData>; + + static constexpr FieldMetadata_PixelFormat kPixelFormat{}; + void set_pixel_format(LayerState_BufferData_PixelFormat value) { + static constexpr uint32_t field_id = FieldMetadata_PixelFormat::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Usage = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + LayerState_BufferData>; + + static constexpr FieldMetadata_Usage kUsage{}; + void set_usage(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Usage::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class LayerState_Color3_Decoder : public ::protozero::TypedProtoDecoder { + public: + LayerState_Color3_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit LayerState_Color3_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit LayerState_Color3_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_r() const { return at<1>().valid(); } + float r() const { return at<1>().as_float(); } + bool has_g() const { return at<2>().valid(); } + float g() const { return at<2>().as_float(); } + bool has_b() const { return at<3>().valid(); } + float b() const { return at<3>().as_float(); } +}; + +class LayerState_Color3 : public ::protozero::Message { + public: + using Decoder = LayerState_Color3_Decoder; + enum : int32_t { + kRFieldNumber = 1, + kGFieldNumber = 2, + kBFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.LayerState.Color3"; } + + + using FieldMetadata_R = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + LayerState_Color3>; + + static constexpr FieldMetadata_R kR{}; + void set_r(float value) { + static constexpr uint32_t field_id = FieldMetadata_R::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } + + using FieldMetadata_G = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + LayerState_Color3>; + + static constexpr FieldMetadata_G kG{}; + void set_g(float value) { + static constexpr uint32_t field_id = FieldMetadata_G::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } + + using FieldMetadata_B = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + LayerState_Color3>; + + static constexpr FieldMetadata_B kB{}; + void set_b(float value) { + static constexpr uint32_t field_id = FieldMetadata_B::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } +}; + +class LayerState_Matrix22_Decoder : public ::protozero::TypedProtoDecoder { + public: + LayerState_Matrix22_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit LayerState_Matrix22_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit LayerState_Matrix22_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dsdx() const { return at<1>().valid(); } + float dsdx() const { return at<1>().as_float(); } + bool has_dtdx() const { return at<2>().valid(); } + float dtdx() const { return at<2>().as_float(); } + bool has_dtdy() const { return at<3>().valid(); } + float dtdy() const { return at<3>().as_float(); } + bool has_dsdy() const { return at<4>().valid(); } + float dsdy() const { return at<4>().as_float(); } +}; + +class LayerState_Matrix22 : public ::protozero::Message { + public: + using Decoder = LayerState_Matrix22_Decoder; + enum : int32_t { + kDsdxFieldNumber = 1, + kDtdxFieldNumber = 2, + kDtdyFieldNumber = 3, + kDsdyFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.LayerState.Matrix22"; } + + + using FieldMetadata_Dsdx = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + LayerState_Matrix22>; + + static constexpr FieldMetadata_Dsdx kDsdx{}; + void set_dsdx(float value) { + static constexpr uint32_t field_id = FieldMetadata_Dsdx::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Dtdx = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + LayerState_Matrix22>; + + static constexpr FieldMetadata_Dtdx kDtdx{}; + void set_dtdx(float value) { + static constexpr uint32_t field_id = FieldMetadata_Dtdx::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Dtdy = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + LayerState_Matrix22>; + + static constexpr FieldMetadata_Dtdy kDtdy{}; + void set_dtdy(float value) { + static constexpr uint32_t field_id = FieldMetadata_Dtdy::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Dsdy = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + LayerState_Matrix22>; + + static constexpr FieldMetadata_Dsdy kDsdy{}; + void set_dsdy(float value) { + static constexpr uint32_t field_id = FieldMetadata_Dsdy::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } +}; + +class TransactionState_Decoder : public ::protozero::TypedProtoDecoder { + public: + TransactionState_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TransactionState_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TransactionState_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_pid() const { return at<1>().valid(); } + int32_t pid() const { return at<1>().as_int32(); } + bool has_uid() const { return at<2>().valid(); } + int32_t uid() const { return at<2>().as_int32(); } + bool has_vsync_id() const { return at<3>().valid(); } + int64_t vsync_id() const { return at<3>().as_int64(); } + bool has_input_event_id() const { return at<4>().valid(); } + int32_t input_event_id() const { return at<4>().as_int32(); } + bool has_post_time() const { return at<5>().valid(); } + int64_t post_time() const { return at<5>().as_int64(); } + bool has_transaction_id() const { return at<6>().valid(); } + uint64_t transaction_id() const { return at<6>().as_uint64(); } + bool has_layer_changes() const { return at<7>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> layer_changes() const { return GetRepeated<::protozero::ConstBytes>(7); } + bool has_display_changes() const { return at<8>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> display_changes() const { return GetRepeated<::protozero::ConstBytes>(8); } + bool has_merged_transaction_ids() const { return at<9>().valid(); } + ::protozero::RepeatedFieldIterator merged_transaction_ids() const { return GetRepeated(9); } +}; + +class TransactionState : public ::protozero::Message { + public: + using Decoder = TransactionState_Decoder; + enum : int32_t { + kPidFieldNumber = 1, + kUidFieldNumber = 2, + kVsyncIdFieldNumber = 3, + kInputEventIdFieldNumber = 4, + kPostTimeFieldNumber = 5, + kTransactionIdFieldNumber = 6, + kLayerChangesFieldNumber = 7, + kDisplayChangesFieldNumber = 8, + kMergedTransactionIdsFieldNumber = 9, + }; + static constexpr const char* GetName() { return ".perfetto.protos.TransactionState"; } + + + using FieldMetadata_Pid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + TransactionState>; + + static constexpr FieldMetadata_Pid kPid{}; + void set_pid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Uid = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + TransactionState>; + + static constexpr FieldMetadata_Uid kUid{}; + void set_uid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Uid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_VsyncId = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + TransactionState>; + + static constexpr FieldMetadata_VsyncId kVsyncId{}; + void set_vsync_id(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_VsyncId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_InputEventId = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + TransactionState>; + + static constexpr FieldMetadata_InputEventId kInputEventId{}; + void set_input_event_id(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_InputEventId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PostTime = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + TransactionState>; + + static constexpr FieldMetadata_PostTime kPostTime{}; + void set_post_time(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_PostTime::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TransactionId = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TransactionState>; + + static constexpr FieldMetadata_TransactionId kTransactionId{}; + void set_transaction_id(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_TransactionId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_LayerChanges = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + LayerState, + TransactionState>; + + static constexpr FieldMetadata_LayerChanges kLayerChanges{}; + template T* add_layer_changes() { + return BeginNestedMessage(7); + } + + + using FieldMetadata_DisplayChanges = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + DisplayState, + TransactionState>; + + static constexpr FieldMetadata_DisplayChanges kDisplayChanges{}; + template T* add_display_changes() { + return BeginNestedMessage(8); + } + + + using FieldMetadata_MergedTransactionIds = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TransactionState>; + + static constexpr FieldMetadata_MergedTransactionIds kMergedTransactionIds{}; + void add_merged_transaction_ids(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_MergedTransactionIds::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class Transform_Decoder : public ::protozero::TypedProtoDecoder { + public: + Transform_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Transform_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Transform_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dsdx() const { return at<1>().valid(); } + float dsdx() const { return at<1>().as_float(); } + bool has_dtdx() const { return at<2>().valid(); } + float dtdx() const { return at<2>().as_float(); } + bool has_dtdy() const { return at<3>().valid(); } + float dtdy() const { return at<3>().as_float(); } + bool has_dsdy() const { return at<4>().valid(); } + float dsdy() const { return at<4>().as_float(); } + bool has_tx() const { return at<5>().valid(); } + float tx() const { return at<5>().as_float(); } + bool has_ty() const { return at<6>().valid(); } + float ty() const { return at<6>().as_float(); } +}; + +class Transform : public ::protozero::Message { + public: + using Decoder = Transform_Decoder; + enum : int32_t { + kDsdxFieldNumber = 1, + kDtdxFieldNumber = 2, + kDtdyFieldNumber = 3, + kDsdyFieldNumber = 4, + kTxFieldNumber = 5, + kTyFieldNumber = 6, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Transform"; } + + + using FieldMetadata_Dsdx = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + Transform>; + + static constexpr FieldMetadata_Dsdx kDsdx{}; + void set_dsdx(float value) { + static constexpr uint32_t field_id = FieldMetadata_Dsdx::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Dtdx = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + Transform>; + + static constexpr FieldMetadata_Dtdx kDtdx{}; + void set_dtdx(float value) { + static constexpr uint32_t field_id = FieldMetadata_Dtdx::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Dtdy = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + Transform>; + + static constexpr FieldMetadata_Dtdy kDtdy{}; + void set_dtdy(float value) { + static constexpr uint32_t field_id = FieldMetadata_Dtdy::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Dsdy = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + Transform>; + + static constexpr FieldMetadata_Dsdy kDsdy{}; + void set_dsdy(float value) { + static constexpr uint32_t field_id = FieldMetadata_Dsdy::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Tx = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + Transform>; + + static constexpr FieldMetadata_Tx kTx{}; + void set_tx(float value) { + static constexpr uint32_t field_id = FieldMetadata_Tx::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ty = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + Transform>; + + static constexpr FieldMetadata_Ty kTy{}; + void set_ty(float value) { + static constexpr uint32_t field_id = FieldMetadata_Ty::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } +}; + +class LayerCreationArgs_Decoder : public ::protozero::TypedProtoDecoder { + public: + LayerCreationArgs_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit LayerCreationArgs_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit LayerCreationArgs_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_layer_id() const { return at<1>().valid(); } + uint32_t layer_id() const { return at<1>().as_uint32(); } + bool has_name() const { return at<2>().valid(); } + ::protozero::ConstChars name() const { return at<2>().as_string(); } + bool has_flags() const { return at<3>().valid(); } + uint32_t flags() const { return at<3>().as_uint32(); } + bool has_parent_id() const { return at<4>().valid(); } + uint32_t parent_id() const { return at<4>().as_uint32(); } + bool has_mirror_from_id() const { return at<5>().valid(); } + uint32_t mirror_from_id() const { return at<5>().as_uint32(); } + bool has_add_to_root() const { return at<6>().valid(); } + bool add_to_root() const { return at<6>().as_bool(); } + bool has_layer_stack_to_mirror() const { return at<7>().valid(); } + uint32_t layer_stack_to_mirror() const { return at<7>().as_uint32(); } +}; + +class LayerCreationArgs : public ::protozero::Message { + public: + using Decoder = LayerCreationArgs_Decoder; + enum : int32_t { + kLayerIdFieldNumber = 1, + kNameFieldNumber = 2, + kFlagsFieldNumber = 3, + kParentIdFieldNumber = 4, + kMirrorFromIdFieldNumber = 5, + kAddToRootFieldNumber = 6, + kLayerStackToMirrorFieldNumber = 7, + }; + static constexpr const char* GetName() { return ".perfetto.protos.LayerCreationArgs"; } + + + using FieldMetadata_LayerId = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + LayerCreationArgs>; + + static constexpr FieldMetadata_LayerId kLayerId{}; + void set_layer_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_LayerId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + LayerCreationArgs>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Flags = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + LayerCreationArgs>; + + static constexpr FieldMetadata_Flags kFlags{}; + void set_flags(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ParentId = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + LayerCreationArgs>; + + static constexpr FieldMetadata_ParentId kParentId{}; + void set_parent_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ParentId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_MirrorFromId = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + LayerCreationArgs>; + + static constexpr FieldMetadata_MirrorFromId kMirrorFromId{}; + void set_mirror_from_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_MirrorFromId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_AddToRoot = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + LayerCreationArgs>; + + static constexpr FieldMetadata_AddToRoot kAddToRoot{}; + void set_add_to_root(bool value) { + static constexpr uint32_t field_id = FieldMetadata_AddToRoot::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_LayerStackToMirror = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + LayerCreationArgs>; + + static constexpr FieldMetadata_LayerStackToMirror kLayerStackToMirror{}; + void set_layer_stack_to_mirror(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_LayerStackToMirror::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class DisplayInfo_Decoder : public ::protozero::TypedProtoDecoder { + public: + DisplayInfo_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit DisplayInfo_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit DisplayInfo_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_layer_stack() const { return at<1>().valid(); } + uint32_t layer_stack() const { return at<1>().as_uint32(); } + bool has_display_id() const { return at<2>().valid(); } + int32_t display_id() const { return at<2>().as_int32(); } + bool has_logical_width() const { return at<3>().valid(); } + int32_t logical_width() const { return at<3>().as_int32(); } + bool has_logical_height() const { return at<4>().valid(); } + int32_t logical_height() const { return at<4>().as_int32(); } + bool has_transform_inverse() const { return at<5>().valid(); } + ::protozero::ConstBytes transform_inverse() const { return at<5>().as_bytes(); } + bool has_transform() const { return at<6>().valid(); } + ::protozero::ConstBytes transform() const { return at<6>().as_bytes(); } + bool has_receives_input() const { return at<7>().valid(); } + bool receives_input() const { return at<7>().as_bool(); } + bool has_is_secure() const { return at<8>().valid(); } + bool is_secure() const { return at<8>().as_bool(); } + bool has_is_primary() const { return at<9>().valid(); } + bool is_primary() const { return at<9>().as_bool(); } + bool has_is_virtual() const { return at<10>().valid(); } + bool is_virtual() const { return at<10>().as_bool(); } + bool has_rotation_flags() const { return at<11>().valid(); } + int32_t rotation_flags() const { return at<11>().as_int32(); } + bool has_transform_hint() const { return at<12>().valid(); } + int32_t transform_hint() const { return at<12>().as_int32(); } +}; + +class DisplayInfo : public ::protozero::Message { + public: + using Decoder = DisplayInfo_Decoder; + enum : int32_t { + kLayerStackFieldNumber = 1, + kDisplayIdFieldNumber = 2, + kLogicalWidthFieldNumber = 3, + kLogicalHeightFieldNumber = 4, + kTransformInverseFieldNumber = 5, + kTransformFieldNumber = 6, + kReceivesInputFieldNumber = 7, + kIsSecureFieldNumber = 8, + kIsPrimaryFieldNumber = 9, + kIsVirtualFieldNumber = 10, + kRotationFlagsFieldNumber = 11, + kTransformHintFieldNumber = 12, + }; + static constexpr const char* GetName() { return ".perfetto.protos.DisplayInfo"; } + + + using FieldMetadata_LayerStack = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + DisplayInfo>; + + static constexpr FieldMetadata_LayerStack kLayerStack{}; + void set_layer_stack(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_LayerStack::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DisplayId = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + DisplayInfo>; + + static constexpr FieldMetadata_DisplayId kDisplayId{}; + void set_display_id(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_DisplayId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_LogicalWidth = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + DisplayInfo>; + + static constexpr FieldMetadata_LogicalWidth kLogicalWidth{}; + void set_logical_width(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_LogicalWidth::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_LogicalHeight = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + DisplayInfo>; + + static constexpr FieldMetadata_LogicalHeight kLogicalHeight{}; + void set_logical_height(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_LogicalHeight::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TransformInverse = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Transform, + DisplayInfo>; + + static constexpr FieldMetadata_TransformInverse kTransformInverse{}; + template T* set_transform_inverse() { + return BeginNestedMessage(5); + } + + + using FieldMetadata_Transform = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Transform, + DisplayInfo>; + + static constexpr FieldMetadata_Transform kTransform{}; + template T* set_transform() { + return BeginNestedMessage(6); + } + + + using FieldMetadata_ReceivesInput = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + DisplayInfo>; + + static constexpr FieldMetadata_ReceivesInput kReceivesInput{}; + void set_receives_input(bool value) { + static constexpr uint32_t field_id = FieldMetadata_ReceivesInput::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_IsSecure = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + DisplayInfo>; + + static constexpr FieldMetadata_IsSecure kIsSecure{}; + void set_is_secure(bool value) { + static constexpr uint32_t field_id = FieldMetadata_IsSecure::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_IsPrimary = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + DisplayInfo>; + + static constexpr FieldMetadata_IsPrimary kIsPrimary{}; + void set_is_primary(bool value) { + static constexpr uint32_t field_id = FieldMetadata_IsPrimary::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_IsVirtual = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + DisplayInfo>; + + static constexpr FieldMetadata_IsVirtual kIsVirtual{}; + void set_is_virtual(bool value) { + static constexpr uint32_t field_id = FieldMetadata_IsVirtual::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_RotationFlags = + ::protozero::proto_utils::FieldMetadata< + 11, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + DisplayInfo>; + + static constexpr FieldMetadata_RotationFlags kRotationFlags{}; + void set_rotation_flags(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_RotationFlags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TransformHint = + ::protozero::proto_utils::FieldMetadata< + 12, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + DisplayInfo>; + + static constexpr FieldMetadata_TransformHint kTransformHint{}; + void set_transform_hint(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TransformHint::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class TransactionTraceEntry_Decoder : public ::protozero::TypedProtoDecoder { + public: + TransactionTraceEntry_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TransactionTraceEntry_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TransactionTraceEntry_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_elapsed_realtime_nanos() const { return at<1>().valid(); } + int64_t elapsed_realtime_nanos() const { return at<1>().as_int64(); } + bool has_vsync_id() const { return at<2>().valid(); } + int64_t vsync_id() const { return at<2>().as_int64(); } + bool has_transactions() const { return at<3>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> transactions() const { return GetRepeated<::protozero::ConstBytes>(3); } + bool has_added_layers() const { return at<4>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> added_layers() const { return GetRepeated<::protozero::ConstBytes>(4); } + bool has_destroyed_layers() const { return at<5>().valid(); } + ::protozero::RepeatedFieldIterator destroyed_layers() const { return GetRepeated(5); } + bool has_added_displays() const { return at<6>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> added_displays() const { return GetRepeated<::protozero::ConstBytes>(6); } + bool has_removed_displays() const { return at<7>().valid(); } + ::protozero::RepeatedFieldIterator removed_displays() const { return GetRepeated(7); } + bool has_destroyed_layer_handles() const { return at<8>().valid(); } + ::protozero::RepeatedFieldIterator destroyed_layer_handles() const { return GetRepeated(8); } + bool has_displays_changed() const { return at<9>().valid(); } + bool displays_changed() const { return at<9>().as_bool(); } + bool has_displays() const { return at<10>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> displays() const { return GetRepeated<::protozero::ConstBytes>(10); } +}; + +class TransactionTraceEntry : public ::protozero::Message { + public: + using Decoder = TransactionTraceEntry_Decoder; + enum : int32_t { + kElapsedRealtimeNanosFieldNumber = 1, + kVsyncIdFieldNumber = 2, + kTransactionsFieldNumber = 3, + kAddedLayersFieldNumber = 4, + kDestroyedLayersFieldNumber = 5, + kAddedDisplaysFieldNumber = 6, + kRemovedDisplaysFieldNumber = 7, + kDestroyedLayerHandlesFieldNumber = 8, + kDisplaysChangedFieldNumber = 9, + kDisplaysFieldNumber = 10, + }; + static constexpr const char* GetName() { return ".perfetto.protos.TransactionTraceEntry"; } + + + using FieldMetadata_ElapsedRealtimeNanos = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + TransactionTraceEntry>; + + static constexpr FieldMetadata_ElapsedRealtimeNanos kElapsedRealtimeNanos{}; + void set_elapsed_realtime_nanos(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_ElapsedRealtimeNanos::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_VsyncId = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + TransactionTraceEntry>; + + static constexpr FieldMetadata_VsyncId kVsyncId{}; + void set_vsync_id(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_VsyncId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Transactions = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TransactionState, + TransactionTraceEntry>; + + static constexpr FieldMetadata_Transactions kTransactions{}; + template T* add_transactions() { + return BeginNestedMessage(3); + } + + + using FieldMetadata_AddedLayers = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + LayerCreationArgs, + TransactionTraceEntry>; + + static constexpr FieldMetadata_AddedLayers kAddedLayers{}; + template T* add_added_layers() { + return BeginNestedMessage(4); + } + + + using FieldMetadata_DestroyedLayers = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + TransactionTraceEntry>; + + static constexpr FieldMetadata_DestroyedLayers kDestroyedLayers{}; + void add_destroyed_layers(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_DestroyedLayers::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_AddedDisplays = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + DisplayState, + TransactionTraceEntry>; + + static constexpr FieldMetadata_AddedDisplays kAddedDisplays{}; + template T* add_added_displays() { + return BeginNestedMessage(6); + } + + + using FieldMetadata_RemovedDisplays = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + TransactionTraceEntry>; + + static constexpr FieldMetadata_RemovedDisplays kRemovedDisplays{}; + void add_removed_displays(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_RemovedDisplays::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DestroyedLayerHandles = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + TransactionTraceEntry>; + + static constexpr FieldMetadata_DestroyedLayerHandles kDestroyedLayerHandles{}; + void add_destroyed_layer_handles(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_DestroyedLayerHandles::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DisplaysChanged = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + TransactionTraceEntry>; + + static constexpr FieldMetadata_DisplaysChanged kDisplaysChanged{}; + void set_displays_changed(bool value) { + static constexpr uint32_t field_id = FieldMetadata_DisplaysChanged::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Displays = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + DisplayInfo, + TransactionTraceEntry>; + + static constexpr FieldMetadata_Displays kDisplays{}; + template T* add_displays() { + return BeginNestedMessage(10); + } + +}; + +class TransactionTraceFile_Decoder : public ::protozero::TypedProtoDecoder { + public: + TransactionTraceFile_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TransactionTraceFile_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TransactionTraceFile_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_magic_number() const { return at<1>().valid(); } + uint64_t magic_number() const { return at<1>().as_uint64(); } + bool has_entry() const { return at<2>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> entry() const { return GetRepeated<::protozero::ConstBytes>(2); } + bool has_real_to_elapsed_time_offset_nanos() const { return at<3>().valid(); } + uint64_t real_to_elapsed_time_offset_nanos() const { return at<3>().as_uint64(); } + bool has_version() const { return at<4>().valid(); } + uint32_t version() const { return at<4>().as_uint32(); } +}; + +class TransactionTraceFile : public ::protozero::Message { + public: + using Decoder = TransactionTraceFile_Decoder; + enum : int32_t { + kMagicNumberFieldNumber = 1, + kEntryFieldNumber = 2, + kRealToElapsedTimeOffsetNanosFieldNumber = 3, + kVersionFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.TransactionTraceFile"; } + + + using MagicNumber = ::perfetto::protos::pbzero::TransactionTraceFile_MagicNumber; + static inline const char* MagicNumber_Name(MagicNumber value) { + return ::perfetto::protos::pbzero::TransactionTraceFile_MagicNumber_Name(value); + } + static inline const MagicNumber INVALID = MagicNumber::INVALID; + static inline const MagicNumber MAGIC_NUMBER_L = MagicNumber::MAGIC_NUMBER_L; + static inline const MagicNumber MAGIC_NUMBER_H = MagicNumber::MAGIC_NUMBER_H; + + using FieldMetadata_MagicNumber = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFixed64, + uint64_t, + TransactionTraceFile>; + + static constexpr FieldMetadata_MagicNumber kMagicNumber{}; + void set_magic_number(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_MagicNumber::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFixed64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Entry = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TransactionTraceEntry, + TransactionTraceFile>; + + static constexpr FieldMetadata_Entry kEntry{}; + template T* add_entry() { + return BeginNestedMessage(2); + } + + + using FieldMetadata_RealToElapsedTimeOffsetNanos = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFixed64, + uint64_t, + TransactionTraceFile>; + + static constexpr FieldMetadata_RealToElapsedTimeOffsetNanos kRealToElapsedTimeOffsetNanos{}; + void set_real_to_elapsed_time_offset_nanos(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_RealToElapsedTimeOffsetNanos::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFixed64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Version = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + TransactionTraceFile>; + + static constexpr FieldMetadata_Version kVersion{}; + void set_version(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Version::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class BarrierLayerProto_Decoder : public ::protozero::TypedProtoDecoder { + public: + BarrierLayerProto_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit BarrierLayerProto_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit BarrierLayerProto_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_id() const { return at<1>().valid(); } + int32_t id() const { return at<1>().as_int32(); } + bool has_frame_number() const { return at<2>().valid(); } + uint64_t frame_number() const { return at<2>().as_uint64(); } +}; + +class BarrierLayerProto : public ::protozero::Message { + public: + using Decoder = BarrierLayerProto_Decoder; + enum : int32_t { + kIdFieldNumber = 1, + kFrameNumberFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.BarrierLayerProto"; } + + + using FieldMetadata_Id = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + BarrierLayerProto>; + + static constexpr FieldMetadata_Id kId{}; + void set_id(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FrameNumber = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + BarrierLayerProto>; + + static constexpr FieldMetadata_FrameNumber kFrameNumber{}; + void set_frame_number(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_FrameNumber::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class ActiveBufferProto_Decoder : public ::protozero::TypedProtoDecoder { + public: + ActiveBufferProto_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ActiveBufferProto_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ActiveBufferProto_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_width() const { return at<1>().valid(); } + uint32_t width() const { return at<1>().as_uint32(); } + bool has_height() const { return at<2>().valid(); } + uint32_t height() const { return at<2>().as_uint32(); } + bool has_stride() const { return at<3>().valid(); } + uint32_t stride() const { return at<3>().as_uint32(); } + bool has_format() const { return at<4>().valid(); } + int32_t format() const { return at<4>().as_int32(); } + bool has_usage() const { return at<5>().valid(); } + uint64_t usage() const { return at<5>().as_uint64(); } +}; + +class ActiveBufferProto : public ::protozero::Message { + public: + using Decoder = ActiveBufferProto_Decoder; + enum : int32_t { + kWidthFieldNumber = 1, + kHeightFieldNumber = 2, + kStrideFieldNumber = 3, + kFormatFieldNumber = 4, + kUsageFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ActiveBufferProto"; } + + + using FieldMetadata_Width = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + ActiveBufferProto>; + + static constexpr FieldMetadata_Width kWidth{}; + void set_width(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Width::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Height = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + ActiveBufferProto>; + + static constexpr FieldMetadata_Height kHeight{}; + void set_height(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Height::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Stride = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + ActiveBufferProto>; + + static constexpr FieldMetadata_Stride kStride{}; + void set_stride(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Stride::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Format = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + ActiveBufferProto>; + + static constexpr FieldMetadata_Format kFormat{}; + void set_format(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Format::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Usage = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + ActiveBufferProto>; + + static constexpr FieldMetadata_Usage kUsage{}; + void set_usage(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Usage::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class FloatRectProto_Decoder : public ::protozero::TypedProtoDecoder { + public: + FloatRectProto_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit FloatRectProto_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit FloatRectProto_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_left() const { return at<1>().valid(); } + float left() const { return at<1>().as_float(); } + bool has_top() const { return at<2>().valid(); } + float top() const { return at<2>().as_float(); } + bool has_right() const { return at<3>().valid(); } + float right() const { return at<3>().as_float(); } + bool has_bottom() const { return at<4>().valid(); } + float bottom() const { return at<4>().as_float(); } +}; + +class FloatRectProto : public ::protozero::Message { + public: + using Decoder = FloatRectProto_Decoder; + enum : int32_t { + kLeftFieldNumber = 1, + kTopFieldNumber = 2, + kRightFieldNumber = 3, + kBottomFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.FloatRectProto"; } + + + using FieldMetadata_Left = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + FloatRectProto>; + + static constexpr FieldMetadata_Left kLeft{}; + void set_left(float value) { + static constexpr uint32_t field_id = FieldMetadata_Left::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Top = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + FloatRectProto>; + + static constexpr FieldMetadata_Top kTop{}; + void set_top(float value) { + static constexpr uint32_t field_id = FieldMetadata_Top::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Right = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + FloatRectProto>; + + static constexpr FieldMetadata_Right kRight{}; + void set_right(float value) { + static constexpr uint32_t field_id = FieldMetadata_Right::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Bottom = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + FloatRectProto>; + + static constexpr FieldMetadata_Bottom kBottom{}; + void set_bottom(float value) { + static constexpr uint32_t field_id = FieldMetadata_Bottom::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } +}; + +class PositionProto_Decoder : public ::protozero::TypedProtoDecoder { + public: + PositionProto_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit PositionProto_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit PositionProto_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_x() const { return at<1>().valid(); } + float x() const { return at<1>().as_float(); } + bool has_y() const { return at<2>().valid(); } + float y() const { return at<2>().as_float(); } +}; + +class PositionProto : public ::protozero::Message { + public: + using Decoder = PositionProto_Decoder; + enum : int32_t { + kXFieldNumber = 1, + kYFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.PositionProto"; } + + + using FieldMetadata_X = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + PositionProto>; + + static constexpr FieldMetadata_X kX{}; + void set_x(float value) { + static constexpr uint32_t field_id = FieldMetadata_X::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Y = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + PositionProto>; + + static constexpr FieldMetadata_Y kY{}; + void set_y(float value) { + static constexpr uint32_t field_id = FieldMetadata_Y::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } +}; + +class LayerProto_Decoder : public ::protozero::TypedProtoDecoder { + public: + LayerProto_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit LayerProto_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit LayerProto_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_id() const { return at<1>().valid(); } + int32_t id() const { return at<1>().as_int32(); } + bool has_name() const { return at<2>().valid(); } + ::protozero::ConstChars name() const { return at<2>().as_string(); } + bool has_children() const { return at<3>().valid(); } + ::protozero::PackedRepeatedFieldIterator<::protozero::proto_utils::ProtoWireType::kVarInt, int32_t> children(bool* parse_error_ptr) const { return GetPackedRepeated<::protozero::proto_utils::ProtoWireType::kVarInt, int32_t>(3, parse_error_ptr); } + bool has_relatives() const { return at<4>().valid(); } + ::protozero::PackedRepeatedFieldIterator<::protozero::proto_utils::ProtoWireType::kVarInt, int32_t> relatives(bool* parse_error_ptr) const { return GetPackedRepeated<::protozero::proto_utils::ProtoWireType::kVarInt, int32_t>(4, parse_error_ptr); } + bool has_type() const { return at<5>().valid(); } + ::protozero::ConstChars type() const { return at<5>().as_string(); } + bool has_transparent_region() const { return at<6>().valid(); } + ::protozero::ConstBytes transparent_region() const { return at<6>().as_bytes(); } + bool has_visible_region() const { return at<7>().valid(); } + ::protozero::ConstBytes visible_region() const { return at<7>().as_bytes(); } + bool has_damage_region() const { return at<8>().valid(); } + ::protozero::ConstBytes damage_region() const { return at<8>().as_bytes(); } + bool has_layer_stack() const { return at<9>().valid(); } + uint32_t layer_stack() const { return at<9>().as_uint32(); } + bool has_z() const { return at<10>().valid(); } + int32_t z() const { return at<10>().as_int32(); } + bool has_position() const { return at<11>().valid(); } + ::protozero::ConstBytes position() const { return at<11>().as_bytes(); } + bool has_requested_position() const { return at<12>().valid(); } + ::protozero::ConstBytes requested_position() const { return at<12>().as_bytes(); } + bool has_size() const { return at<13>().valid(); } + ::protozero::ConstBytes size() const { return at<13>().as_bytes(); } + bool has_crop() const { return at<14>().valid(); } + ::protozero::ConstBytes crop() const { return at<14>().as_bytes(); } + bool has_final_crop() const { return at<15>().valid(); } + ::protozero::ConstBytes final_crop() const { return at<15>().as_bytes(); } + bool has_is_opaque() const { return at<16>().valid(); } + bool is_opaque() const { return at<16>().as_bool(); } + bool has_invalidate() const { return at<17>().valid(); } + bool invalidate() const { return at<17>().as_bool(); } + bool has_dataspace() const { return at<18>().valid(); } + ::protozero::ConstChars dataspace() const { return at<18>().as_string(); } + bool has_pixel_format() const { return at<19>().valid(); } + ::protozero::ConstChars pixel_format() const { return at<19>().as_string(); } + bool has_color() const { return at<20>().valid(); } + ::protozero::ConstBytes color() const { return at<20>().as_bytes(); } + bool has_requested_color() const { return at<21>().valid(); } + ::protozero::ConstBytes requested_color() const { return at<21>().as_bytes(); } + bool has_flags() const { return at<22>().valid(); } + uint32_t flags() const { return at<22>().as_uint32(); } + bool has_transform() const { return at<23>().valid(); } + ::protozero::ConstBytes transform() const { return at<23>().as_bytes(); } + bool has_requested_transform() const { return at<24>().valid(); } + ::protozero::ConstBytes requested_transform() const { return at<24>().as_bytes(); } + bool has_parent() const { return at<25>().valid(); } + int32_t parent() const { return at<25>().as_int32(); } + bool has_z_order_relative_of() const { return at<26>().valid(); } + int32_t z_order_relative_of() const { return at<26>().as_int32(); } + bool has_active_buffer() const { return at<27>().valid(); } + ::protozero::ConstBytes active_buffer() const { return at<27>().as_bytes(); } + bool has_queued_frames() const { return at<28>().valid(); } + int32_t queued_frames() const { return at<28>().as_int32(); } + bool has_refresh_pending() const { return at<29>().valid(); } + bool refresh_pending() const { return at<29>().as_bool(); } + bool has_hwc_frame() const { return at<30>().valid(); } + ::protozero::ConstBytes hwc_frame() const { return at<30>().as_bytes(); } + bool has_hwc_crop() const { return at<31>().valid(); } + ::protozero::ConstBytes hwc_crop() const { return at<31>().as_bytes(); } + bool has_hwc_transform() const { return at<32>().valid(); } + int32_t hwc_transform() const { return at<32>().as_int32(); } + bool has_window_type() const { return at<33>().valid(); } + int32_t window_type() const { return at<33>().as_int32(); } + bool has_app_id() const { return at<34>().valid(); } + int32_t app_id() const { return at<34>().as_int32(); } + bool has_hwc_composition_type() const { return at<35>().valid(); } + int32_t hwc_composition_type() const { return at<35>().as_int32(); } + bool has_is_protected() const { return at<36>().valid(); } + bool is_protected() const { return at<36>().as_bool(); } + bool has_curr_frame() const { return at<37>().valid(); } + uint64_t curr_frame() const { return at<37>().as_uint64(); } + bool has_barrier_layer() const { return at<38>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> barrier_layer() const { return GetRepeated<::protozero::ConstBytes>(38); } + bool has_buffer_transform() const { return at<39>().valid(); } + ::protozero::ConstBytes buffer_transform() const { return at<39>().as_bytes(); } + bool has_effective_scaling_mode() const { return at<40>().valid(); } + int32_t effective_scaling_mode() const { return at<40>().as_int32(); } + bool has_corner_radius() const { return at<41>().valid(); } + float corner_radius() const { return at<41>().as_float(); } + bool has_metadata() const { return at<42>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> metadata() const { return GetRepeated<::protozero::ConstBytes>(42); } + bool has_effective_transform() const { return at<43>().valid(); } + ::protozero::ConstBytes effective_transform() const { return at<43>().as_bytes(); } + bool has_source_bounds() const { return at<44>().valid(); } + ::protozero::ConstBytes source_bounds() const { return at<44>().as_bytes(); } + bool has_bounds() const { return at<45>().valid(); } + ::protozero::ConstBytes bounds() const { return at<45>().as_bytes(); } + bool has_screen_bounds() const { return at<46>().valid(); } + ::protozero::ConstBytes screen_bounds() const { return at<46>().as_bytes(); } + bool has_input_window_info() const { return at<47>().valid(); } + ::protozero::ConstBytes input_window_info() const { return at<47>().as_bytes(); } + bool has_corner_radius_crop() const { return at<48>().valid(); } + ::protozero::ConstBytes corner_radius_crop() const { return at<48>().as_bytes(); } + bool has_shadow_radius() const { return at<49>().valid(); } + float shadow_radius() const { return at<49>().as_float(); } + bool has_color_transform() const { return at<50>().valid(); } + ::protozero::ConstBytes color_transform() const { return at<50>().as_bytes(); } + bool has_is_relative_of() const { return at<51>().valid(); } + bool is_relative_of() const { return at<51>().as_bool(); } + bool has_background_blur_radius() const { return at<52>().valid(); } + int32_t background_blur_radius() const { return at<52>().as_int32(); } + bool has_owner_uid() const { return at<53>().valid(); } + uint32_t owner_uid() const { return at<53>().as_uint32(); } + bool has_blur_regions() const { return at<54>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> blur_regions() const { return GetRepeated<::protozero::ConstBytes>(54); } + bool has_is_trusted_overlay() const { return at<55>().valid(); } + bool is_trusted_overlay() const { return at<55>().as_bool(); } + bool has_requested_corner_radius() const { return at<56>().valid(); } + float requested_corner_radius() const { return at<56>().as_float(); } + bool has_destination_frame() const { return at<57>().valid(); } + ::protozero::ConstBytes destination_frame() const { return at<57>().as_bytes(); } + bool has_original_id() const { return at<58>().valid(); } + uint32_t original_id() const { return at<58>().as_uint32(); } +}; + +class LayerProto : public ::protozero::Message { + public: + using Decoder = LayerProto_Decoder; + enum : int32_t { + kIdFieldNumber = 1, + kNameFieldNumber = 2, + kChildrenFieldNumber = 3, + kRelativesFieldNumber = 4, + kTypeFieldNumber = 5, + kTransparentRegionFieldNumber = 6, + kVisibleRegionFieldNumber = 7, + kDamageRegionFieldNumber = 8, + kLayerStackFieldNumber = 9, + kZFieldNumber = 10, + kPositionFieldNumber = 11, + kRequestedPositionFieldNumber = 12, + kSizeFieldNumber = 13, + kCropFieldNumber = 14, + kFinalCropFieldNumber = 15, + kIsOpaqueFieldNumber = 16, + kInvalidateFieldNumber = 17, + kDataspaceFieldNumber = 18, + kPixelFormatFieldNumber = 19, + kColorFieldNumber = 20, + kRequestedColorFieldNumber = 21, + kFlagsFieldNumber = 22, + kTransformFieldNumber = 23, + kRequestedTransformFieldNumber = 24, + kParentFieldNumber = 25, + kZOrderRelativeOfFieldNumber = 26, + kActiveBufferFieldNumber = 27, + kQueuedFramesFieldNumber = 28, + kRefreshPendingFieldNumber = 29, + kHwcFrameFieldNumber = 30, + kHwcCropFieldNumber = 31, + kHwcTransformFieldNumber = 32, + kWindowTypeFieldNumber = 33, + kAppIdFieldNumber = 34, + kHwcCompositionTypeFieldNumber = 35, + kIsProtectedFieldNumber = 36, + kCurrFrameFieldNumber = 37, + kBarrierLayerFieldNumber = 38, + kBufferTransformFieldNumber = 39, + kEffectiveScalingModeFieldNumber = 40, + kCornerRadiusFieldNumber = 41, + kMetadataFieldNumber = 42, + kEffectiveTransformFieldNumber = 43, + kSourceBoundsFieldNumber = 44, + kBoundsFieldNumber = 45, + kScreenBoundsFieldNumber = 46, + kInputWindowInfoFieldNumber = 47, + kCornerRadiusCropFieldNumber = 48, + kShadowRadiusFieldNumber = 49, + kColorTransformFieldNumber = 50, + kIsRelativeOfFieldNumber = 51, + kBackgroundBlurRadiusFieldNumber = 52, + kOwnerUidFieldNumber = 53, + kBlurRegionsFieldNumber = 54, + kIsTrustedOverlayFieldNumber = 55, + kRequestedCornerRadiusFieldNumber = 56, + kDestinationFrameFieldNumber = 57, + kOriginalIdFieldNumber = 58, + }; + static constexpr const char* GetName() { return ".perfetto.protos.LayerProto"; } + + using MetadataEntry = ::perfetto::protos::pbzero::LayerProto_MetadataEntry; + + using FieldMetadata_Id = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + LayerProto>; + + static constexpr FieldMetadata_Id kId{}; + void set_id(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + LayerProto>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Children = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kRepeatedPacked, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + LayerProto>; + + static constexpr FieldMetadata_Children kChildren{}; + void set_children(const ::protozero::PackedVarInt& packed_buffer) { + AppendBytes(FieldMetadata_Children::kFieldId, packed_buffer.data(), + packed_buffer.size()); + } + + using FieldMetadata_Relatives = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kRepeatedPacked, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + LayerProto>; + + static constexpr FieldMetadata_Relatives kRelatives{}; + void set_relatives(const ::protozero::PackedVarInt& packed_buffer) { + AppendBytes(FieldMetadata_Relatives::kFieldId, packed_buffer.data(), + packed_buffer.size()); + } + + using FieldMetadata_Type = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + LayerProto>; + + static constexpr FieldMetadata_Type kType{}; + void set_type(const char* data, size_t size) { + AppendBytes(FieldMetadata_Type::kFieldId, data, size); + } + void set_type(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Type::kFieldId, chars.data, chars.size); + } + void set_type(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TransparentRegion = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + RegionProto, + LayerProto>; + + static constexpr FieldMetadata_TransparentRegion kTransparentRegion{}; + template T* set_transparent_region() { + return BeginNestedMessage(6); + } + + + using FieldMetadata_VisibleRegion = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + RegionProto, + LayerProto>; + + static constexpr FieldMetadata_VisibleRegion kVisibleRegion{}; + template T* set_visible_region() { + return BeginNestedMessage(7); + } + + + using FieldMetadata_DamageRegion = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + RegionProto, + LayerProto>; + + static constexpr FieldMetadata_DamageRegion kDamageRegion{}; + template T* set_damage_region() { + return BeginNestedMessage(8); + } + + + using FieldMetadata_LayerStack = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + LayerProto>; + + static constexpr FieldMetadata_LayerStack kLayerStack{}; + void set_layer_stack(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_LayerStack::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Z = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + LayerProto>; + + static constexpr FieldMetadata_Z kZ{}; + void set_z(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Z::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Position = + ::protozero::proto_utils::FieldMetadata< + 11, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + PositionProto, + LayerProto>; + + static constexpr FieldMetadata_Position kPosition{}; + template T* set_position() { + return BeginNestedMessage(11); + } + + + using FieldMetadata_RequestedPosition = + ::protozero::proto_utils::FieldMetadata< + 12, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + PositionProto, + LayerProto>; + + static constexpr FieldMetadata_RequestedPosition kRequestedPosition{}; + template T* set_requested_position() { + return BeginNestedMessage(12); + } + + + using FieldMetadata_Size = + ::protozero::proto_utils::FieldMetadata< + 13, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + SizeProto, + LayerProto>; + + static constexpr FieldMetadata_Size kSize{}; + template T* set_size() { + return BeginNestedMessage(13); + } + + + using FieldMetadata_Crop = + ::protozero::proto_utils::FieldMetadata< + 14, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + RectProto, + LayerProto>; + + static constexpr FieldMetadata_Crop kCrop{}; + template T* set_crop() { + return BeginNestedMessage(14); + } + + + using FieldMetadata_FinalCrop = + ::protozero::proto_utils::FieldMetadata< + 15, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + RectProto, + LayerProto>; + + static constexpr FieldMetadata_FinalCrop kFinalCrop{}; + template T* set_final_crop() { + return BeginNestedMessage(15); + } + + + using FieldMetadata_IsOpaque = + ::protozero::proto_utils::FieldMetadata< + 16, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + LayerProto>; + + static constexpr FieldMetadata_IsOpaque kIsOpaque{}; + void set_is_opaque(bool value) { + static constexpr uint32_t field_id = FieldMetadata_IsOpaque::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Invalidate = + ::protozero::proto_utils::FieldMetadata< + 17, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + LayerProto>; + + static constexpr FieldMetadata_Invalidate kInvalidate{}; + void set_invalidate(bool value) { + static constexpr uint32_t field_id = FieldMetadata_Invalidate::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Dataspace = + ::protozero::proto_utils::FieldMetadata< + 18, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + LayerProto>; + + static constexpr FieldMetadata_Dataspace kDataspace{}; + void set_dataspace(const char* data, size_t size) { + AppendBytes(FieldMetadata_Dataspace::kFieldId, data, size); + } + void set_dataspace(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Dataspace::kFieldId, chars.data, chars.size); + } + void set_dataspace(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Dataspace::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PixelFormat = + ::protozero::proto_utils::FieldMetadata< + 19, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + LayerProto>; + + static constexpr FieldMetadata_PixelFormat kPixelFormat{}; + void set_pixel_format(const char* data, size_t size) { + AppendBytes(FieldMetadata_PixelFormat::kFieldId, data, size); + } + void set_pixel_format(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_PixelFormat::kFieldId, chars.data, chars.size); + } + void set_pixel_format(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_PixelFormat::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Color = + ::protozero::proto_utils::FieldMetadata< + 20, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ColorProto, + LayerProto>; + + static constexpr FieldMetadata_Color kColor{}; + template T* set_color() { + return BeginNestedMessage(20); + } + + + using FieldMetadata_RequestedColor = + ::protozero::proto_utils::FieldMetadata< + 21, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ColorProto, + LayerProto>; + + static constexpr FieldMetadata_RequestedColor kRequestedColor{}; + template T* set_requested_color() { + return BeginNestedMessage(21); + } + + + using FieldMetadata_Flags = + ::protozero::proto_utils::FieldMetadata< + 22, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + LayerProto>; + + static constexpr FieldMetadata_Flags kFlags{}; + void set_flags(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Transform = + ::protozero::proto_utils::FieldMetadata< + 23, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TransformProto, + LayerProto>; + + static constexpr FieldMetadata_Transform kTransform{}; + template T* set_transform() { + return BeginNestedMessage(23); + } + + + using FieldMetadata_RequestedTransform = + ::protozero::proto_utils::FieldMetadata< + 24, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TransformProto, + LayerProto>; + + static constexpr FieldMetadata_RequestedTransform kRequestedTransform{}; + template T* set_requested_transform() { + return BeginNestedMessage(24); + } + + + using FieldMetadata_Parent = + ::protozero::proto_utils::FieldMetadata< + 25, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + LayerProto>; + + static constexpr FieldMetadata_Parent kParent{}; + void set_parent(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Parent::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ZOrderRelativeOf = + ::protozero::proto_utils::FieldMetadata< + 26, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + LayerProto>; + + static constexpr FieldMetadata_ZOrderRelativeOf kZOrderRelativeOf{}; + void set_z_order_relative_of(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ZOrderRelativeOf::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ActiveBuffer = + ::protozero::proto_utils::FieldMetadata< + 27, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ActiveBufferProto, + LayerProto>; + + static constexpr FieldMetadata_ActiveBuffer kActiveBuffer{}; + template T* set_active_buffer() { + return BeginNestedMessage(27); + } + + + using FieldMetadata_QueuedFrames = + ::protozero::proto_utils::FieldMetadata< + 28, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + LayerProto>; + + static constexpr FieldMetadata_QueuedFrames kQueuedFrames{}; + void set_queued_frames(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_QueuedFrames::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_RefreshPending = + ::protozero::proto_utils::FieldMetadata< + 29, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + LayerProto>; + + static constexpr FieldMetadata_RefreshPending kRefreshPending{}; + void set_refresh_pending(bool value) { + static constexpr uint32_t field_id = FieldMetadata_RefreshPending::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_HwcFrame = + ::protozero::proto_utils::FieldMetadata< + 30, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + RectProto, + LayerProto>; + + static constexpr FieldMetadata_HwcFrame kHwcFrame{}; + template T* set_hwc_frame() { + return BeginNestedMessage(30); + } + + + using FieldMetadata_HwcCrop = + ::protozero::proto_utils::FieldMetadata< + 31, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + FloatRectProto, + LayerProto>; + + static constexpr FieldMetadata_HwcCrop kHwcCrop{}; + template T* set_hwc_crop() { + return BeginNestedMessage(31); + } + + + using FieldMetadata_HwcTransform = + ::protozero::proto_utils::FieldMetadata< + 32, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + LayerProto>; + + static constexpr FieldMetadata_HwcTransform kHwcTransform{}; + void set_hwc_transform(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_HwcTransform::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_WindowType = + ::protozero::proto_utils::FieldMetadata< + 33, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + LayerProto>; + + static constexpr FieldMetadata_WindowType kWindowType{}; + void set_window_type(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_WindowType::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_AppId = + ::protozero::proto_utils::FieldMetadata< + 34, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + LayerProto>; + + static constexpr FieldMetadata_AppId kAppId{}; + void set_app_id(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_AppId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_HwcCompositionType = + ::protozero::proto_utils::FieldMetadata< + 35, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + HwcCompositionType, + LayerProto>; + + static constexpr FieldMetadata_HwcCompositionType kHwcCompositionType{}; + void set_hwc_composition_type(HwcCompositionType value) { + static constexpr uint32_t field_id = FieldMetadata_HwcCompositionType::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_IsProtected = + ::protozero::proto_utils::FieldMetadata< + 36, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + LayerProto>; + + static constexpr FieldMetadata_IsProtected kIsProtected{}; + void set_is_protected(bool value) { + static constexpr uint32_t field_id = FieldMetadata_IsProtected::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CurrFrame = + ::protozero::proto_utils::FieldMetadata< + 37, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + LayerProto>; + + static constexpr FieldMetadata_CurrFrame kCurrFrame{}; + void set_curr_frame(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_CurrFrame::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_BarrierLayer = + ::protozero::proto_utils::FieldMetadata< + 38, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + BarrierLayerProto, + LayerProto>; + + static constexpr FieldMetadata_BarrierLayer kBarrierLayer{}; + template T* add_barrier_layer() { + return BeginNestedMessage(38); + } + + + using FieldMetadata_BufferTransform = + ::protozero::proto_utils::FieldMetadata< + 39, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TransformProto, + LayerProto>; + + static constexpr FieldMetadata_BufferTransform kBufferTransform{}; + template T* set_buffer_transform() { + return BeginNestedMessage(39); + } + + + using FieldMetadata_EffectiveScalingMode = + ::protozero::proto_utils::FieldMetadata< + 40, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + LayerProto>; + + static constexpr FieldMetadata_EffectiveScalingMode kEffectiveScalingMode{}; + void set_effective_scaling_mode(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_EffectiveScalingMode::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CornerRadius = + ::protozero::proto_utils::FieldMetadata< + 41, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + LayerProto>; + + static constexpr FieldMetadata_CornerRadius kCornerRadius{}; + void set_corner_radius(float value) { + static constexpr uint32_t field_id = FieldMetadata_CornerRadius::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Metadata = + ::protozero::proto_utils::FieldMetadata< + 42, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + LayerProto_MetadataEntry, + LayerProto>; + + static constexpr FieldMetadata_Metadata kMetadata{}; + template T* add_metadata() { + return BeginNestedMessage(42); + } + + + using FieldMetadata_EffectiveTransform = + ::protozero::proto_utils::FieldMetadata< + 43, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TransformProto, + LayerProto>; + + static constexpr FieldMetadata_EffectiveTransform kEffectiveTransform{}; + template T* set_effective_transform() { + return BeginNestedMessage(43); + } + + + using FieldMetadata_SourceBounds = + ::protozero::proto_utils::FieldMetadata< + 44, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + FloatRectProto, + LayerProto>; + + static constexpr FieldMetadata_SourceBounds kSourceBounds{}; + template T* set_source_bounds() { + return BeginNestedMessage(44); + } + + + using FieldMetadata_Bounds = + ::protozero::proto_utils::FieldMetadata< + 45, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + FloatRectProto, + LayerProto>; + + static constexpr FieldMetadata_Bounds kBounds{}; + template T* set_bounds() { + return BeginNestedMessage(45); + } + + + using FieldMetadata_ScreenBounds = + ::protozero::proto_utils::FieldMetadata< + 46, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + FloatRectProto, + LayerProto>; + + static constexpr FieldMetadata_ScreenBounds kScreenBounds{}; + template T* set_screen_bounds() { + return BeginNestedMessage(46); + } + + + using FieldMetadata_InputWindowInfo = + ::protozero::proto_utils::FieldMetadata< + 47, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + InputWindowInfoProto, + LayerProto>; + + static constexpr FieldMetadata_InputWindowInfo kInputWindowInfo{}; + template T* set_input_window_info() { + return BeginNestedMessage(47); + } + + + using FieldMetadata_CornerRadiusCrop = + ::protozero::proto_utils::FieldMetadata< + 48, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + FloatRectProto, + LayerProto>; + + static constexpr FieldMetadata_CornerRadiusCrop kCornerRadiusCrop{}; + template T* set_corner_radius_crop() { + return BeginNestedMessage(48); + } + + + using FieldMetadata_ShadowRadius = + ::protozero::proto_utils::FieldMetadata< + 49, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + LayerProto>; + + static constexpr FieldMetadata_ShadowRadius kShadowRadius{}; + void set_shadow_radius(float value) { + static constexpr uint32_t field_id = FieldMetadata_ShadowRadius::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ColorTransform = + ::protozero::proto_utils::FieldMetadata< + 50, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ColorTransformProto, + LayerProto>; + + static constexpr FieldMetadata_ColorTransform kColorTransform{}; + template T* set_color_transform() { + return BeginNestedMessage(50); + } + + + using FieldMetadata_IsRelativeOf = + ::protozero::proto_utils::FieldMetadata< + 51, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + LayerProto>; + + static constexpr FieldMetadata_IsRelativeOf kIsRelativeOf{}; + void set_is_relative_of(bool value) { + static constexpr uint32_t field_id = FieldMetadata_IsRelativeOf::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_BackgroundBlurRadius = + ::protozero::proto_utils::FieldMetadata< + 52, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + LayerProto>; + + static constexpr FieldMetadata_BackgroundBlurRadius kBackgroundBlurRadius{}; + void set_background_blur_radius(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_BackgroundBlurRadius::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_OwnerUid = + ::protozero::proto_utils::FieldMetadata< + 53, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + LayerProto>; + + static constexpr FieldMetadata_OwnerUid kOwnerUid{}; + void set_owner_uid(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_OwnerUid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_BlurRegions = + ::protozero::proto_utils::FieldMetadata< + 54, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + BlurRegion, + LayerProto>; + + static constexpr FieldMetadata_BlurRegions kBlurRegions{}; + template T* add_blur_regions() { + return BeginNestedMessage(54); + } + + + using FieldMetadata_IsTrustedOverlay = + ::protozero::proto_utils::FieldMetadata< + 55, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + LayerProto>; + + static constexpr FieldMetadata_IsTrustedOverlay kIsTrustedOverlay{}; + void set_is_trusted_overlay(bool value) { + static constexpr uint32_t field_id = FieldMetadata_IsTrustedOverlay::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_RequestedCornerRadius = + ::protozero::proto_utils::FieldMetadata< + 56, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + LayerProto>; + + static constexpr FieldMetadata_RequestedCornerRadius kRequestedCornerRadius{}; + void set_requested_corner_radius(float value) { + static constexpr uint32_t field_id = FieldMetadata_RequestedCornerRadius::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DestinationFrame = + ::protozero::proto_utils::FieldMetadata< + 57, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + RectProto, + LayerProto>; + + static constexpr FieldMetadata_DestinationFrame kDestinationFrame{}; + template T* set_destination_frame() { + return BeginNestedMessage(57); + } + + + using FieldMetadata_OriginalId = + ::protozero::proto_utils::FieldMetadata< + 58, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + LayerProto>; + + static constexpr FieldMetadata_OriginalId kOriginalId{}; + void set_original_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_OriginalId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class LayerProto_MetadataEntry_Decoder : public ::protozero::TypedProtoDecoder { + public: + LayerProto_MetadataEntry_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit LayerProto_MetadataEntry_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit LayerProto_MetadataEntry_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_key() const { return at<1>().valid(); } + int32_t key() const { return at<1>().as_int32(); } + bool has_value() const { return at<2>().valid(); } + ::protozero::ConstChars value() const { return at<2>().as_string(); } +}; + +class LayerProto_MetadataEntry : public ::protozero::Message { + public: + using Decoder = LayerProto_MetadataEntry_Decoder; + enum : int32_t { + kKeyFieldNumber = 1, + kValueFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.LayerProto.MetadataEntry"; } + + + using FieldMetadata_Key = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + LayerProto_MetadataEntry>; + + static constexpr FieldMetadata_Key kKey{}; + void set_key(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Key::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Value = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + LayerProto_MetadataEntry>; + + static constexpr FieldMetadata_Value kValue{}; + void set_value(const char* data, size_t size) { + AppendBytes(FieldMetadata_Value::kFieldId, data, size); + } + void set_value(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Value::kFieldId, chars.data, chars.size); + } + void set_value(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class DisplayProto_Decoder : public ::protozero::TypedProtoDecoder { + public: + DisplayProto_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit DisplayProto_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit DisplayProto_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_id() const { return at<1>().valid(); } + uint64_t id() const { return at<1>().as_uint64(); } + bool has_name() const { return at<2>().valid(); } + ::protozero::ConstChars name() const { return at<2>().as_string(); } + bool has_layer_stack() const { return at<3>().valid(); } + uint32_t layer_stack() const { return at<3>().as_uint32(); } + bool has_size() const { return at<4>().valid(); } + ::protozero::ConstBytes size() const { return at<4>().as_bytes(); } + bool has_layer_stack_space_rect() const { return at<5>().valid(); } + ::protozero::ConstBytes layer_stack_space_rect() const { return at<5>().as_bytes(); } + bool has_transform() const { return at<6>().valid(); } + ::protozero::ConstBytes transform() const { return at<6>().as_bytes(); } + bool has_is_virtual() const { return at<7>().valid(); } + bool is_virtual() const { return at<7>().as_bool(); } + bool has_dpi_x() const { return at<8>().valid(); } + double dpi_x() const { return at<8>().as_double(); } + bool has_dpi_y() const { return at<9>().valid(); } + double dpi_y() const { return at<9>().as_double(); } +}; + +class DisplayProto : public ::protozero::Message { + public: + using Decoder = DisplayProto_Decoder; + enum : int32_t { + kIdFieldNumber = 1, + kNameFieldNumber = 2, + kLayerStackFieldNumber = 3, + kSizeFieldNumber = 4, + kLayerStackSpaceRectFieldNumber = 5, + kTransformFieldNumber = 6, + kIsVirtualFieldNumber = 7, + kDpiXFieldNumber = 8, + kDpiYFieldNumber = 9, + }; + static constexpr const char* GetName() { return ".perfetto.protos.DisplayProto"; } + + + using FieldMetadata_Id = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + DisplayProto>; + + static constexpr FieldMetadata_Id kId{}; + void set_id(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + DisplayProto>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_LayerStack = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + DisplayProto>; + + static constexpr FieldMetadata_LayerStack kLayerStack{}; + void set_layer_stack(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_LayerStack::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Size = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + SizeProto, + DisplayProto>; + + static constexpr FieldMetadata_Size kSize{}; + template T* set_size() { + return BeginNestedMessage(4); + } + + + using FieldMetadata_LayerStackSpaceRect = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + RectProto, + DisplayProto>; + + static constexpr FieldMetadata_LayerStackSpaceRect kLayerStackSpaceRect{}; + template T* set_layer_stack_space_rect() { + return BeginNestedMessage(5); + } + + + using FieldMetadata_Transform = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TransformProto, + DisplayProto>; + + static constexpr FieldMetadata_Transform kTransform{}; + template T* set_transform() { + return BeginNestedMessage(6); + } + + + using FieldMetadata_IsVirtual = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + DisplayProto>; + + static constexpr FieldMetadata_IsVirtual kIsVirtual{}; + void set_is_virtual(bool value) { + static constexpr uint32_t field_id = FieldMetadata_IsVirtual::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DpiX = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kDouble, + double, + DisplayProto>; + + static constexpr FieldMetadata_DpiX kDpiX{}; + void set_dpi_x(double value) { + static constexpr uint32_t field_id = FieldMetadata_DpiX::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kDouble> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DpiY = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kDouble, + double, + DisplayProto>; + + static constexpr FieldMetadata_DpiY kDpiY{}; + void set_dpi_y(double value) { + static constexpr uint32_t field_id = FieldMetadata_DpiY::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kDouble> + ::Append(*this, field_id, value); + } +}; + +class LayersProto_Decoder : public ::protozero::TypedProtoDecoder { + public: + LayersProto_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit LayersProto_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit LayersProto_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_layers() const { return at<1>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> layers() const { return GetRepeated<::protozero::ConstBytes>(1); } +}; + +class LayersProto : public ::protozero::Message { + public: + using Decoder = LayersProto_Decoder; + enum : int32_t { + kLayersFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.LayersProto"; } + + + using FieldMetadata_Layers = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + LayerProto, + LayersProto>; + + static constexpr FieldMetadata_Layers kLayers{}; + template T* add_layers() { + return BeginNestedMessage(1); + } + +}; + +class LayersSnapshotProto_Decoder : public ::protozero::TypedProtoDecoder { + public: + LayersSnapshotProto_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit LayersSnapshotProto_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit LayersSnapshotProto_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_elapsed_realtime_nanos() const { return at<1>().valid(); } + int64_t elapsed_realtime_nanos() const { return at<1>().as_int64(); } + bool has_where() const { return at<2>().valid(); } + ::protozero::ConstChars where() const { return at<2>().as_string(); } + bool has_layers() const { return at<3>().valid(); } + ::protozero::ConstBytes layers() const { return at<3>().as_bytes(); } + bool has_hwc_blob() const { return at<4>().valid(); } + ::protozero::ConstChars hwc_blob() const { return at<4>().as_string(); } + bool has_excludes_composition_state() const { return at<5>().valid(); } + bool excludes_composition_state() const { return at<5>().as_bool(); } + bool has_missed_entries() const { return at<6>().valid(); } + uint32_t missed_entries() const { return at<6>().as_uint32(); } + bool has_displays() const { return at<7>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> displays() const { return GetRepeated<::protozero::ConstBytes>(7); } + bool has_vsync_id() const { return at<8>().valid(); } + int64_t vsync_id() const { return at<8>().as_int64(); } +}; + +class LayersSnapshotProto : public ::protozero::Message { + public: + using Decoder = LayersSnapshotProto_Decoder; + enum : int32_t { + kElapsedRealtimeNanosFieldNumber = 1, + kWhereFieldNumber = 2, + kLayersFieldNumber = 3, + kHwcBlobFieldNumber = 4, + kExcludesCompositionStateFieldNumber = 5, + kMissedEntriesFieldNumber = 6, + kDisplaysFieldNumber = 7, + kVsyncIdFieldNumber = 8, + }; + static constexpr const char* GetName() { return ".perfetto.protos.LayersSnapshotProto"; } + + + using FieldMetadata_ElapsedRealtimeNanos = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kSfixed64, + int64_t, + LayersSnapshotProto>; + + static constexpr FieldMetadata_ElapsedRealtimeNanos kElapsedRealtimeNanos{}; + void set_elapsed_realtime_nanos(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_ElapsedRealtimeNanos::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kSfixed64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Where = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + LayersSnapshotProto>; + + static constexpr FieldMetadata_Where kWhere{}; + void set_where(const char* data, size_t size) { + AppendBytes(FieldMetadata_Where::kFieldId, data, size); + } + void set_where(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Where::kFieldId, chars.data, chars.size); + } + void set_where(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Where::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Layers = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + LayersProto, + LayersSnapshotProto>; + + static constexpr FieldMetadata_Layers kLayers{}; + template T* set_layers() { + return BeginNestedMessage(3); + } + + + using FieldMetadata_HwcBlob = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + LayersSnapshotProto>; + + static constexpr FieldMetadata_HwcBlob kHwcBlob{}; + void set_hwc_blob(const char* data, size_t size) { + AppendBytes(FieldMetadata_HwcBlob::kFieldId, data, size); + } + void set_hwc_blob(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_HwcBlob::kFieldId, chars.data, chars.size); + } + void set_hwc_blob(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_HwcBlob::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ExcludesCompositionState = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + LayersSnapshotProto>; + + static constexpr FieldMetadata_ExcludesCompositionState kExcludesCompositionState{}; + void set_excludes_composition_state(bool value) { + static constexpr uint32_t field_id = FieldMetadata_ExcludesCompositionState::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_MissedEntries = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + LayersSnapshotProto>; + + static constexpr FieldMetadata_MissedEntries kMissedEntries{}; + void set_missed_entries(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_MissedEntries::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Displays = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + DisplayProto, + LayersSnapshotProto>; + + static constexpr FieldMetadata_Displays kDisplays{}; + template T* add_displays() { + return BeginNestedMessage(7); + } + + + using FieldMetadata_VsyncId = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + LayersSnapshotProto>; + + static constexpr FieldMetadata_VsyncId kVsyncId{}; + void set_vsync_id(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_VsyncId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } +}; + +class LayersTraceFileProto_Decoder : public ::protozero::TypedProtoDecoder { + public: + LayersTraceFileProto_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit LayersTraceFileProto_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit LayersTraceFileProto_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_magic_number() const { return at<1>().valid(); } + uint64_t magic_number() const { return at<1>().as_uint64(); } + bool has_entry() const { return at<2>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> entry() const { return GetRepeated<::protozero::ConstBytes>(2); } + bool has_real_to_elapsed_time_offset_nanos() const { return at<3>().valid(); } + uint64_t real_to_elapsed_time_offset_nanos() const { return at<3>().as_uint64(); } +}; + +class LayersTraceFileProto : public ::protozero::Message { + public: + using Decoder = LayersTraceFileProto_Decoder; + enum : int32_t { + kMagicNumberFieldNumber = 1, + kEntryFieldNumber = 2, + kRealToElapsedTimeOffsetNanosFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.LayersTraceFileProto"; } + + + using MagicNumber = ::perfetto::protos::pbzero::LayersTraceFileProto_MagicNumber; + static inline const char* MagicNumber_Name(MagicNumber value) { + return ::perfetto::protos::pbzero::LayersTraceFileProto_MagicNumber_Name(value); + } + static inline const MagicNumber INVALID = MagicNumber::INVALID; + static inline const MagicNumber MAGIC_NUMBER_L = MagicNumber::MAGIC_NUMBER_L; + static inline const MagicNumber MAGIC_NUMBER_H = MagicNumber::MAGIC_NUMBER_H; + + using FieldMetadata_MagicNumber = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFixed64, + uint64_t, + LayersTraceFileProto>; + + static constexpr FieldMetadata_MagicNumber kMagicNumber{}; + void set_magic_number(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_MagicNumber::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFixed64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Entry = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + LayersSnapshotProto, + LayersTraceFileProto>; + + static constexpr FieldMetadata_Entry kEntry{}; + template T* add_entry() { + return BeginNestedMessage(2); + } + + + using FieldMetadata_RealToElapsedTimeOffsetNanos = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFixed64, + uint64_t, + LayersTraceFileProto>; + + static constexpr FieldMetadata_RealToElapsedTimeOffsetNanos kRealToElapsedTimeOffsetNanos{}; + void set_real_to_elapsed_time_offset_nanos(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_RealToElapsedTimeOffsetNanos::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFixed64> + ::Append(*this, field_id, value); + } +}; + +class ColorTransformProto_Decoder : public ::protozero::TypedProtoDecoder { + public: + ColorTransformProto_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ColorTransformProto_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ColorTransformProto_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_val() const { return at<1>().valid(); } + ::protozero::PackedRepeatedFieldIterator<::protozero::proto_utils::ProtoWireType::kFixed32, float> val(bool* parse_error_ptr) const { return GetPackedRepeated<::protozero::proto_utils::ProtoWireType::kFixed32, float>(1, parse_error_ptr); } +}; + +class ColorTransformProto : public ::protozero::Message { + public: + using Decoder = ColorTransformProto_Decoder; + enum : int32_t { + kValFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ColorTransformProto"; } + + + using FieldMetadata_Val = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kRepeatedPacked, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + ColorTransformProto>; + + static constexpr FieldMetadata_Val kVal{}; + void set_val(const ::protozero::PackedFixedSizeInt& packed_buffer) { + AppendBytes(FieldMetadata_Val::kFieldId, packed_buffer.data(), + packed_buffer.size()); + } +}; + +class BlurRegion_Decoder : public ::protozero::TypedProtoDecoder { + public: + BlurRegion_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit BlurRegion_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit BlurRegion_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_blur_radius() const { return at<1>().valid(); } + uint32_t blur_radius() const { return at<1>().as_uint32(); } + bool has_corner_radius_tl() const { return at<2>().valid(); } + uint32_t corner_radius_tl() const { return at<2>().as_uint32(); } + bool has_corner_radius_tr() const { return at<3>().valid(); } + uint32_t corner_radius_tr() const { return at<3>().as_uint32(); } + bool has_corner_radius_bl() const { return at<4>().valid(); } + uint32_t corner_radius_bl() const { return at<4>().as_uint32(); } + bool has_corner_radius_br() const { return at<5>().valid(); } + float corner_radius_br() const { return at<5>().as_float(); } + bool has_alpha() const { return at<6>().valid(); } + float alpha() const { return at<6>().as_float(); } + bool has_left() const { return at<7>().valid(); } + int32_t left() const { return at<7>().as_int32(); } + bool has_top() const { return at<8>().valid(); } + int32_t top() const { return at<8>().as_int32(); } + bool has_right() const { return at<9>().valid(); } + int32_t right() const { return at<9>().as_int32(); } + bool has_bottom() const { return at<10>().valid(); } + int32_t bottom() const { return at<10>().as_int32(); } +}; + +class BlurRegion : public ::protozero::Message { + public: + using Decoder = BlurRegion_Decoder; + enum : int32_t { + kBlurRadiusFieldNumber = 1, + kCornerRadiusTlFieldNumber = 2, + kCornerRadiusTrFieldNumber = 3, + kCornerRadiusBlFieldNumber = 4, + kCornerRadiusBrFieldNumber = 5, + kAlphaFieldNumber = 6, + kLeftFieldNumber = 7, + kTopFieldNumber = 8, + kRightFieldNumber = 9, + kBottomFieldNumber = 10, + }; + static constexpr const char* GetName() { return ".perfetto.protos.BlurRegion"; } + + + using FieldMetadata_BlurRadius = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + BlurRegion>; + + static constexpr FieldMetadata_BlurRadius kBlurRadius{}; + void set_blur_radius(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_BlurRadius::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CornerRadiusTl = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + BlurRegion>; + + static constexpr FieldMetadata_CornerRadiusTl kCornerRadiusTl{}; + void set_corner_radius_tl(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_CornerRadiusTl::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CornerRadiusTr = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + BlurRegion>; + + static constexpr FieldMetadata_CornerRadiusTr kCornerRadiusTr{}; + void set_corner_radius_tr(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_CornerRadiusTr::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CornerRadiusBl = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + BlurRegion>; + + static constexpr FieldMetadata_CornerRadiusBl kCornerRadiusBl{}; + void set_corner_radius_bl(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_CornerRadiusBl::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CornerRadiusBr = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + BlurRegion>; + + static constexpr FieldMetadata_CornerRadiusBr kCornerRadiusBr{}; + void set_corner_radius_br(float value) { + static constexpr uint32_t field_id = FieldMetadata_CornerRadiusBr::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Alpha = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + BlurRegion>; + + static constexpr FieldMetadata_Alpha kAlpha{}; + void set_alpha(float value) { + static constexpr uint32_t field_id = FieldMetadata_Alpha::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Left = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + BlurRegion>; + + static constexpr FieldMetadata_Left kLeft{}; + void set_left(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Left::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Top = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + BlurRegion>; + + static constexpr FieldMetadata_Top kTop{}; + void set_top(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Top::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Right = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + BlurRegion>; + + static constexpr FieldMetadata_Right kRight{}; + void set_right(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Right::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Bottom = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + BlurRegion>; + + static constexpr FieldMetadata_Bottom kBottom{}; + void set_bottom(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Bottom::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class InputWindowInfoProto_Decoder : public ::protozero::TypedProtoDecoder { + public: + InputWindowInfoProto_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit InputWindowInfoProto_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit InputWindowInfoProto_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_layout_params_flags() const { return at<1>().valid(); } + uint32_t layout_params_flags() const { return at<1>().as_uint32(); } + bool has_layout_params_type() const { return at<2>().valid(); } + int32_t layout_params_type() const { return at<2>().as_int32(); } + bool has_frame() const { return at<3>().valid(); } + ::protozero::ConstBytes frame() const { return at<3>().as_bytes(); } + bool has_touchable_region() const { return at<4>().valid(); } + ::protozero::ConstBytes touchable_region() const { return at<4>().as_bytes(); } + bool has_surface_inset() const { return at<5>().valid(); } + int32_t surface_inset() const { return at<5>().as_int32(); } + bool has_visible() const { return at<6>().valid(); } + bool visible() const { return at<6>().as_bool(); } + bool has_can_receive_keys() const { return at<7>().valid(); } + bool can_receive_keys() const { return at<7>().as_bool(); } + bool has_focusable() const { return at<8>().valid(); } + bool focusable() const { return at<8>().as_bool(); } + bool has_has_wallpaper() const { return at<9>().valid(); } + bool has_wallpaper() const { return at<9>().as_bool(); } + bool has_global_scale_factor() const { return at<10>().valid(); } + float global_scale_factor() const { return at<10>().as_float(); } + bool has_window_x_scale() const { return at<11>().valid(); } + float window_x_scale() const { return at<11>().as_float(); } + bool has_window_y_scale() const { return at<12>().valid(); } + float window_y_scale() const { return at<12>().as_float(); } + bool has_crop_layer_id() const { return at<13>().valid(); } + int32_t crop_layer_id() const { return at<13>().as_int32(); } + bool has_replace_touchable_region_with_crop() const { return at<14>().valid(); } + bool replace_touchable_region_with_crop() const { return at<14>().as_bool(); } + bool has_touchable_region_crop() const { return at<15>().valid(); } + ::protozero::ConstBytes touchable_region_crop() const { return at<15>().as_bytes(); } + bool has_transform() const { return at<16>().valid(); } + ::protozero::ConstBytes transform() const { return at<16>().as_bytes(); } + bool has_input_config() const { return at<17>().valid(); } + uint32_t input_config() const { return at<17>().as_uint32(); } +}; + +class InputWindowInfoProto : public ::protozero::Message { + public: + using Decoder = InputWindowInfoProto_Decoder; + enum : int32_t { + kLayoutParamsFlagsFieldNumber = 1, + kLayoutParamsTypeFieldNumber = 2, + kFrameFieldNumber = 3, + kTouchableRegionFieldNumber = 4, + kSurfaceInsetFieldNumber = 5, + kVisibleFieldNumber = 6, + kCanReceiveKeysFieldNumber = 7, + kFocusableFieldNumber = 8, + kHasWallpaperFieldNumber = 9, + kGlobalScaleFactorFieldNumber = 10, + kWindowXScaleFieldNumber = 11, + kWindowYScaleFieldNumber = 12, + kCropLayerIdFieldNumber = 13, + kReplaceTouchableRegionWithCropFieldNumber = 14, + kTouchableRegionCropFieldNumber = 15, + kTransformFieldNumber = 16, + kInputConfigFieldNumber = 17, + }; + static constexpr const char* GetName() { return ".perfetto.protos.InputWindowInfoProto"; } + + + using FieldMetadata_LayoutParamsFlags = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + InputWindowInfoProto>; + + static constexpr FieldMetadata_LayoutParamsFlags kLayoutParamsFlags{}; + void set_layout_params_flags(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_LayoutParamsFlags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_LayoutParamsType = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + InputWindowInfoProto>; + + static constexpr FieldMetadata_LayoutParamsType kLayoutParamsType{}; + void set_layout_params_type(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_LayoutParamsType::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Frame = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + RectProto, + InputWindowInfoProto>; + + static constexpr FieldMetadata_Frame kFrame{}; + template T* set_frame() { + return BeginNestedMessage(3); + } + + + using FieldMetadata_TouchableRegion = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + RegionProto, + InputWindowInfoProto>; + + static constexpr FieldMetadata_TouchableRegion kTouchableRegion{}; + template T* set_touchable_region() { + return BeginNestedMessage(4); + } + + + using FieldMetadata_SurfaceInset = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + InputWindowInfoProto>; + + static constexpr FieldMetadata_SurfaceInset kSurfaceInset{}; + void set_surface_inset(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_SurfaceInset::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Visible = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + InputWindowInfoProto>; + + static constexpr FieldMetadata_Visible kVisible{}; + void set_visible(bool value) { + static constexpr uint32_t field_id = FieldMetadata_Visible::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CanReceiveKeys = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + InputWindowInfoProto>; + + static constexpr FieldMetadata_CanReceiveKeys kCanReceiveKeys{}; + void set_can_receive_keys(bool value) { + static constexpr uint32_t field_id = FieldMetadata_CanReceiveKeys::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Focusable = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + InputWindowInfoProto>; + + static constexpr FieldMetadata_Focusable kFocusable{}; + void set_focusable(bool value) { + static constexpr uint32_t field_id = FieldMetadata_Focusable::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_HasWallpaper = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + InputWindowInfoProto>; + + static constexpr FieldMetadata_HasWallpaper kHasWallpaper{}; + void set_has_wallpaper(bool value) { + static constexpr uint32_t field_id = FieldMetadata_HasWallpaper::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_GlobalScaleFactor = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + InputWindowInfoProto>; + + static constexpr FieldMetadata_GlobalScaleFactor kGlobalScaleFactor{}; + void set_global_scale_factor(float value) { + static constexpr uint32_t field_id = FieldMetadata_GlobalScaleFactor::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } + + using FieldMetadata_WindowXScale = + ::protozero::proto_utils::FieldMetadata< + 11, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + InputWindowInfoProto>; + + static constexpr FieldMetadata_WindowXScale kWindowXScale{}; + void set_window_x_scale(float value) { + static constexpr uint32_t field_id = FieldMetadata_WindowXScale::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } + + using FieldMetadata_WindowYScale = + ::protozero::proto_utils::FieldMetadata< + 12, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + InputWindowInfoProto>; + + static constexpr FieldMetadata_WindowYScale kWindowYScale{}; + void set_window_y_scale(float value) { + static constexpr uint32_t field_id = FieldMetadata_WindowYScale::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CropLayerId = + ::protozero::proto_utils::FieldMetadata< + 13, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + InputWindowInfoProto>; + + static constexpr FieldMetadata_CropLayerId kCropLayerId{}; + void set_crop_layer_id(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_CropLayerId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ReplaceTouchableRegionWithCrop = + ::protozero::proto_utils::FieldMetadata< + 14, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + InputWindowInfoProto>; + + static constexpr FieldMetadata_ReplaceTouchableRegionWithCrop kReplaceTouchableRegionWithCrop{}; + void set_replace_touchable_region_with_crop(bool value) { + static constexpr uint32_t field_id = FieldMetadata_ReplaceTouchableRegionWithCrop::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TouchableRegionCrop = + ::protozero::proto_utils::FieldMetadata< + 15, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + RectProto, + InputWindowInfoProto>; + + static constexpr FieldMetadata_TouchableRegionCrop kTouchableRegionCrop{}; + template T* set_touchable_region_crop() { + return BeginNestedMessage(15); + } + + + using FieldMetadata_Transform = + ::protozero::proto_utils::FieldMetadata< + 16, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TransformProto, + InputWindowInfoProto>; + + static constexpr FieldMetadata_Transform kTransform{}; + template T* set_transform() { + return BeginNestedMessage(16); + } + + + using FieldMetadata_InputConfig = + ::protozero::proto_utils::FieldMetadata< + 17, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + InputWindowInfoProto>; + + static constexpr FieldMetadata_InputConfig kInputConfig{}; + void set_input_config(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_InputConfig::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class ColorProto_Decoder : public ::protozero::TypedProtoDecoder { + public: + ColorProto_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ColorProto_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ColorProto_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_r() const { return at<1>().valid(); } + float r() const { return at<1>().as_float(); } + bool has_g() const { return at<2>().valid(); } + float g() const { return at<2>().as_float(); } + bool has_b() const { return at<3>().valid(); } + float b() const { return at<3>().as_float(); } + bool has_a() const { return at<4>().valid(); } + float a() const { return at<4>().as_float(); } +}; + +class ColorProto : public ::protozero::Message { + public: + using Decoder = ColorProto_Decoder; + enum : int32_t { + kRFieldNumber = 1, + kGFieldNumber = 2, + kBFieldNumber = 3, + kAFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ColorProto"; } + + + using FieldMetadata_R = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + ColorProto>; + + static constexpr FieldMetadata_R kR{}; + void set_r(float value) { + static constexpr uint32_t field_id = FieldMetadata_R::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } + + using FieldMetadata_G = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + ColorProto>; + + static constexpr FieldMetadata_G kG{}; + void set_g(float value) { + static constexpr uint32_t field_id = FieldMetadata_G::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } + + using FieldMetadata_B = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + ColorProto>; + + static constexpr FieldMetadata_B kB{}; + void set_b(float value) { + static constexpr uint32_t field_id = FieldMetadata_B::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } + + using FieldMetadata_A = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + ColorProto>; + + static constexpr FieldMetadata_A kA{}; + void set_a(float value) { + static constexpr uint32_t field_id = FieldMetadata_A::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } +}; + +class TransformProto_Decoder : public ::protozero::TypedProtoDecoder { + public: + TransformProto_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TransformProto_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TransformProto_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dsdx() const { return at<1>().valid(); } + float dsdx() const { return at<1>().as_float(); } + bool has_dtdx() const { return at<2>().valid(); } + float dtdx() const { return at<2>().as_float(); } + bool has_dsdy() const { return at<3>().valid(); } + float dsdy() const { return at<3>().as_float(); } + bool has_dtdy() const { return at<4>().valid(); } + float dtdy() const { return at<4>().as_float(); } + bool has_type() const { return at<5>().valid(); } + int32_t type() const { return at<5>().as_int32(); } +}; + +class TransformProto : public ::protozero::Message { + public: + using Decoder = TransformProto_Decoder; + enum : int32_t { + kDsdxFieldNumber = 1, + kDtdxFieldNumber = 2, + kDsdyFieldNumber = 3, + kDtdyFieldNumber = 4, + kTypeFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.TransformProto"; } + + + using FieldMetadata_Dsdx = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + TransformProto>; + + static constexpr FieldMetadata_Dsdx kDsdx{}; + void set_dsdx(float value) { + static constexpr uint32_t field_id = FieldMetadata_Dsdx::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Dtdx = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + TransformProto>; + + static constexpr FieldMetadata_Dtdx kDtdx{}; + void set_dtdx(float value) { + static constexpr uint32_t field_id = FieldMetadata_Dtdx::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Dsdy = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + TransformProto>; + + static constexpr FieldMetadata_Dsdy kDsdy{}; + void set_dsdy(float value) { + static constexpr uint32_t field_id = FieldMetadata_Dsdy::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Dtdy = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + TransformProto>; + + static constexpr FieldMetadata_Dtdy kDtdy{}; + void set_dtdy(float value) { + static constexpr uint32_t field_id = FieldMetadata_Dtdy::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Type = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + TransformProto>; + + static constexpr FieldMetadata_Type kType{}; + void set_type(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class SizeProto_Decoder : public ::protozero::TypedProtoDecoder { + public: + SizeProto_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit SizeProto_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit SizeProto_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_w() const { return at<1>().valid(); } + int32_t w() const { return at<1>().as_int32(); } + bool has_h() const { return at<2>().valid(); } + int32_t h() const { return at<2>().as_int32(); } +}; + +class SizeProto : public ::protozero::Message { + public: + using Decoder = SizeProto_Decoder; + enum : int32_t { + kWFieldNumber = 1, + kHFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.SizeProto"; } + + + using FieldMetadata_W = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + SizeProto>; + + static constexpr FieldMetadata_W kW{}; + void set_w(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_W::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_H = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + SizeProto>; + + static constexpr FieldMetadata_H kH{}; + void set_h(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_H::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class RectProto_Decoder : public ::protozero::TypedProtoDecoder { + public: + RectProto_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit RectProto_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit RectProto_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_left() const { return at<1>().valid(); } + int32_t left() const { return at<1>().as_int32(); } + bool has_top() const { return at<2>().valid(); } + int32_t top() const { return at<2>().as_int32(); } + bool has_right() const { return at<3>().valid(); } + int32_t right() const { return at<3>().as_int32(); } + bool has_bottom() const { return at<4>().valid(); } + int32_t bottom() const { return at<4>().as_int32(); } +}; + +class RectProto : public ::protozero::Message { + public: + using Decoder = RectProto_Decoder; + enum : int32_t { + kLeftFieldNumber = 1, + kTopFieldNumber = 2, + kRightFieldNumber = 3, + kBottomFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.RectProto"; } + + + using FieldMetadata_Left = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + RectProto>; + + static constexpr FieldMetadata_Left kLeft{}; + void set_left(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Left::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Top = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + RectProto>; + + static constexpr FieldMetadata_Top kTop{}; + void set_top(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Top::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Right = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + RectProto>; + + static constexpr FieldMetadata_Right kRight{}; + void set_right(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Right::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Bottom = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + RectProto>; + + static constexpr FieldMetadata_Bottom kBottom{}; + void set_bottom(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Bottom::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class RegionProto_Decoder : public ::protozero::TypedProtoDecoder { + public: + RegionProto_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit RegionProto_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit RegionProto_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_rect() const { return at<2>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> rect() const { return GetRepeated<::protozero::ConstBytes>(2); } +}; + +class RegionProto : public ::protozero::Message { + public: + using Decoder = RegionProto_Decoder; + enum : int32_t { + kRectFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.RegionProto"; } + + + using FieldMetadata_Rect = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + RectProto, + RegionProto>; + + static constexpr FieldMetadata_Rect kRect{}; + template T* add_rect() { + return BeginNestedMessage(2); + } + +}; + +class ShellHandlerMapping_Decoder : public ::protozero::TypedProtoDecoder { + public: + ShellHandlerMapping_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ShellHandlerMapping_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ShellHandlerMapping_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_id() const { return at<1>().valid(); } + int32_t id() const { return at<1>().as_int32(); } + bool has_name() const { return at<2>().valid(); } + ::protozero::ConstChars name() const { return at<2>().as_string(); } +}; + +class ShellHandlerMapping : public ::protozero::Message { + public: + using Decoder = ShellHandlerMapping_Decoder; + enum : int32_t { + kIdFieldNumber = 1, + kNameFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ShellHandlerMapping"; } + + + using FieldMetadata_Id = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + ShellHandlerMapping>; + + static constexpr FieldMetadata_Id kId{}; + void set_id(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + ShellHandlerMapping>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class ShellHandlerMappings_Decoder : public ::protozero::TypedProtoDecoder { + public: + ShellHandlerMappings_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ShellHandlerMappings_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ShellHandlerMappings_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_mapping() const { return at<1>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> mapping() const { return GetRepeated<::protozero::ConstBytes>(1); } +}; + +class ShellHandlerMappings : public ::protozero::Message { + public: + using Decoder = ShellHandlerMappings_Decoder; + enum : int32_t { + kMappingFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ShellHandlerMappings"; } + + + using FieldMetadata_Mapping = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ShellHandlerMapping, + ShellHandlerMappings>; + + static constexpr FieldMetadata_Mapping kMapping{}; + template T* add_mapping() { + return BeginNestedMessage(1); + } + +}; + +class ShellTransition_Decoder : public ::protozero::TypedProtoDecoder { + public: + ShellTransition_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ShellTransition_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ShellTransition_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_id() const { return at<1>().valid(); } + int32_t id() const { return at<1>().as_int32(); } + bool has_create_time_ns() const { return at<2>().valid(); } + int64_t create_time_ns() const { return at<2>().as_int64(); } + bool has_send_time_ns() const { return at<3>().valid(); } + int64_t send_time_ns() const { return at<3>().as_int64(); } + bool has_dispatch_time_ns() const { return at<4>().valid(); } + int64_t dispatch_time_ns() const { return at<4>().as_int64(); } + bool has_merge_time_ns() const { return at<5>().valid(); } + int64_t merge_time_ns() const { return at<5>().as_int64(); } + bool has_merge_request_time_ns() const { return at<6>().valid(); } + int64_t merge_request_time_ns() const { return at<6>().as_int64(); } + bool has_shell_abort_time_ns() const { return at<7>().valid(); } + int64_t shell_abort_time_ns() const { return at<7>().as_int64(); } + bool has_wm_abort_time_ns() const { return at<8>().valid(); } + int64_t wm_abort_time_ns() const { return at<8>().as_int64(); } + bool has_finish_time_ns() const { return at<9>().valid(); } + int64_t finish_time_ns() const { return at<9>().as_int64(); } + bool has_start_transaction_id() const { return at<10>().valid(); } + uint64_t start_transaction_id() const { return at<10>().as_uint64(); } + bool has_finish_transaction_id() const { return at<11>().valid(); } + uint64_t finish_transaction_id() const { return at<11>().as_uint64(); } + bool has_handler() const { return at<12>().valid(); } + int32_t handler() const { return at<12>().as_int32(); } + bool has_type() const { return at<13>().valid(); } + int32_t type() const { return at<13>().as_int32(); } + bool has_targets() const { return at<14>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> targets() const { return GetRepeated<::protozero::ConstBytes>(14); } + bool has_merge_target() const { return at<15>().valid(); } + int32_t merge_target() const { return at<15>().as_int32(); } + bool has_flags() const { return at<16>().valid(); } + int32_t flags() const { return at<16>().as_int32(); } + bool has_starting_window_remove_time_ns() const { return at<17>().valid(); } + int64_t starting_window_remove_time_ns() const { return at<17>().as_int64(); } +}; + +class ShellTransition : public ::protozero::Message { + public: + using Decoder = ShellTransition_Decoder; + enum : int32_t { + kIdFieldNumber = 1, + kCreateTimeNsFieldNumber = 2, + kSendTimeNsFieldNumber = 3, + kDispatchTimeNsFieldNumber = 4, + kMergeTimeNsFieldNumber = 5, + kMergeRequestTimeNsFieldNumber = 6, + kShellAbortTimeNsFieldNumber = 7, + kWmAbortTimeNsFieldNumber = 8, + kFinishTimeNsFieldNumber = 9, + kStartTransactionIdFieldNumber = 10, + kFinishTransactionIdFieldNumber = 11, + kHandlerFieldNumber = 12, + kTypeFieldNumber = 13, + kTargetsFieldNumber = 14, + kMergeTargetFieldNumber = 15, + kFlagsFieldNumber = 16, + kStartingWindowRemoveTimeNsFieldNumber = 17, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ShellTransition"; } + + using Target = ::perfetto::protos::pbzero::ShellTransition_Target; + + using FieldMetadata_Id = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + ShellTransition>; + + static constexpr FieldMetadata_Id kId{}; + void set_id(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CreateTimeNs = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + ShellTransition>; + + static constexpr FieldMetadata_CreateTimeNs kCreateTimeNs{}; + void set_create_time_ns(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_CreateTimeNs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SendTimeNs = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + ShellTransition>; + + static constexpr FieldMetadata_SendTimeNs kSendTimeNs{}; + void set_send_time_ns(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_SendTimeNs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DispatchTimeNs = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + ShellTransition>; + + static constexpr FieldMetadata_DispatchTimeNs kDispatchTimeNs{}; + void set_dispatch_time_ns(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_DispatchTimeNs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_MergeTimeNs = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + ShellTransition>; + + static constexpr FieldMetadata_MergeTimeNs kMergeTimeNs{}; + void set_merge_time_ns(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_MergeTimeNs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_MergeRequestTimeNs = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + ShellTransition>; + + static constexpr FieldMetadata_MergeRequestTimeNs kMergeRequestTimeNs{}; + void set_merge_request_time_ns(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_MergeRequestTimeNs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ShellAbortTimeNs = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + ShellTransition>; + + static constexpr FieldMetadata_ShellAbortTimeNs kShellAbortTimeNs{}; + void set_shell_abort_time_ns(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_ShellAbortTimeNs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_WmAbortTimeNs = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + ShellTransition>; + + static constexpr FieldMetadata_WmAbortTimeNs kWmAbortTimeNs{}; + void set_wm_abort_time_ns(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_WmAbortTimeNs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FinishTimeNs = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + ShellTransition>; + + static constexpr FieldMetadata_FinishTimeNs kFinishTimeNs{}; + void set_finish_time_ns(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_FinishTimeNs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_StartTransactionId = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + ShellTransition>; + + static constexpr FieldMetadata_StartTransactionId kStartTransactionId{}; + void set_start_transaction_id(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_StartTransactionId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FinishTransactionId = + ::protozero::proto_utils::FieldMetadata< + 11, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + ShellTransition>; + + static constexpr FieldMetadata_FinishTransactionId kFinishTransactionId{}; + void set_finish_transaction_id(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_FinishTransactionId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Handler = + ::protozero::proto_utils::FieldMetadata< + 12, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + ShellTransition>; + + static constexpr FieldMetadata_Handler kHandler{}; + void set_handler(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Handler::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Type = + ::protozero::proto_utils::FieldMetadata< + 13, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + ShellTransition>; + + static constexpr FieldMetadata_Type kType{}; + void set_type(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Targets = + ::protozero::proto_utils::FieldMetadata< + 14, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ShellTransition_Target, + ShellTransition>; + + static constexpr FieldMetadata_Targets kTargets{}; + template T* add_targets() { + return BeginNestedMessage(14); + } + + + using FieldMetadata_MergeTarget = + ::protozero::proto_utils::FieldMetadata< + 15, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + ShellTransition>; + + static constexpr FieldMetadata_MergeTarget kMergeTarget{}; + void set_merge_target(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_MergeTarget::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Flags = + ::protozero::proto_utils::FieldMetadata< + 16, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + ShellTransition>; + + static constexpr FieldMetadata_Flags kFlags{}; + void set_flags(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_StartingWindowRemoveTimeNs = + ::protozero::proto_utils::FieldMetadata< + 17, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + ShellTransition>; + + static constexpr FieldMetadata_StartingWindowRemoveTimeNs kStartingWindowRemoveTimeNs{}; + void set_starting_window_remove_time_ns(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_StartingWindowRemoveTimeNs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } +}; + +class ShellTransition_Target_Decoder : public ::protozero::TypedProtoDecoder { + public: + ShellTransition_Target_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ShellTransition_Target_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ShellTransition_Target_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_mode() const { return at<1>().valid(); } + int32_t mode() const { return at<1>().as_int32(); } + bool has_layer_id() const { return at<2>().valid(); } + int32_t layer_id() const { return at<2>().as_int32(); } + bool has_window_id() const { return at<3>().valid(); } + int32_t window_id() const { return at<3>().as_int32(); } + bool has_flags() const { return at<4>().valid(); } + int32_t flags() const { return at<4>().as_int32(); } +}; + +class ShellTransition_Target : public ::protozero::Message { + public: + using Decoder = ShellTransition_Target_Decoder; + enum : int32_t { + kModeFieldNumber = 1, + kLayerIdFieldNumber = 2, + kWindowIdFieldNumber = 3, + kFlagsFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ShellTransition.Target"; } + + + using FieldMetadata_Mode = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + ShellTransition_Target>; + + static constexpr FieldMetadata_Mode kMode{}; + void set_mode(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Mode::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_LayerId = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + ShellTransition_Target>; + + static constexpr FieldMetadata_LayerId kLayerId{}; + void set_layer_id(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_LayerId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_WindowId = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + ShellTransition_Target>; + + static constexpr FieldMetadata_WindowId kWindowId{}; + void set_window_id(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_WindowId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Flags = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + ShellTransition_Target>; + + static constexpr FieldMetadata_Flags kFlags{}; + void set_flags(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class ProtoLogViewerConfig_Decoder : public ::protozero::TypedProtoDecoder { + public: + ProtoLogViewerConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ProtoLogViewerConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ProtoLogViewerConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_messages() const { return at<1>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> messages() const { return GetRepeated<::protozero::ConstBytes>(1); } + bool has_groups() const { return at<2>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> groups() const { return GetRepeated<::protozero::ConstBytes>(2); } +}; + +class ProtoLogViewerConfig : public ::protozero::Message { + public: + using Decoder = ProtoLogViewerConfig_Decoder; + enum : int32_t { + kMessagesFieldNumber = 1, + kGroupsFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ProtoLogViewerConfig"; } + + using MessageData = ::perfetto::protos::pbzero::ProtoLogViewerConfig_MessageData; + using Group = ::perfetto::protos::pbzero::ProtoLogViewerConfig_Group; + + using FieldMetadata_Messages = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ProtoLogViewerConfig_MessageData, + ProtoLogViewerConfig>; + + static constexpr FieldMetadata_Messages kMessages{}; + template T* add_messages() { + return BeginNestedMessage(1); + } + + + using FieldMetadata_Groups = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ProtoLogViewerConfig_Group, + ProtoLogViewerConfig>; + + static constexpr FieldMetadata_Groups kGroups{}; + template T* add_groups() { + return BeginNestedMessage(2); + } + +}; + +class ProtoLogViewerConfig_Group_Decoder : public ::protozero::TypedProtoDecoder { + public: + ProtoLogViewerConfig_Group_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ProtoLogViewerConfig_Group_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ProtoLogViewerConfig_Group_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_id() const { return at<1>().valid(); } + uint32_t id() const { return at<1>().as_uint32(); } + bool has_name() const { return at<2>().valid(); } + ::protozero::ConstChars name() const { return at<2>().as_string(); } + bool has_tag() const { return at<3>().valid(); } + ::protozero::ConstChars tag() const { return at<3>().as_string(); } +}; + +class ProtoLogViewerConfig_Group : public ::protozero::Message { + public: + using Decoder = ProtoLogViewerConfig_Group_Decoder; + enum : int32_t { + kIdFieldNumber = 1, + kNameFieldNumber = 2, + kTagFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ProtoLogViewerConfig.Group"; } + + + using FieldMetadata_Id = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + ProtoLogViewerConfig_Group>; + + static constexpr FieldMetadata_Id kId{}; + void set_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + ProtoLogViewerConfig_Group>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Tag = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + ProtoLogViewerConfig_Group>; + + static constexpr FieldMetadata_Tag kTag{}; + void set_tag(const char* data, size_t size) { + AppendBytes(FieldMetadata_Tag::kFieldId, data, size); + } + void set_tag(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Tag::kFieldId, chars.data, chars.size); + } + void set_tag(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Tag::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class ProtoLogViewerConfig_MessageData_Decoder : public ::protozero::TypedProtoDecoder { + public: + ProtoLogViewerConfig_MessageData_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ProtoLogViewerConfig_MessageData_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ProtoLogViewerConfig_MessageData_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_message_id() const { return at<1>().valid(); } + uint64_t message_id() const { return at<1>().as_uint64(); } + bool has_message() const { return at<2>().valid(); } + ::protozero::ConstChars message() const { return at<2>().as_string(); } + bool has_level() const { return at<3>().valid(); } + int32_t level() const { return at<3>().as_int32(); } + bool has_group_id() const { return at<4>().valid(); } + uint32_t group_id() const { return at<4>().as_uint32(); } +}; + +class ProtoLogViewerConfig_MessageData : public ::protozero::Message { + public: + using Decoder = ProtoLogViewerConfig_MessageData_Decoder; + enum : int32_t { + kMessageIdFieldNumber = 1, + kMessageFieldNumber = 2, + kLevelFieldNumber = 3, + kGroupIdFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ProtoLogViewerConfig.MessageData"; } + + + using FieldMetadata_MessageId = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFixed64, + uint64_t, + ProtoLogViewerConfig_MessageData>; + + static constexpr FieldMetadata_MessageId kMessageId{}; + void set_message_id(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_MessageId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFixed64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Message = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + ProtoLogViewerConfig_MessageData>; + + static constexpr FieldMetadata_Message kMessage{}; + void set_message(const char* data, size_t size) { + AppendBytes(FieldMetadata_Message::kFieldId, data, size); + } + void set_message(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Message::kFieldId, chars.data, chars.size); + } + void set_message(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Message::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Level = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + ProtoLogLevel, + ProtoLogViewerConfig_MessageData>; + + static constexpr FieldMetadata_Level kLevel{}; + void set_level(ProtoLogLevel value) { + static constexpr uint32_t field_id = FieldMetadata_Level::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_GroupId = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + ProtoLogViewerConfig_MessageData>; + + static constexpr FieldMetadata_GroupId kGroupId{}; + void set_group_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_GroupId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class ProtoLogMessage_Decoder : public ::protozero::TypedProtoDecoder { + public: + ProtoLogMessage_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ProtoLogMessage_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ProtoLogMessage_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_message_id() const { return at<1>().valid(); } + uint64_t message_id() const { return at<1>().as_uint64(); } + bool has_str_param_iids() const { return at<2>().valid(); } + ::protozero::RepeatedFieldIterator str_param_iids() const { return GetRepeated(2); } + bool has_sint64_params() const { return at<3>().valid(); } + ::protozero::RepeatedFieldIterator sint64_params() const { return GetRepeated(3); } + bool has_double_params() const { return at<4>().valid(); } + ::protozero::RepeatedFieldIterator double_params() const { return GetRepeated(4); } + bool has_boolean_params() const { return at<5>().valid(); } + ::protozero::RepeatedFieldIterator boolean_params() const { return GetRepeated(5); } + bool has_stacktrace_iid() const { return at<6>().valid(); } + uint32_t stacktrace_iid() const { return at<6>().as_uint32(); } +}; + +class ProtoLogMessage : public ::protozero::Message { + public: + using Decoder = ProtoLogMessage_Decoder; + enum : int32_t { + kMessageIdFieldNumber = 1, + kStrParamIidsFieldNumber = 2, + kSint64ParamsFieldNumber = 3, + kDoubleParamsFieldNumber = 4, + kBooleanParamsFieldNumber = 5, + kStacktraceIidFieldNumber = 6, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ProtoLogMessage"; } + + + using FieldMetadata_MessageId = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFixed64, + uint64_t, + ProtoLogMessage>; + + static constexpr FieldMetadata_MessageId kMessageId{}; + void set_message_id(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_MessageId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFixed64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_StrParamIids = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + ProtoLogMessage>; + + static constexpr FieldMetadata_StrParamIids kStrParamIids{}; + void add_str_param_iids(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_StrParamIids::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Sint64Params = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kSint64, + int64_t, + ProtoLogMessage>; + + static constexpr FieldMetadata_Sint64Params kSint64Params{}; + void add_sint64_params(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Sint64Params::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kSint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DoubleParams = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kDouble, + double, + ProtoLogMessage>; + + static constexpr FieldMetadata_DoubleParams kDoubleParams{}; + void add_double_params(double value) { + static constexpr uint32_t field_id = FieldMetadata_DoubleParams::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kDouble> + ::Append(*this, field_id, value); + } + + using FieldMetadata_BooleanParams = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + ProtoLogMessage>; + + static constexpr FieldMetadata_BooleanParams kBooleanParams{}; + void add_boolean_params(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_BooleanParams::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_StacktraceIid = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + ProtoLogMessage>; + + static constexpr FieldMetadata_StacktraceIid kStacktraceIid{}; + void set_stacktrace_iid(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_StacktraceIid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class PackagesList_Decoder : public ::protozero::TypedProtoDecoder { + public: + PackagesList_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit PackagesList_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit PackagesList_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_packages() const { return at<1>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> packages() const { return GetRepeated<::protozero::ConstBytes>(1); } + bool has_parse_error() const { return at<2>().valid(); } + bool parse_error() const { return at<2>().as_bool(); } + bool has_read_error() const { return at<3>().valid(); } + bool read_error() const { return at<3>().as_bool(); } +}; + +class PackagesList : public ::protozero::Message { + public: + using Decoder = PackagesList_Decoder; + enum : int32_t { + kPackagesFieldNumber = 1, + kParseErrorFieldNumber = 2, + kReadErrorFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.PackagesList"; } + + using PackageInfo = ::perfetto::protos::pbzero::PackagesList_PackageInfo; + + using FieldMetadata_Packages = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + PackagesList_PackageInfo, + PackagesList>; + + static constexpr FieldMetadata_Packages kPackages{}; + template T* add_packages() { + return BeginNestedMessage(1); + } + + + using FieldMetadata_ParseError = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + PackagesList>; + + static constexpr FieldMetadata_ParseError kParseError{}; + void set_parse_error(bool value) { + static constexpr uint32_t field_id = FieldMetadata_ParseError::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ReadError = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + PackagesList>; + + static constexpr FieldMetadata_ReadError kReadError{}; + void set_read_error(bool value) { + static constexpr uint32_t field_id = FieldMetadata_ReadError::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } +}; + +class PackagesList_PackageInfo_Decoder : public ::protozero::TypedProtoDecoder { + public: + PackagesList_PackageInfo_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit PackagesList_PackageInfo_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit PackagesList_PackageInfo_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_name() const { return at<1>().valid(); } + ::protozero::ConstChars name() const { return at<1>().as_string(); } + bool has_uid() const { return at<2>().valid(); } + uint64_t uid() const { return at<2>().as_uint64(); } + bool has_debuggable() const { return at<3>().valid(); } + bool debuggable() const { return at<3>().as_bool(); } + bool has_profileable_from_shell() const { return at<4>().valid(); } + bool profileable_from_shell() const { return at<4>().as_bool(); } + bool has_version_code() const { return at<5>().valid(); } + int64_t version_code() const { return at<5>().as_int64(); } +}; + +class PackagesList_PackageInfo : public ::protozero::Message { + public: + using Decoder = PackagesList_PackageInfo_Decoder; + enum : int32_t { + kNameFieldNumber = 1, + kUidFieldNumber = 2, + kDebuggableFieldNumber = 3, + kProfileableFromShellFieldNumber = 4, + kVersionCodeFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.PackagesList.PackageInfo"; } + + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + PackagesList_PackageInfo>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Uid = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + PackagesList_PackageInfo>; + + static constexpr FieldMetadata_Uid kUid{}; + void set_uid(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Uid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Debuggable = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + PackagesList_PackageInfo>; + + static constexpr FieldMetadata_Debuggable kDebuggable{}; + void set_debuggable(bool value) { + static constexpr uint32_t field_id = FieldMetadata_Debuggable::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ProfileableFromShell = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + PackagesList_PackageInfo>; + + static constexpr FieldMetadata_ProfileableFromShell kProfileableFromShell{}; + void set_profileable_from_shell(bool value) { + static constexpr uint32_t field_id = FieldMetadata_ProfileableFromShell::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_VersionCode = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + PackagesList_PackageInfo>; + + static constexpr FieldMetadata_VersionCode kVersionCode{}; + void set_version_code(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_VersionCode::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } +}; + +class NetworkPacketContext_Decoder : public ::protozero::TypedProtoDecoder { + public: + NetworkPacketContext_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit NetworkPacketContext_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit NetworkPacketContext_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_iid() const { return at<1>().valid(); } + uint64_t iid() const { return at<1>().as_uint64(); } + bool has_ctx() const { return at<2>().valid(); } + ::protozero::ConstBytes ctx() const { return at<2>().as_bytes(); } +}; + +class NetworkPacketContext : public ::protozero::Message { + public: + using Decoder = NetworkPacketContext_Decoder; + enum : int32_t { + kIidFieldNumber = 1, + kCtxFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.NetworkPacketContext"; } + + + using FieldMetadata_Iid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + NetworkPacketContext>; + + static constexpr FieldMetadata_Iid kIid{}; + void set_iid(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Iid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ctx = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + NetworkPacketEvent, + NetworkPacketContext>; + + static constexpr FieldMetadata_Ctx kCtx{}; + template T* set_ctx() { + return BeginNestedMessage(2); + } + +}; + +class NetworkPacketBundle_Decoder : public ::protozero::TypedProtoDecoder { + public: + NetworkPacketBundle_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit NetworkPacketBundle_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit NetworkPacketBundle_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_iid() const { return at<1>().valid(); } + uint64_t iid() const { return at<1>().as_uint64(); } + bool has_ctx() const { return at<2>().valid(); } + ::protozero::ConstBytes ctx() const { return at<2>().as_bytes(); } + bool has_packet_timestamps() const { return at<3>().valid(); } + ::protozero::PackedRepeatedFieldIterator<::protozero::proto_utils::ProtoWireType::kVarInt, uint64_t> packet_timestamps(bool* parse_error_ptr) const { return GetPackedRepeated<::protozero::proto_utils::ProtoWireType::kVarInt, uint64_t>(3, parse_error_ptr); } + bool has_packet_lengths() const { return at<4>().valid(); } + ::protozero::PackedRepeatedFieldIterator<::protozero::proto_utils::ProtoWireType::kVarInt, uint32_t> packet_lengths(bool* parse_error_ptr) const { return GetPackedRepeated<::protozero::proto_utils::ProtoWireType::kVarInt, uint32_t>(4, parse_error_ptr); } + bool has_total_packets() const { return at<5>().valid(); } + uint32_t total_packets() const { return at<5>().as_uint32(); } + bool has_total_duration() const { return at<6>().valid(); } + uint64_t total_duration() const { return at<6>().as_uint64(); } + bool has_total_length() const { return at<7>().valid(); } + uint64_t total_length() const { return at<7>().as_uint64(); } +}; + +class NetworkPacketBundle : public ::protozero::Message { + public: + using Decoder = NetworkPacketBundle_Decoder; + enum : int32_t { + kIidFieldNumber = 1, + kCtxFieldNumber = 2, + kPacketTimestampsFieldNumber = 3, + kPacketLengthsFieldNumber = 4, + kTotalPacketsFieldNumber = 5, + kTotalDurationFieldNumber = 6, + kTotalLengthFieldNumber = 7, + }; + static constexpr const char* GetName() { return ".perfetto.protos.NetworkPacketBundle"; } + + + using FieldMetadata_Iid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + NetworkPacketBundle>; + + static constexpr FieldMetadata_Iid kIid{}; + void set_iid(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Iid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ctx = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + NetworkPacketEvent, + NetworkPacketBundle>; + + static constexpr FieldMetadata_Ctx kCtx{}; + template T* set_ctx() { + return BeginNestedMessage(2); + } + + + using FieldMetadata_PacketTimestamps = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kRepeatedPacked, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + NetworkPacketBundle>; + + static constexpr FieldMetadata_PacketTimestamps kPacketTimestamps{}; + void set_packet_timestamps(const ::protozero::PackedVarInt& packed_buffer) { + AppendBytes(FieldMetadata_PacketTimestamps::kFieldId, packed_buffer.data(), + packed_buffer.size()); + } + + using FieldMetadata_PacketLengths = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kRepeatedPacked, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + NetworkPacketBundle>; + + static constexpr FieldMetadata_PacketLengths kPacketLengths{}; + void set_packet_lengths(const ::protozero::PackedVarInt& packed_buffer) { + AppendBytes(FieldMetadata_PacketLengths::kFieldId, packed_buffer.data(), + packed_buffer.size()); + } + + using FieldMetadata_TotalPackets = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + NetworkPacketBundle>; + + static constexpr FieldMetadata_TotalPackets kTotalPackets{}; + void set_total_packets(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TotalPackets::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TotalDuration = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + NetworkPacketBundle>; + + static constexpr FieldMetadata_TotalDuration kTotalDuration{}; + void set_total_duration(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_TotalDuration::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TotalLength = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + NetworkPacketBundle>; + + static constexpr FieldMetadata_TotalLength kTotalLength{}; + void set_total_length(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_TotalLength::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class NetworkPacketEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + NetworkPacketEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit NetworkPacketEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit NetworkPacketEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_direction() const { return at<1>().valid(); } + int32_t direction() const { return at<1>().as_int32(); } + bool has_interface() const { return at<2>().valid(); } + ::protozero::ConstChars interface() const { return at<2>().as_string(); } + bool has_length() const { return at<3>().valid(); } + uint32_t length() const { return at<3>().as_uint32(); } + bool has_uid() const { return at<4>().valid(); } + uint32_t uid() const { return at<4>().as_uint32(); } + bool has_tag() const { return at<5>().valid(); } + uint32_t tag() const { return at<5>().as_uint32(); } + bool has_ip_proto() const { return at<6>().valid(); } + uint32_t ip_proto() const { return at<6>().as_uint32(); } + bool has_tcp_flags() const { return at<7>().valid(); } + uint32_t tcp_flags() const { return at<7>().as_uint32(); } + bool has_local_port() const { return at<8>().valid(); } + uint32_t local_port() const { return at<8>().as_uint32(); } + bool has_remote_port() const { return at<9>().valid(); } + uint32_t remote_port() const { return at<9>().as_uint32(); } + bool has_icmp_type() const { return at<10>().valid(); } + uint32_t icmp_type() const { return at<10>().as_uint32(); } + bool has_icmp_code() const { return at<11>().valid(); } + uint32_t icmp_code() const { return at<11>().as_uint32(); } +}; + +class NetworkPacketEvent : public ::protozero::Message { + public: + using Decoder = NetworkPacketEvent_Decoder; + enum : int32_t { + kDirectionFieldNumber = 1, + kInterfaceFieldNumber = 2, + kLengthFieldNumber = 3, + kUidFieldNumber = 4, + kTagFieldNumber = 5, + kIpProtoFieldNumber = 6, + kTcpFlagsFieldNumber = 7, + kLocalPortFieldNumber = 8, + kRemotePortFieldNumber = 9, + kIcmpTypeFieldNumber = 10, + kIcmpCodeFieldNumber = 11, + }; + static constexpr const char* GetName() { return ".perfetto.protos.NetworkPacketEvent"; } + + + using FieldMetadata_Direction = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + TrafficDirection, + NetworkPacketEvent>; + + static constexpr FieldMetadata_Direction kDirection{}; + void set_direction(TrafficDirection value) { + static constexpr uint32_t field_id = FieldMetadata_Direction::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Interface = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + NetworkPacketEvent>; + + static constexpr FieldMetadata_Interface kInterface{}; + void set_interface(const char* data, size_t size) { + AppendBytes(FieldMetadata_Interface::kFieldId, data, size); + } + void set_interface(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Interface::kFieldId, chars.data, chars.size); + } + void set_interface(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Interface::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Length = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + NetworkPacketEvent>; + + static constexpr FieldMetadata_Length kLength{}; + void set_length(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Length::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Uid = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + NetworkPacketEvent>; + + static constexpr FieldMetadata_Uid kUid{}; + void set_uid(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Uid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Tag = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + NetworkPacketEvent>; + + static constexpr FieldMetadata_Tag kTag{}; + void set_tag(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Tag::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_IpProto = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + NetworkPacketEvent>; + + static constexpr FieldMetadata_IpProto kIpProto{}; + void set_ip_proto(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_IpProto::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TcpFlags = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + NetworkPacketEvent>; + + static constexpr FieldMetadata_TcpFlags kTcpFlags{}; + void set_tcp_flags(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TcpFlags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_LocalPort = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + NetworkPacketEvent>; + + static constexpr FieldMetadata_LocalPort kLocalPort{}; + void set_local_port(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_LocalPort::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_RemotePort = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + NetworkPacketEvent>; + + static constexpr FieldMetadata_RemotePort kRemotePort{}; + void set_remote_port(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_RemotePort::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_IcmpType = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + NetworkPacketEvent>; + + static constexpr FieldMetadata_IcmpType kIcmpType{}; + void set_icmp_type(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_IcmpType::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_IcmpCode = + ::protozero::proto_utils::FieldMetadata< + 11, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + NetworkPacketEvent>; + + static constexpr FieldMetadata_IcmpCode kIcmpCode{}; + void set_icmp_code(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_IcmpCode::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class InitialDisplayState_Decoder : public ::protozero::TypedProtoDecoder { + public: + InitialDisplayState_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit InitialDisplayState_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit InitialDisplayState_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_display_state() const { return at<1>().valid(); } + int32_t display_state() const { return at<1>().as_int32(); } + bool has_brightness() const { return at<2>().valid(); } + double brightness() const { return at<2>().as_double(); } +}; + +class InitialDisplayState : public ::protozero::Message { + public: + using Decoder = InitialDisplayState_Decoder; + enum : int32_t { + kDisplayStateFieldNumber = 1, + kBrightnessFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.InitialDisplayState"; } + + + using FieldMetadata_DisplayState = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + InitialDisplayState>; + + static constexpr FieldMetadata_DisplayState kDisplayState{}; + void set_display_state(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_DisplayState::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Brightness = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kDouble, + double, + InitialDisplayState>; + + static constexpr FieldMetadata_Brightness kBrightness{}; + void set_brightness(double value) { + static constexpr uint32_t field_id = FieldMetadata_Brightness::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kDouble> + ::Append(*this, field_id, value); + } +}; + +class GraphicsFrameEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + GraphicsFrameEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit GraphicsFrameEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit GraphicsFrameEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_buffer_event() const { return at<1>().valid(); } + ::protozero::ConstBytes buffer_event() const { return at<1>().as_bytes(); } +}; + +class GraphicsFrameEvent : public ::protozero::Message { + public: + using Decoder = GraphicsFrameEvent_Decoder; + enum : int32_t { + kBufferEventFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.GraphicsFrameEvent"; } + + using BufferEvent = ::perfetto::protos::pbzero::GraphicsFrameEvent_BufferEvent; + + using BufferEventType = ::perfetto::protos::pbzero::GraphicsFrameEvent_BufferEventType; + static inline const char* BufferEventType_Name(BufferEventType value) { + return ::perfetto::protos::pbzero::GraphicsFrameEvent_BufferEventType_Name(value); + } + static inline const BufferEventType UNSPECIFIED = BufferEventType::UNSPECIFIED; + static inline const BufferEventType DEQUEUE = BufferEventType::DEQUEUE; + static inline const BufferEventType QUEUE = BufferEventType::QUEUE; + static inline const BufferEventType POST = BufferEventType::POST; + static inline const BufferEventType ACQUIRE_FENCE = BufferEventType::ACQUIRE_FENCE; + static inline const BufferEventType LATCH = BufferEventType::LATCH; + static inline const BufferEventType HWC_COMPOSITION_QUEUED = BufferEventType::HWC_COMPOSITION_QUEUED; + static inline const BufferEventType FALLBACK_COMPOSITION = BufferEventType::FALLBACK_COMPOSITION; + static inline const BufferEventType PRESENT_FENCE = BufferEventType::PRESENT_FENCE; + static inline const BufferEventType RELEASE_FENCE = BufferEventType::RELEASE_FENCE; + static inline const BufferEventType MODIFY = BufferEventType::MODIFY; + static inline const BufferEventType DETACH = BufferEventType::DETACH; + static inline const BufferEventType ATTACH = BufferEventType::ATTACH; + static inline const BufferEventType CANCEL = BufferEventType::CANCEL; + + using FieldMetadata_BufferEvent = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + GraphicsFrameEvent_BufferEvent, + GraphicsFrameEvent>; + + static constexpr FieldMetadata_BufferEvent kBufferEvent{}; + template T* set_buffer_event() { + return BeginNestedMessage(1); + } + +}; + +class GraphicsFrameEvent_BufferEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + GraphicsFrameEvent_BufferEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit GraphicsFrameEvent_BufferEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit GraphicsFrameEvent_BufferEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_frame_number() const { return at<1>().valid(); } + uint32_t frame_number() const { return at<1>().as_uint32(); } + bool has_type() const { return at<2>().valid(); } + int32_t type() const { return at<2>().as_int32(); } + bool has_layer_name() const { return at<3>().valid(); } + ::protozero::ConstChars layer_name() const { return at<3>().as_string(); } + bool has_duration_ns() const { return at<4>().valid(); } + uint64_t duration_ns() const { return at<4>().as_uint64(); } + bool has_buffer_id() const { return at<5>().valid(); } + uint32_t buffer_id() const { return at<5>().as_uint32(); } +}; + +class GraphicsFrameEvent_BufferEvent : public ::protozero::Message { + public: + using Decoder = GraphicsFrameEvent_BufferEvent_Decoder; + enum : int32_t { + kFrameNumberFieldNumber = 1, + kTypeFieldNumber = 2, + kLayerNameFieldNumber = 3, + kDurationNsFieldNumber = 4, + kBufferIdFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.GraphicsFrameEvent.BufferEvent"; } + + + using FieldMetadata_FrameNumber = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + GraphicsFrameEvent_BufferEvent>; + + static constexpr FieldMetadata_FrameNumber kFrameNumber{}; + void set_frame_number(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_FrameNumber::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Type = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + GraphicsFrameEvent_BufferEventType, + GraphicsFrameEvent_BufferEvent>; + + static constexpr FieldMetadata_Type kType{}; + void set_type(GraphicsFrameEvent_BufferEventType value) { + static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_LayerName = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + GraphicsFrameEvent_BufferEvent>; + + static constexpr FieldMetadata_LayerName kLayerName{}; + void set_layer_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_LayerName::kFieldId, data, size); + } + void set_layer_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_LayerName::kFieldId, chars.data, chars.size); + } + void set_layer_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_LayerName::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DurationNs = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + GraphicsFrameEvent_BufferEvent>; + + static constexpr FieldMetadata_DurationNs kDurationNs{}; + void set_duration_ns(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_DurationNs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_BufferId = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + GraphicsFrameEvent_BufferEvent>; + + static constexpr FieldMetadata_BufferId kBufferId{}; + void set_buffer_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_BufferId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class GpuMemTotalEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + GpuMemTotalEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit GpuMemTotalEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit GpuMemTotalEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_gpu_id() const { return at<1>().valid(); } + uint32_t gpu_id() const { return at<1>().as_uint32(); } + bool has_pid() const { return at<2>().valid(); } + uint32_t pid() const { return at<2>().as_uint32(); } + bool has_size() const { return at<3>().valid(); } + uint64_t size() const { return at<3>().as_uint64(); } +}; + +class GpuMemTotalEvent : public ::protozero::Message { + public: + using Decoder = GpuMemTotalEvent_Decoder; + enum : int32_t { + kGpuIdFieldNumber = 1, + kPidFieldNumber = 2, + kSizeFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.GpuMemTotalEvent"; } + + + using FieldMetadata_GpuId = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + GpuMemTotalEvent>; + + static constexpr FieldMetadata_GpuId kGpuId{}; + void set_gpu_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_GpuId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pid = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + GpuMemTotalEvent>; + + static constexpr FieldMetadata_Pid kPid{}; + void set_pid(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Size = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + GpuMemTotalEvent>; + + static constexpr FieldMetadata_Size kSize{}; + void set_size(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Size::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class FrameTimelineEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + FrameTimelineEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit FrameTimelineEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit FrameTimelineEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_expected_display_frame_start() const { return at<1>().valid(); } + ::protozero::ConstBytes expected_display_frame_start() const { return at<1>().as_bytes(); } + bool has_actual_display_frame_start() const { return at<2>().valid(); } + ::protozero::ConstBytes actual_display_frame_start() const { return at<2>().as_bytes(); } + bool has_expected_surface_frame_start() const { return at<3>().valid(); } + ::protozero::ConstBytes expected_surface_frame_start() const { return at<3>().as_bytes(); } + bool has_actual_surface_frame_start() const { return at<4>().valid(); } + ::protozero::ConstBytes actual_surface_frame_start() const { return at<4>().as_bytes(); } + bool has_frame_end() const { return at<5>().valid(); } + ::protozero::ConstBytes frame_end() const { return at<5>().as_bytes(); } +}; + +class FrameTimelineEvent : public ::protozero::Message { + public: + using Decoder = FrameTimelineEvent_Decoder; + enum : int32_t { + kExpectedDisplayFrameStartFieldNumber = 1, + kActualDisplayFrameStartFieldNumber = 2, + kExpectedSurfaceFrameStartFieldNumber = 3, + kActualSurfaceFrameStartFieldNumber = 4, + kFrameEndFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.FrameTimelineEvent"; } + + using ExpectedSurfaceFrameStart = ::perfetto::protos::pbzero::FrameTimelineEvent_ExpectedSurfaceFrameStart; + using ActualSurfaceFrameStart = ::perfetto::protos::pbzero::FrameTimelineEvent_ActualSurfaceFrameStart; + using ExpectedDisplayFrameStart = ::perfetto::protos::pbzero::FrameTimelineEvent_ExpectedDisplayFrameStart; + using ActualDisplayFrameStart = ::perfetto::protos::pbzero::FrameTimelineEvent_ActualDisplayFrameStart; + using FrameEnd = ::perfetto::protos::pbzero::FrameTimelineEvent_FrameEnd; + + using JankType = ::perfetto::protos::pbzero::FrameTimelineEvent_JankType; + static inline const char* JankType_Name(JankType value) { + return ::perfetto::protos::pbzero::FrameTimelineEvent_JankType_Name(value); + } + + using JankSeverityType = ::perfetto::protos::pbzero::FrameTimelineEvent_JankSeverityType; + static inline const char* JankSeverityType_Name(JankSeverityType value) { + return ::perfetto::protos::pbzero::FrameTimelineEvent_JankSeverityType_Name(value); + } + + using PresentType = ::perfetto::protos::pbzero::FrameTimelineEvent_PresentType; + static inline const char* PresentType_Name(PresentType value) { + return ::perfetto::protos::pbzero::FrameTimelineEvent_PresentType_Name(value); + } + + using PredictionType = ::perfetto::protos::pbzero::FrameTimelineEvent_PredictionType; + static inline const char* PredictionType_Name(PredictionType value) { + return ::perfetto::protos::pbzero::FrameTimelineEvent_PredictionType_Name(value); + } + static inline const JankType JANK_UNSPECIFIED = JankType::JANK_UNSPECIFIED; + static inline const JankType JANK_NONE = JankType::JANK_NONE; + static inline const JankType JANK_SF_SCHEDULING = JankType::JANK_SF_SCHEDULING; + static inline const JankType JANK_PREDICTION_ERROR = JankType::JANK_PREDICTION_ERROR; + static inline const JankType JANK_DISPLAY_HAL = JankType::JANK_DISPLAY_HAL; + static inline const JankType JANK_SF_CPU_DEADLINE_MISSED = JankType::JANK_SF_CPU_DEADLINE_MISSED; + static inline const JankType JANK_SF_GPU_DEADLINE_MISSED = JankType::JANK_SF_GPU_DEADLINE_MISSED; + static inline const JankType JANK_APP_DEADLINE_MISSED = JankType::JANK_APP_DEADLINE_MISSED; + static inline const JankType JANK_BUFFER_STUFFING = JankType::JANK_BUFFER_STUFFING; + static inline const JankType JANK_UNKNOWN = JankType::JANK_UNKNOWN; + static inline const JankType JANK_SF_STUFFING = JankType::JANK_SF_STUFFING; + static inline const JankType JANK_DROPPED = JankType::JANK_DROPPED; + static inline const JankSeverityType SEVERITY_UNKNOWN = JankSeverityType::SEVERITY_UNKNOWN; + static inline const JankSeverityType SEVERITY_NONE = JankSeverityType::SEVERITY_NONE; + static inline const JankSeverityType SEVERITY_PARTIAL = JankSeverityType::SEVERITY_PARTIAL; + static inline const JankSeverityType SEVERITY_FULL = JankSeverityType::SEVERITY_FULL; + static inline const PresentType PRESENT_UNSPECIFIED = PresentType::PRESENT_UNSPECIFIED; + static inline const PresentType PRESENT_ON_TIME = PresentType::PRESENT_ON_TIME; + static inline const PresentType PRESENT_LATE = PresentType::PRESENT_LATE; + static inline const PresentType PRESENT_EARLY = PresentType::PRESENT_EARLY; + static inline const PresentType PRESENT_DROPPED = PresentType::PRESENT_DROPPED; + static inline const PresentType PRESENT_UNKNOWN = PresentType::PRESENT_UNKNOWN; + static inline const PredictionType PREDICTION_UNSPECIFIED = PredictionType::PREDICTION_UNSPECIFIED; + static inline const PredictionType PREDICTION_VALID = PredictionType::PREDICTION_VALID; + static inline const PredictionType PREDICTION_EXPIRED = PredictionType::PREDICTION_EXPIRED; + static inline const PredictionType PREDICTION_UNKNOWN = PredictionType::PREDICTION_UNKNOWN; + + using FieldMetadata_ExpectedDisplayFrameStart = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + FrameTimelineEvent_ExpectedDisplayFrameStart, + FrameTimelineEvent>; + + static constexpr FieldMetadata_ExpectedDisplayFrameStart kExpectedDisplayFrameStart{}; + template T* set_expected_display_frame_start() { + return BeginNestedMessage(1); + } + + + using FieldMetadata_ActualDisplayFrameStart = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + FrameTimelineEvent_ActualDisplayFrameStart, + FrameTimelineEvent>; + + static constexpr FieldMetadata_ActualDisplayFrameStart kActualDisplayFrameStart{}; + template T* set_actual_display_frame_start() { + return BeginNestedMessage(2); + } + + + using FieldMetadata_ExpectedSurfaceFrameStart = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + FrameTimelineEvent_ExpectedSurfaceFrameStart, + FrameTimelineEvent>; + + static constexpr FieldMetadata_ExpectedSurfaceFrameStart kExpectedSurfaceFrameStart{}; + template T* set_expected_surface_frame_start() { + return BeginNestedMessage(3); + } + + + using FieldMetadata_ActualSurfaceFrameStart = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + FrameTimelineEvent_ActualSurfaceFrameStart, + FrameTimelineEvent>; + + static constexpr FieldMetadata_ActualSurfaceFrameStart kActualSurfaceFrameStart{}; + template T* set_actual_surface_frame_start() { + return BeginNestedMessage(4); + } + + + using FieldMetadata_FrameEnd = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + FrameTimelineEvent_FrameEnd, + FrameTimelineEvent>; + + static constexpr FieldMetadata_FrameEnd kFrameEnd{}; + template T* set_frame_end() { + return BeginNestedMessage(5); + } + +}; + +class FrameTimelineEvent_FrameEnd_Decoder : public ::protozero::TypedProtoDecoder { + public: + FrameTimelineEvent_FrameEnd_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit FrameTimelineEvent_FrameEnd_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit FrameTimelineEvent_FrameEnd_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_cookie() const { return at<1>().valid(); } + int64_t cookie() const { return at<1>().as_int64(); } +}; + +class FrameTimelineEvent_FrameEnd : public ::protozero::Message { + public: + using Decoder = FrameTimelineEvent_FrameEnd_Decoder; + enum : int32_t { + kCookieFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.FrameTimelineEvent.FrameEnd"; } + + + using FieldMetadata_Cookie = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + FrameTimelineEvent_FrameEnd>; + + static constexpr FieldMetadata_Cookie kCookie{}; + void set_cookie(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Cookie::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } +}; + +class FrameTimelineEvent_ActualDisplayFrameStart_Decoder : public ::protozero::TypedProtoDecoder { + public: + FrameTimelineEvent_ActualDisplayFrameStart_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit FrameTimelineEvent_ActualDisplayFrameStart_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit FrameTimelineEvent_ActualDisplayFrameStart_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_cookie() const { return at<1>().valid(); } + int64_t cookie() const { return at<1>().as_int64(); } + bool has_token() const { return at<2>().valid(); } + int64_t token() const { return at<2>().as_int64(); } + bool has_pid() const { return at<3>().valid(); } + int32_t pid() const { return at<3>().as_int32(); } + bool has_present_type() const { return at<4>().valid(); } + int32_t present_type() const { return at<4>().as_int32(); } + bool has_on_time_finish() const { return at<5>().valid(); } + bool on_time_finish() const { return at<5>().as_bool(); } + bool has_gpu_composition() const { return at<6>().valid(); } + bool gpu_composition() const { return at<6>().as_bool(); } + bool has_jank_type() const { return at<7>().valid(); } + int32_t jank_type() const { return at<7>().as_int32(); } + bool has_prediction_type() const { return at<8>().valid(); } + int32_t prediction_type() const { return at<8>().as_int32(); } + bool has_jank_severity_type() const { return at<9>().valid(); } + int32_t jank_severity_type() const { return at<9>().as_int32(); } +}; + +class FrameTimelineEvent_ActualDisplayFrameStart : public ::protozero::Message { + public: + using Decoder = FrameTimelineEvent_ActualDisplayFrameStart_Decoder; + enum : int32_t { + kCookieFieldNumber = 1, + kTokenFieldNumber = 2, + kPidFieldNumber = 3, + kPresentTypeFieldNumber = 4, + kOnTimeFinishFieldNumber = 5, + kGpuCompositionFieldNumber = 6, + kJankTypeFieldNumber = 7, + kPredictionTypeFieldNumber = 8, + kJankSeverityTypeFieldNumber = 9, + }; + static constexpr const char* GetName() { return ".perfetto.protos.FrameTimelineEvent.ActualDisplayFrameStart"; } + + + using FieldMetadata_Cookie = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + FrameTimelineEvent_ActualDisplayFrameStart>; + + static constexpr FieldMetadata_Cookie kCookie{}; + void set_cookie(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Cookie::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Token = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + FrameTimelineEvent_ActualDisplayFrameStart>; + + static constexpr FieldMetadata_Token kToken{}; + void set_token(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Token::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pid = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + FrameTimelineEvent_ActualDisplayFrameStart>; + + static constexpr FieldMetadata_Pid kPid{}; + void set_pid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PresentType = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + FrameTimelineEvent_PresentType, + FrameTimelineEvent_ActualDisplayFrameStart>; + + static constexpr FieldMetadata_PresentType kPresentType{}; + void set_present_type(FrameTimelineEvent_PresentType value) { + static constexpr uint32_t field_id = FieldMetadata_PresentType::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_OnTimeFinish = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + FrameTimelineEvent_ActualDisplayFrameStart>; + + static constexpr FieldMetadata_OnTimeFinish kOnTimeFinish{}; + void set_on_time_finish(bool value) { + static constexpr uint32_t field_id = FieldMetadata_OnTimeFinish::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_GpuComposition = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + FrameTimelineEvent_ActualDisplayFrameStart>; + + static constexpr FieldMetadata_GpuComposition kGpuComposition{}; + void set_gpu_composition(bool value) { + static constexpr uint32_t field_id = FieldMetadata_GpuComposition::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_JankType = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + FrameTimelineEvent_ActualDisplayFrameStart>; + + static constexpr FieldMetadata_JankType kJankType{}; + void set_jank_type(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_JankType::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PredictionType = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + FrameTimelineEvent_PredictionType, + FrameTimelineEvent_ActualDisplayFrameStart>; + + static constexpr FieldMetadata_PredictionType kPredictionType{}; + void set_prediction_type(FrameTimelineEvent_PredictionType value) { + static constexpr uint32_t field_id = FieldMetadata_PredictionType::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_JankSeverityType = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + FrameTimelineEvent_JankSeverityType, + FrameTimelineEvent_ActualDisplayFrameStart>; + + static constexpr FieldMetadata_JankSeverityType kJankSeverityType{}; + void set_jank_severity_type(FrameTimelineEvent_JankSeverityType value) { + static constexpr uint32_t field_id = FieldMetadata_JankSeverityType::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } +}; + +class FrameTimelineEvent_ExpectedDisplayFrameStart_Decoder : public ::protozero::TypedProtoDecoder { + public: + FrameTimelineEvent_ExpectedDisplayFrameStart_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit FrameTimelineEvent_ExpectedDisplayFrameStart_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit FrameTimelineEvent_ExpectedDisplayFrameStart_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_cookie() const { return at<1>().valid(); } + int64_t cookie() const { return at<1>().as_int64(); } + bool has_token() const { return at<2>().valid(); } + int64_t token() const { return at<2>().as_int64(); } + bool has_pid() const { return at<3>().valid(); } + int32_t pid() const { return at<3>().as_int32(); } +}; + +class FrameTimelineEvent_ExpectedDisplayFrameStart : public ::protozero::Message { + public: + using Decoder = FrameTimelineEvent_ExpectedDisplayFrameStart_Decoder; + enum : int32_t { + kCookieFieldNumber = 1, + kTokenFieldNumber = 2, + kPidFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.FrameTimelineEvent.ExpectedDisplayFrameStart"; } + + + using FieldMetadata_Cookie = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + FrameTimelineEvent_ExpectedDisplayFrameStart>; + + static constexpr FieldMetadata_Cookie kCookie{}; + void set_cookie(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Cookie::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Token = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + FrameTimelineEvent_ExpectedDisplayFrameStart>; + + static constexpr FieldMetadata_Token kToken{}; + void set_token(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Token::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pid = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + FrameTimelineEvent_ExpectedDisplayFrameStart>; + + static constexpr FieldMetadata_Pid kPid{}; + void set_pid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class FrameTimelineEvent_ActualSurfaceFrameStart_Decoder : public ::protozero::TypedProtoDecoder { + public: + FrameTimelineEvent_ActualSurfaceFrameStart_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit FrameTimelineEvent_ActualSurfaceFrameStart_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit FrameTimelineEvent_ActualSurfaceFrameStart_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_cookie() const { return at<1>().valid(); } + int64_t cookie() const { return at<1>().as_int64(); } + bool has_token() const { return at<2>().valid(); } + int64_t token() const { return at<2>().as_int64(); } + bool has_display_frame_token() const { return at<3>().valid(); } + int64_t display_frame_token() const { return at<3>().as_int64(); } + bool has_pid() const { return at<4>().valid(); } + int32_t pid() const { return at<4>().as_int32(); } + bool has_layer_name() const { return at<5>().valid(); } + ::protozero::ConstChars layer_name() const { return at<5>().as_string(); } + bool has_present_type() const { return at<6>().valid(); } + int32_t present_type() const { return at<6>().as_int32(); } + bool has_on_time_finish() const { return at<7>().valid(); } + bool on_time_finish() const { return at<7>().as_bool(); } + bool has_gpu_composition() const { return at<8>().valid(); } + bool gpu_composition() const { return at<8>().as_bool(); } + bool has_jank_type() const { return at<9>().valid(); } + int32_t jank_type() const { return at<9>().as_int32(); } + bool has_prediction_type() const { return at<10>().valid(); } + int32_t prediction_type() const { return at<10>().as_int32(); } + bool has_is_buffer() const { return at<11>().valid(); } + bool is_buffer() const { return at<11>().as_bool(); } + bool has_jank_severity_type() const { return at<12>().valid(); } + int32_t jank_severity_type() const { return at<12>().as_int32(); } +}; + +class FrameTimelineEvent_ActualSurfaceFrameStart : public ::protozero::Message { + public: + using Decoder = FrameTimelineEvent_ActualSurfaceFrameStart_Decoder; + enum : int32_t { + kCookieFieldNumber = 1, + kTokenFieldNumber = 2, + kDisplayFrameTokenFieldNumber = 3, + kPidFieldNumber = 4, + kLayerNameFieldNumber = 5, + kPresentTypeFieldNumber = 6, + kOnTimeFinishFieldNumber = 7, + kGpuCompositionFieldNumber = 8, + kJankTypeFieldNumber = 9, + kPredictionTypeFieldNumber = 10, + kIsBufferFieldNumber = 11, + kJankSeverityTypeFieldNumber = 12, + }; + static constexpr const char* GetName() { return ".perfetto.protos.FrameTimelineEvent.ActualSurfaceFrameStart"; } + + + using FieldMetadata_Cookie = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + FrameTimelineEvent_ActualSurfaceFrameStart>; + + static constexpr FieldMetadata_Cookie kCookie{}; + void set_cookie(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Cookie::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Token = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + FrameTimelineEvent_ActualSurfaceFrameStart>; + + static constexpr FieldMetadata_Token kToken{}; + void set_token(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Token::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DisplayFrameToken = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + FrameTimelineEvent_ActualSurfaceFrameStart>; + + static constexpr FieldMetadata_DisplayFrameToken kDisplayFrameToken{}; + void set_display_frame_token(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_DisplayFrameToken::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pid = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + FrameTimelineEvent_ActualSurfaceFrameStart>; + + static constexpr FieldMetadata_Pid kPid{}; + void set_pid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_LayerName = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + FrameTimelineEvent_ActualSurfaceFrameStart>; + + static constexpr FieldMetadata_LayerName kLayerName{}; + void set_layer_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_LayerName::kFieldId, data, size); + } + void set_layer_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_LayerName::kFieldId, chars.data, chars.size); + } + void set_layer_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_LayerName::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PresentType = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + FrameTimelineEvent_PresentType, + FrameTimelineEvent_ActualSurfaceFrameStart>; + + static constexpr FieldMetadata_PresentType kPresentType{}; + void set_present_type(FrameTimelineEvent_PresentType value) { + static constexpr uint32_t field_id = FieldMetadata_PresentType::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_OnTimeFinish = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + FrameTimelineEvent_ActualSurfaceFrameStart>; + + static constexpr FieldMetadata_OnTimeFinish kOnTimeFinish{}; + void set_on_time_finish(bool value) { + static constexpr uint32_t field_id = FieldMetadata_OnTimeFinish::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_GpuComposition = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + FrameTimelineEvent_ActualSurfaceFrameStart>; + + static constexpr FieldMetadata_GpuComposition kGpuComposition{}; + void set_gpu_composition(bool value) { + static constexpr uint32_t field_id = FieldMetadata_GpuComposition::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_JankType = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + FrameTimelineEvent_ActualSurfaceFrameStart>; + + static constexpr FieldMetadata_JankType kJankType{}; + void set_jank_type(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_JankType::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PredictionType = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + FrameTimelineEvent_PredictionType, + FrameTimelineEvent_ActualSurfaceFrameStart>; + + static constexpr FieldMetadata_PredictionType kPredictionType{}; + void set_prediction_type(FrameTimelineEvent_PredictionType value) { + static constexpr uint32_t field_id = FieldMetadata_PredictionType::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_IsBuffer = + ::protozero::proto_utils::FieldMetadata< + 11, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + FrameTimelineEvent_ActualSurfaceFrameStart>; + + static constexpr FieldMetadata_IsBuffer kIsBuffer{}; + void set_is_buffer(bool value) { + static constexpr uint32_t field_id = FieldMetadata_IsBuffer::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_JankSeverityType = + ::protozero::proto_utils::FieldMetadata< + 12, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + FrameTimelineEvent_JankSeverityType, + FrameTimelineEvent_ActualSurfaceFrameStart>; + + static constexpr FieldMetadata_JankSeverityType kJankSeverityType{}; + void set_jank_severity_type(FrameTimelineEvent_JankSeverityType value) { + static constexpr uint32_t field_id = FieldMetadata_JankSeverityType::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } +}; + +class FrameTimelineEvent_ExpectedSurfaceFrameStart_Decoder : public ::protozero::TypedProtoDecoder { + public: + FrameTimelineEvent_ExpectedSurfaceFrameStart_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit FrameTimelineEvent_ExpectedSurfaceFrameStart_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit FrameTimelineEvent_ExpectedSurfaceFrameStart_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_cookie() const { return at<1>().valid(); } + int64_t cookie() const { return at<1>().as_int64(); } + bool has_token() const { return at<2>().valid(); } + int64_t token() const { return at<2>().as_int64(); } + bool has_display_frame_token() const { return at<3>().valid(); } + int64_t display_frame_token() const { return at<3>().as_int64(); } + bool has_pid() const { return at<4>().valid(); } + int32_t pid() const { return at<4>().as_int32(); } + bool has_layer_name() const { return at<5>().valid(); } + ::protozero::ConstChars layer_name() const { return at<5>().as_string(); } +}; + +class FrameTimelineEvent_ExpectedSurfaceFrameStart : public ::protozero::Message { + public: + using Decoder = FrameTimelineEvent_ExpectedSurfaceFrameStart_Decoder; + enum : int32_t { + kCookieFieldNumber = 1, + kTokenFieldNumber = 2, + kDisplayFrameTokenFieldNumber = 3, + kPidFieldNumber = 4, + kLayerNameFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.FrameTimelineEvent.ExpectedSurfaceFrameStart"; } + + + using FieldMetadata_Cookie = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + FrameTimelineEvent_ExpectedSurfaceFrameStart>; + + static constexpr FieldMetadata_Cookie kCookie{}; + void set_cookie(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Cookie::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Token = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + FrameTimelineEvent_ExpectedSurfaceFrameStart>; + + static constexpr FieldMetadata_Token kToken{}; + void set_token(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Token::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DisplayFrameToken = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + FrameTimelineEvent_ExpectedSurfaceFrameStart>; + + static constexpr FieldMetadata_DisplayFrameToken kDisplayFrameToken{}; + void set_display_frame_token(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_DisplayFrameToken::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pid = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + FrameTimelineEvent_ExpectedSurfaceFrameStart>; + + static constexpr FieldMetadata_Pid kPid{}; + void set_pid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_LayerName = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + FrameTimelineEvent_ExpectedSurfaceFrameStart>; + + static constexpr FieldMetadata_LayerName kLayerName{}; + void set_layer_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_LayerName::kFieldId, data, size); + } + void set_layer_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_LayerName::kFieldId, chars.data, chars.size); + } + void set_layer_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_LayerName::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class AndroidCameraSessionStats_Decoder : public ::protozero::TypedProtoDecoder { + public: + AndroidCameraSessionStats_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit AndroidCameraSessionStats_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit AndroidCameraSessionStats_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_session_id() const { return at<1>().valid(); } + uint64_t session_id() const { return at<1>().as_uint64(); } + bool has_graph() const { return at<2>().valid(); } + ::protozero::ConstBytes graph() const { return at<2>().as_bytes(); } +}; + +class AndroidCameraSessionStats : public ::protozero::Message { + public: + using Decoder = AndroidCameraSessionStats_Decoder; + enum : int32_t { + kSessionIdFieldNumber = 1, + kGraphFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.AndroidCameraSessionStats"; } + + using CameraGraph = ::perfetto::protos::pbzero::AndroidCameraSessionStats_CameraGraph; + + using FieldMetadata_SessionId = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + AndroidCameraSessionStats>; + + static constexpr FieldMetadata_SessionId kSessionId{}; + void set_session_id(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_SessionId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Graph = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + AndroidCameraSessionStats_CameraGraph, + AndroidCameraSessionStats>; + + static constexpr FieldMetadata_Graph kGraph{}; + template T* set_graph() { + return BeginNestedMessage(2); + } + +}; + +class AndroidCameraSessionStats_CameraGraph_Decoder : public ::protozero::TypedProtoDecoder { + public: + AndroidCameraSessionStats_CameraGraph_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit AndroidCameraSessionStats_CameraGraph_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit AndroidCameraSessionStats_CameraGraph_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_nodes() const { return at<1>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> nodes() const { return GetRepeated<::protozero::ConstBytes>(1); } + bool has_edges() const { return at<2>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> edges() const { return GetRepeated<::protozero::ConstBytes>(2); } +}; + +class AndroidCameraSessionStats_CameraGraph : public ::protozero::Message { + public: + using Decoder = AndroidCameraSessionStats_CameraGraph_Decoder; + enum : int32_t { + kNodesFieldNumber = 1, + kEdgesFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.AndroidCameraSessionStats.CameraGraph"; } + + using CameraNode = ::perfetto::protos::pbzero::AndroidCameraSessionStats_CameraGraph_CameraNode; + using CameraEdge = ::perfetto::protos::pbzero::AndroidCameraSessionStats_CameraGraph_CameraEdge; + + using FieldMetadata_Nodes = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + AndroidCameraSessionStats_CameraGraph_CameraNode, + AndroidCameraSessionStats_CameraGraph>; + + static constexpr FieldMetadata_Nodes kNodes{}; + template T* add_nodes() { + return BeginNestedMessage(1); + } + + + using FieldMetadata_Edges = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + AndroidCameraSessionStats_CameraGraph_CameraEdge, + AndroidCameraSessionStats_CameraGraph>; + + static constexpr FieldMetadata_Edges kEdges{}; + template T* add_edges() { + return BeginNestedMessage(2); + } + +}; + +class AndroidCameraSessionStats_CameraGraph_CameraEdge_Decoder : public ::protozero::TypedProtoDecoder { + public: + AndroidCameraSessionStats_CameraGraph_CameraEdge_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit AndroidCameraSessionStats_CameraGraph_CameraEdge_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit AndroidCameraSessionStats_CameraGraph_CameraEdge_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_output_node_id() const { return at<1>().valid(); } + int64_t output_node_id() const { return at<1>().as_int64(); } + bool has_output_id() const { return at<2>().valid(); } + int64_t output_id() const { return at<2>().as_int64(); } + bool has_input_node_id() const { return at<3>().valid(); } + int64_t input_node_id() const { return at<3>().as_int64(); } + bool has_input_id() const { return at<4>().valid(); } + int64_t input_id() const { return at<4>().as_int64(); } + bool has_vendor_data_version() const { return at<5>().valid(); } + int32_t vendor_data_version() const { return at<5>().as_int32(); } + bool has_vendor_data() const { return at<6>().valid(); } + ::protozero::ConstBytes vendor_data() const { return at<6>().as_bytes(); } +}; + +class AndroidCameraSessionStats_CameraGraph_CameraEdge : public ::protozero::Message { + public: + using Decoder = AndroidCameraSessionStats_CameraGraph_CameraEdge_Decoder; + enum : int32_t { + kOutputNodeIdFieldNumber = 1, + kOutputIdFieldNumber = 2, + kInputNodeIdFieldNumber = 3, + kInputIdFieldNumber = 4, + kVendorDataVersionFieldNumber = 5, + kVendorDataFieldNumber = 6, + }; + static constexpr const char* GetName() { return ".perfetto.protos.AndroidCameraSessionStats.CameraGraph.CameraEdge"; } + + + using FieldMetadata_OutputNodeId = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + AndroidCameraSessionStats_CameraGraph_CameraEdge>; + + static constexpr FieldMetadata_OutputNodeId kOutputNodeId{}; + void set_output_node_id(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_OutputNodeId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_OutputId = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + AndroidCameraSessionStats_CameraGraph_CameraEdge>; + + static constexpr FieldMetadata_OutputId kOutputId{}; + void set_output_id(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_OutputId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_InputNodeId = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + AndroidCameraSessionStats_CameraGraph_CameraEdge>; + + static constexpr FieldMetadata_InputNodeId kInputNodeId{}; + void set_input_node_id(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_InputNodeId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_InputId = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + AndroidCameraSessionStats_CameraGraph_CameraEdge>; + + static constexpr FieldMetadata_InputId kInputId{}; + void set_input_id(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_InputId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_VendorDataVersion = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + AndroidCameraSessionStats_CameraGraph_CameraEdge>; + + static constexpr FieldMetadata_VendorDataVersion kVendorDataVersion{}; + void set_vendor_data_version(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_VendorDataVersion::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_VendorData = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBytes, + std::string, + AndroidCameraSessionStats_CameraGraph_CameraEdge>; + + static constexpr FieldMetadata_VendorData kVendorData{}; + void set_vendor_data(const uint8_t* data, size_t size) { + AppendBytes(FieldMetadata_VendorData::kFieldId, data, size); + } + void set_vendor_data(::protozero::ConstBytes bytes) { + AppendBytes(FieldMetadata_VendorData::kFieldId, bytes.data, bytes.size); + } + void set_vendor_data(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_VendorData::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBytes> + ::Append(*this, field_id, value); + } +}; + +class AndroidCameraSessionStats_CameraGraph_CameraNode_Decoder : public ::protozero::TypedProtoDecoder { + public: + AndroidCameraSessionStats_CameraGraph_CameraNode_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit AndroidCameraSessionStats_CameraGraph_CameraNode_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit AndroidCameraSessionStats_CameraGraph_CameraNode_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_node_id() const { return at<1>().valid(); } + int64_t node_id() const { return at<1>().as_int64(); } + bool has_input_ids() const { return at<2>().valid(); } + ::protozero::RepeatedFieldIterator input_ids() const { return GetRepeated(2); } + bool has_output_ids() const { return at<3>().valid(); } + ::protozero::RepeatedFieldIterator output_ids() const { return GetRepeated(3); } + bool has_vendor_data_version() const { return at<4>().valid(); } + int32_t vendor_data_version() const { return at<4>().as_int32(); } + bool has_vendor_data() const { return at<5>().valid(); } + ::protozero::ConstBytes vendor_data() const { return at<5>().as_bytes(); } +}; + +class AndroidCameraSessionStats_CameraGraph_CameraNode : public ::protozero::Message { + public: + using Decoder = AndroidCameraSessionStats_CameraGraph_CameraNode_Decoder; + enum : int32_t { + kNodeIdFieldNumber = 1, + kInputIdsFieldNumber = 2, + kOutputIdsFieldNumber = 3, + kVendorDataVersionFieldNumber = 4, + kVendorDataFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.AndroidCameraSessionStats.CameraGraph.CameraNode"; } + + + using FieldMetadata_NodeId = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + AndroidCameraSessionStats_CameraGraph_CameraNode>; + + static constexpr FieldMetadata_NodeId kNodeId{}; + void set_node_id(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_NodeId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_InputIds = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + AndroidCameraSessionStats_CameraGraph_CameraNode>; + + static constexpr FieldMetadata_InputIds kInputIds{}; + void add_input_ids(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_InputIds::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_OutputIds = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + AndroidCameraSessionStats_CameraGraph_CameraNode>; + + static constexpr FieldMetadata_OutputIds kOutputIds{}; + void add_output_ids(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_OutputIds::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_VendorDataVersion = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + AndroidCameraSessionStats_CameraGraph_CameraNode>; + + static constexpr FieldMetadata_VendorDataVersion kVendorDataVersion{}; + void set_vendor_data_version(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_VendorDataVersion::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_VendorData = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBytes, + std::string, + AndroidCameraSessionStats_CameraGraph_CameraNode>; + + static constexpr FieldMetadata_VendorData kVendorData{}; + void set_vendor_data(const uint8_t* data, size_t size) { + AppendBytes(FieldMetadata_VendorData::kFieldId, data, size); + } + void set_vendor_data(::protozero::ConstBytes bytes) { + AppendBytes(FieldMetadata_VendorData::kFieldId, bytes.data, bytes.size); + } + void set_vendor_data(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_VendorData::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBytes> + ::Append(*this, field_id, value); + } +}; + +class AndroidCameraFrameEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + AndroidCameraFrameEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit AndroidCameraFrameEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit AndroidCameraFrameEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_session_id() const { return at<1>().valid(); } + uint64_t session_id() const { return at<1>().as_uint64(); } + bool has_camera_id() const { return at<2>().valid(); } + uint32_t camera_id() const { return at<2>().as_uint32(); } + bool has_frame_number() const { return at<3>().valid(); } + int64_t frame_number() const { return at<3>().as_int64(); } + bool has_request_id() const { return at<4>().valid(); } + int64_t request_id() const { return at<4>().as_int64(); } + bool has_request_received_ns() const { return at<5>().valid(); } + int64_t request_received_ns() const { return at<5>().as_int64(); } + bool has_request_processing_started_ns() const { return at<6>().valid(); } + int64_t request_processing_started_ns() const { return at<6>().as_int64(); } + bool has_start_of_exposure_ns() const { return at<7>().valid(); } + int64_t start_of_exposure_ns() const { return at<7>().as_int64(); } + bool has_start_of_frame_ns() const { return at<8>().valid(); } + int64_t start_of_frame_ns() const { return at<8>().as_int64(); } + bool has_responses_all_sent_ns() const { return at<9>().valid(); } + int64_t responses_all_sent_ns() const { return at<9>().as_int64(); } + bool has_capture_result_status() const { return at<10>().valid(); } + int32_t capture_result_status() const { return at<10>().as_int32(); } + bool has_skipped_sensor_frames() const { return at<11>().valid(); } + int32_t skipped_sensor_frames() const { return at<11>().as_int32(); } + bool has_capture_intent() const { return at<12>().valid(); } + int32_t capture_intent() const { return at<12>().as_int32(); } + bool has_num_streams() const { return at<13>().valid(); } + int32_t num_streams() const { return at<13>().as_int32(); } + bool has_node_processing_details() const { return at<14>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> node_processing_details() const { return GetRepeated<::protozero::ConstBytes>(14); } + bool has_vendor_data_version() const { return at<15>().valid(); } + int32_t vendor_data_version() const { return at<15>().as_int32(); } + bool has_vendor_data() const { return at<16>().valid(); } + ::protozero::ConstBytes vendor_data() const { return at<16>().as_bytes(); } +}; + +class AndroidCameraFrameEvent : public ::protozero::Message { + public: + using Decoder = AndroidCameraFrameEvent_Decoder; + enum : int32_t { + kSessionIdFieldNumber = 1, + kCameraIdFieldNumber = 2, + kFrameNumberFieldNumber = 3, + kRequestIdFieldNumber = 4, + kRequestReceivedNsFieldNumber = 5, + kRequestProcessingStartedNsFieldNumber = 6, + kStartOfExposureNsFieldNumber = 7, + kStartOfFrameNsFieldNumber = 8, + kResponsesAllSentNsFieldNumber = 9, + kCaptureResultStatusFieldNumber = 10, + kSkippedSensorFramesFieldNumber = 11, + kCaptureIntentFieldNumber = 12, + kNumStreamsFieldNumber = 13, + kNodeProcessingDetailsFieldNumber = 14, + kVendorDataVersionFieldNumber = 15, + kVendorDataFieldNumber = 16, + }; + static constexpr const char* GetName() { return ".perfetto.protos.AndroidCameraFrameEvent"; } + + using CameraNodeProcessingDetails = ::perfetto::protos::pbzero::AndroidCameraFrameEvent_CameraNodeProcessingDetails; + + using CaptureResultStatus = ::perfetto::protos::pbzero::AndroidCameraFrameEvent_CaptureResultStatus; + static inline const char* CaptureResultStatus_Name(CaptureResultStatus value) { + return ::perfetto::protos::pbzero::AndroidCameraFrameEvent_CaptureResultStatus_Name(value); + } + static inline const CaptureResultStatus STATUS_UNSPECIFIED = CaptureResultStatus::STATUS_UNSPECIFIED; + static inline const CaptureResultStatus STATUS_OK = CaptureResultStatus::STATUS_OK; + static inline const CaptureResultStatus STATUS_EARLY_METADATA_ERROR = CaptureResultStatus::STATUS_EARLY_METADATA_ERROR; + static inline const CaptureResultStatus STATUS_FINAL_METADATA_ERROR = CaptureResultStatus::STATUS_FINAL_METADATA_ERROR; + static inline const CaptureResultStatus STATUS_BUFFER_ERROR = CaptureResultStatus::STATUS_BUFFER_ERROR; + static inline const CaptureResultStatus STATUS_FLUSH_ERROR = CaptureResultStatus::STATUS_FLUSH_ERROR; + + using FieldMetadata_SessionId = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + AndroidCameraFrameEvent>; + + static constexpr FieldMetadata_SessionId kSessionId{}; + void set_session_id(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_SessionId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CameraId = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + AndroidCameraFrameEvent>; + + static constexpr FieldMetadata_CameraId kCameraId{}; + void set_camera_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_CameraId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FrameNumber = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + AndroidCameraFrameEvent>; + + static constexpr FieldMetadata_FrameNumber kFrameNumber{}; + void set_frame_number(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_FrameNumber::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_RequestId = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + AndroidCameraFrameEvent>; + + static constexpr FieldMetadata_RequestId kRequestId{}; + void set_request_id(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_RequestId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_RequestReceivedNs = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + AndroidCameraFrameEvent>; + + static constexpr FieldMetadata_RequestReceivedNs kRequestReceivedNs{}; + void set_request_received_ns(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_RequestReceivedNs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_RequestProcessingStartedNs = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + AndroidCameraFrameEvent>; + + static constexpr FieldMetadata_RequestProcessingStartedNs kRequestProcessingStartedNs{}; + void set_request_processing_started_ns(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_RequestProcessingStartedNs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_StartOfExposureNs = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + AndroidCameraFrameEvent>; + + static constexpr FieldMetadata_StartOfExposureNs kStartOfExposureNs{}; + void set_start_of_exposure_ns(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_StartOfExposureNs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_StartOfFrameNs = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + AndroidCameraFrameEvent>; + + static constexpr FieldMetadata_StartOfFrameNs kStartOfFrameNs{}; + void set_start_of_frame_ns(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_StartOfFrameNs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ResponsesAllSentNs = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + AndroidCameraFrameEvent>; + + static constexpr FieldMetadata_ResponsesAllSentNs kResponsesAllSentNs{}; + void set_responses_all_sent_ns(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_ResponsesAllSentNs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CaptureResultStatus = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + AndroidCameraFrameEvent_CaptureResultStatus, + AndroidCameraFrameEvent>; + + static constexpr FieldMetadata_CaptureResultStatus kCaptureResultStatus{}; + void set_capture_result_status(AndroidCameraFrameEvent_CaptureResultStatus value) { + static constexpr uint32_t field_id = FieldMetadata_CaptureResultStatus::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SkippedSensorFrames = + ::protozero::proto_utils::FieldMetadata< + 11, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + AndroidCameraFrameEvent>; + + static constexpr FieldMetadata_SkippedSensorFrames kSkippedSensorFrames{}; + void set_skipped_sensor_frames(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_SkippedSensorFrames::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CaptureIntent = + ::protozero::proto_utils::FieldMetadata< + 12, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + AndroidCameraFrameEvent>; + + static constexpr FieldMetadata_CaptureIntent kCaptureIntent{}; + void set_capture_intent(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_CaptureIntent::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NumStreams = + ::protozero::proto_utils::FieldMetadata< + 13, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + AndroidCameraFrameEvent>; + + static constexpr FieldMetadata_NumStreams kNumStreams{}; + void set_num_streams(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_NumStreams::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NodeProcessingDetails = + ::protozero::proto_utils::FieldMetadata< + 14, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + AndroidCameraFrameEvent_CameraNodeProcessingDetails, + AndroidCameraFrameEvent>; + + static constexpr FieldMetadata_NodeProcessingDetails kNodeProcessingDetails{}; + template T* add_node_processing_details() { + return BeginNestedMessage(14); + } + + + using FieldMetadata_VendorDataVersion = + ::protozero::proto_utils::FieldMetadata< + 15, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + AndroidCameraFrameEvent>; + + static constexpr FieldMetadata_VendorDataVersion kVendorDataVersion{}; + void set_vendor_data_version(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_VendorDataVersion::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_VendorData = + ::protozero::proto_utils::FieldMetadata< + 16, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBytes, + std::string, + AndroidCameraFrameEvent>; + + static constexpr FieldMetadata_VendorData kVendorData{}; + void set_vendor_data(const uint8_t* data, size_t size) { + AppendBytes(FieldMetadata_VendorData::kFieldId, data, size); + } + void set_vendor_data(::protozero::ConstBytes bytes) { + AppendBytes(FieldMetadata_VendorData::kFieldId, bytes.data, bytes.size); + } + void set_vendor_data(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_VendorData::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBytes> + ::Append(*this, field_id, value); + } +}; + +class AndroidCameraFrameEvent_CameraNodeProcessingDetails_Decoder : public ::protozero::TypedProtoDecoder { + public: + AndroidCameraFrameEvent_CameraNodeProcessingDetails_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit AndroidCameraFrameEvent_CameraNodeProcessingDetails_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit AndroidCameraFrameEvent_CameraNodeProcessingDetails_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_node_id() const { return at<1>().valid(); } + int64_t node_id() const { return at<1>().as_int64(); } + bool has_start_processing_ns() const { return at<2>().valid(); } + int64_t start_processing_ns() const { return at<2>().as_int64(); } + bool has_end_processing_ns() const { return at<3>().valid(); } + int64_t end_processing_ns() const { return at<3>().as_int64(); } + bool has_scheduling_latency_ns() const { return at<4>().valid(); } + int64_t scheduling_latency_ns() const { return at<4>().as_int64(); } +}; + +class AndroidCameraFrameEvent_CameraNodeProcessingDetails : public ::protozero::Message { + public: + using Decoder = AndroidCameraFrameEvent_CameraNodeProcessingDetails_Decoder; + enum : int32_t { + kNodeIdFieldNumber = 1, + kStartProcessingNsFieldNumber = 2, + kEndProcessingNsFieldNumber = 3, + kSchedulingLatencyNsFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.AndroidCameraFrameEvent.CameraNodeProcessingDetails"; } + + + using FieldMetadata_NodeId = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + AndroidCameraFrameEvent_CameraNodeProcessingDetails>; + + static constexpr FieldMetadata_NodeId kNodeId{}; + void set_node_id(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_NodeId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_StartProcessingNs = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + AndroidCameraFrameEvent_CameraNodeProcessingDetails>; + + static constexpr FieldMetadata_StartProcessingNs kStartProcessingNs{}; + void set_start_processing_ns(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_StartProcessingNs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_EndProcessingNs = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + AndroidCameraFrameEvent_CameraNodeProcessingDetails>; + + static constexpr FieldMetadata_EndProcessingNs kEndProcessingNs{}; + void set_end_processing_ns(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_EndProcessingNs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SchedulingLatencyNs = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + AndroidCameraFrameEvent_CameraNodeProcessingDetails>; + + static constexpr FieldMetadata_SchedulingLatencyNs kSchedulingLatencyNs{}; + void set_scheduling_latency_ns(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_SchedulingLatencyNs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } +}; + +class AndroidSystemProperty_Decoder : public ::protozero::TypedProtoDecoder { + public: + AndroidSystemProperty_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit AndroidSystemProperty_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit AndroidSystemProperty_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_values() const { return at<1>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> values() const { return GetRepeated<::protozero::ConstBytes>(1); } +}; + +class AndroidSystemProperty : public ::protozero::Message { + public: + using Decoder = AndroidSystemProperty_Decoder; + enum : int32_t { + kValuesFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.AndroidSystemProperty"; } + + using PropertyValue = ::perfetto::protos::pbzero::AndroidSystemProperty_PropertyValue; + + using FieldMetadata_Values = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + AndroidSystemProperty_PropertyValue, + AndroidSystemProperty>; + + static constexpr FieldMetadata_Values kValues{}; + template T* add_values() { + return BeginNestedMessage(1); + } + +}; + +class AndroidSystemProperty_PropertyValue_Decoder : public ::protozero::TypedProtoDecoder { + public: + AndroidSystemProperty_PropertyValue_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit AndroidSystemProperty_PropertyValue_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit AndroidSystemProperty_PropertyValue_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_name() const { return at<1>().valid(); } + ::protozero::ConstChars name() const { return at<1>().as_string(); } + bool has_value() const { return at<2>().valid(); } + ::protozero::ConstChars value() const { return at<2>().as_string(); } +}; + +class AndroidSystemProperty_PropertyValue : public ::protozero::Message { + public: + using Decoder = AndroidSystemProperty_PropertyValue_Decoder; + enum : int32_t { + kNameFieldNumber = 1, + kValueFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.AndroidSystemProperty.PropertyValue"; } + + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + AndroidSystemProperty_PropertyValue>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Value = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + AndroidSystemProperty_PropertyValue>; + + static constexpr FieldMetadata_Value kValue{}; + void set_value(const char* data, size_t size) { + AppendBytes(FieldMetadata_Value::kFieldId, data, size); + } + void set_value(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Value::kFieldId, chars.data, chars.size); + } + void set_value(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class AndroidLogPacket_Decoder : public ::protozero::TypedProtoDecoder { + public: + AndroidLogPacket_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit AndroidLogPacket_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit AndroidLogPacket_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_events() const { return at<1>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> events() const { return GetRepeated<::protozero::ConstBytes>(1); } + bool has_stats() const { return at<2>().valid(); } + ::protozero::ConstBytes stats() const { return at<2>().as_bytes(); } +}; + +class AndroidLogPacket : public ::protozero::Message { + public: + using Decoder = AndroidLogPacket_Decoder; + enum : int32_t { + kEventsFieldNumber = 1, + kStatsFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.AndroidLogPacket"; } + + using LogEvent = ::perfetto::protos::pbzero::AndroidLogPacket_LogEvent; + using Stats = ::perfetto::protos::pbzero::AndroidLogPacket_Stats; + + using FieldMetadata_Events = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + AndroidLogPacket_LogEvent, + AndroidLogPacket>; + + static constexpr FieldMetadata_Events kEvents{}; + template T* add_events() { + return BeginNestedMessage(1); + } + + + using FieldMetadata_Stats = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + AndroidLogPacket_Stats, + AndroidLogPacket>; + + static constexpr FieldMetadata_Stats kStats{}; + template T* set_stats() { + return BeginNestedMessage(2); + } + +}; + +class AndroidLogPacket_Stats_Decoder : public ::protozero::TypedProtoDecoder { + public: + AndroidLogPacket_Stats_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit AndroidLogPacket_Stats_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit AndroidLogPacket_Stats_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_num_total() const { return at<1>().valid(); } + uint64_t num_total() const { return at<1>().as_uint64(); } + bool has_num_failed() const { return at<2>().valid(); } + uint64_t num_failed() const { return at<2>().as_uint64(); } + bool has_num_skipped() const { return at<3>().valid(); } + uint64_t num_skipped() const { return at<3>().as_uint64(); } +}; + +class AndroidLogPacket_Stats : public ::protozero::Message { + public: + using Decoder = AndroidLogPacket_Stats_Decoder; + enum : int32_t { + kNumTotalFieldNumber = 1, + kNumFailedFieldNumber = 2, + kNumSkippedFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.AndroidLogPacket.Stats"; } + + + using FieldMetadata_NumTotal = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + AndroidLogPacket_Stats>; + + static constexpr FieldMetadata_NumTotal kNumTotal{}; + void set_num_total(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_NumTotal::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NumFailed = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + AndroidLogPacket_Stats>; + + static constexpr FieldMetadata_NumFailed kNumFailed{}; + void set_num_failed(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_NumFailed::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NumSkipped = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + AndroidLogPacket_Stats>; + + static constexpr FieldMetadata_NumSkipped kNumSkipped{}; + void set_num_skipped(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_NumSkipped::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class AndroidLogPacket_LogEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + AndroidLogPacket_LogEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit AndroidLogPacket_LogEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit AndroidLogPacket_LogEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_log_id() const { return at<1>().valid(); } + int32_t log_id() const { return at<1>().as_int32(); } + bool has_pid() const { return at<2>().valid(); } + int32_t pid() const { return at<2>().as_int32(); } + bool has_tid() const { return at<3>().valid(); } + int32_t tid() const { return at<3>().as_int32(); } + bool has_uid() const { return at<4>().valid(); } + int32_t uid() const { return at<4>().as_int32(); } + bool has_timestamp() const { return at<5>().valid(); } + uint64_t timestamp() const { return at<5>().as_uint64(); } + bool has_tag() const { return at<6>().valid(); } + ::protozero::ConstChars tag() const { return at<6>().as_string(); } + bool has_prio() const { return at<7>().valid(); } + int32_t prio() const { return at<7>().as_int32(); } + bool has_message() const { return at<8>().valid(); } + ::protozero::ConstChars message() const { return at<8>().as_string(); } + bool has_args() const { return at<9>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> args() const { return GetRepeated<::protozero::ConstBytes>(9); } +}; + +class AndroidLogPacket_LogEvent : public ::protozero::Message { + public: + using Decoder = AndroidLogPacket_LogEvent_Decoder; + enum : int32_t { + kLogIdFieldNumber = 1, + kPidFieldNumber = 2, + kTidFieldNumber = 3, + kUidFieldNumber = 4, + kTimestampFieldNumber = 5, + kTagFieldNumber = 6, + kPrioFieldNumber = 7, + kMessageFieldNumber = 8, + kArgsFieldNumber = 9, + }; + static constexpr const char* GetName() { return ".perfetto.protos.AndroidLogPacket.LogEvent"; } + + using Arg = ::perfetto::protos::pbzero::AndroidLogPacket_LogEvent_Arg; + + using FieldMetadata_LogId = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + AndroidLogId, + AndroidLogPacket_LogEvent>; + + static constexpr FieldMetadata_LogId kLogId{}; + void set_log_id(AndroidLogId value) { + static constexpr uint32_t field_id = FieldMetadata_LogId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pid = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + AndroidLogPacket_LogEvent>; + + static constexpr FieldMetadata_Pid kPid{}; + void set_pid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Tid = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + AndroidLogPacket_LogEvent>; + + static constexpr FieldMetadata_Tid kTid{}; + void set_tid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Tid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Uid = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + AndroidLogPacket_LogEvent>; + + static constexpr FieldMetadata_Uid kUid{}; + void set_uid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Uid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Timestamp = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + AndroidLogPacket_LogEvent>; + + static constexpr FieldMetadata_Timestamp kTimestamp{}; + void set_timestamp(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Timestamp::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Tag = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + AndroidLogPacket_LogEvent>; + + static constexpr FieldMetadata_Tag kTag{}; + void set_tag(const char* data, size_t size) { + AppendBytes(FieldMetadata_Tag::kFieldId, data, size); + } + void set_tag(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Tag::kFieldId, chars.data, chars.size); + } + void set_tag(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Tag::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Prio = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + AndroidLogPriority, + AndroidLogPacket_LogEvent>; + + static constexpr FieldMetadata_Prio kPrio{}; + void set_prio(AndroidLogPriority value) { + static constexpr uint32_t field_id = FieldMetadata_Prio::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Message = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + AndroidLogPacket_LogEvent>; + + static constexpr FieldMetadata_Message kMessage{}; + void set_message(const char* data, size_t size) { + AppendBytes(FieldMetadata_Message::kFieldId, data, size); + } + void set_message(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Message::kFieldId, chars.data, chars.size); + } + void set_message(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Message::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Args = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + AndroidLogPacket_LogEvent_Arg, + AndroidLogPacket_LogEvent>; + + static constexpr FieldMetadata_Args kArgs{}; + template T* add_args() { + return BeginNestedMessage(9); + } + +}; + +class AndroidLogPacket_LogEvent_Arg_Decoder : public ::protozero::TypedProtoDecoder { + public: + AndroidLogPacket_LogEvent_Arg_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit AndroidLogPacket_LogEvent_Arg_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit AndroidLogPacket_LogEvent_Arg_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_name() const { return at<1>().valid(); } + ::protozero::ConstChars name() const { return at<1>().as_string(); } + bool has_int_value() const { return at<2>().valid(); } + int64_t int_value() const { return at<2>().as_int64(); } + bool has_float_value() const { return at<3>().valid(); } + float float_value() const { return at<3>().as_float(); } + bool has_string_value() const { return at<4>().valid(); } + ::protozero::ConstChars string_value() const { return at<4>().as_string(); } +}; + +class AndroidLogPacket_LogEvent_Arg : public ::protozero::Message { + public: + using Decoder = AndroidLogPacket_LogEvent_Arg_Decoder; + enum : int32_t { + kNameFieldNumber = 1, + kIntValueFieldNumber = 2, + kFloatValueFieldNumber = 3, + kStringValueFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.AndroidLogPacket.LogEvent.Arg"; } + + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + AndroidLogPacket_LogEvent_Arg>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_IntValue = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + AndroidLogPacket_LogEvent_Arg>; + + static constexpr FieldMetadata_IntValue kIntValue{}; + void set_int_value(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_IntValue::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FloatValue = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + AndroidLogPacket_LogEvent_Arg>; + + static constexpr FieldMetadata_FloatValue kFloatValue{}; + void set_float_value(float value) { + static constexpr uint32_t field_id = FieldMetadata_FloatValue::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } + + using FieldMetadata_StringValue = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + AndroidLogPacket_LogEvent_Arg>; + + static constexpr FieldMetadata_StringValue kStringValue{}; + void set_string_value(const char* data, size_t size) { + AppendBytes(FieldMetadata_StringValue::kFieldId, data, size); + } + void set_string_value(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_StringValue::kFieldId, chars.data, chars.size); + } + void set_string_value(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_StringValue::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class AndroidInputEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + AndroidInputEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit AndroidInputEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit AndroidInputEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dispatcher_motion_event() const { return at<1>().valid(); } + ::protozero::ConstBytes dispatcher_motion_event() const { return at<1>().as_bytes(); } + bool has_dispatcher_motion_event_redacted() const { return at<2>().valid(); } + ::protozero::ConstBytes dispatcher_motion_event_redacted() const { return at<2>().as_bytes(); } + bool has_dispatcher_key_event() const { return at<3>().valid(); } + ::protozero::ConstBytes dispatcher_key_event() const { return at<3>().as_bytes(); } + bool has_dispatcher_key_event_redacted() const { return at<4>().valid(); } + ::protozero::ConstBytes dispatcher_key_event_redacted() const { return at<4>().as_bytes(); } + bool has_dispatcher_window_dispatch_event() const { return at<5>().valid(); } + ::protozero::ConstBytes dispatcher_window_dispatch_event() const { return at<5>().as_bytes(); } + bool has_dispatcher_window_dispatch_event_redacted() const { return at<6>().valid(); } + ::protozero::ConstBytes dispatcher_window_dispatch_event_redacted() const { return at<6>().as_bytes(); } +}; + +class AndroidInputEvent : public ::protozero::Message { + public: + using Decoder = AndroidInputEvent_Decoder; + enum : int32_t { + kDispatcherMotionEventFieldNumber = 1, + kDispatcherMotionEventRedactedFieldNumber = 2, + kDispatcherKeyEventFieldNumber = 3, + kDispatcherKeyEventRedactedFieldNumber = 4, + kDispatcherWindowDispatchEventFieldNumber = 5, + kDispatcherWindowDispatchEventRedactedFieldNumber = 6, + }; + static constexpr const char* GetName() { return ".perfetto.protos.AndroidInputEvent"; } + + + using FieldMetadata_DispatcherMotionEvent = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + AndroidMotionEvent, + AndroidInputEvent>; + + static constexpr FieldMetadata_DispatcherMotionEvent kDispatcherMotionEvent{}; + template T* set_dispatcher_motion_event() { + return BeginNestedMessage(1); + } + + + using FieldMetadata_DispatcherMotionEventRedacted = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + AndroidMotionEvent, + AndroidInputEvent>; + + static constexpr FieldMetadata_DispatcherMotionEventRedacted kDispatcherMotionEventRedacted{}; + template T* set_dispatcher_motion_event_redacted() { + return BeginNestedMessage(2); + } + + + using FieldMetadata_DispatcherKeyEvent = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + AndroidKeyEvent, + AndroidInputEvent>; + + static constexpr FieldMetadata_DispatcherKeyEvent kDispatcherKeyEvent{}; + template T* set_dispatcher_key_event() { + return BeginNestedMessage(3); + } + + + using FieldMetadata_DispatcherKeyEventRedacted = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + AndroidKeyEvent, + AndroidInputEvent>; + + static constexpr FieldMetadata_DispatcherKeyEventRedacted kDispatcherKeyEventRedacted{}; + template T* set_dispatcher_key_event_redacted() { + return BeginNestedMessage(4); + } + + + using FieldMetadata_DispatcherWindowDispatchEvent = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + AndroidWindowInputDispatchEvent, + AndroidInputEvent>; + + static constexpr FieldMetadata_DispatcherWindowDispatchEvent kDispatcherWindowDispatchEvent{}; + template T* set_dispatcher_window_dispatch_event() { + return BeginNestedMessage(5); + } + + + using FieldMetadata_DispatcherWindowDispatchEventRedacted = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + AndroidWindowInputDispatchEvent, + AndroidInputEvent>; + + static constexpr FieldMetadata_DispatcherWindowDispatchEventRedacted kDispatcherWindowDispatchEventRedacted{}; + template T* set_dispatcher_window_dispatch_event_redacted() { + return BeginNestedMessage(6); + } + +}; + +class AndroidWindowInputDispatchEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + AndroidWindowInputDispatchEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit AndroidWindowInputDispatchEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit AndroidWindowInputDispatchEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_event_id() const { return at<1>().valid(); } + uint32_t event_id() const { return at<1>().as_uint32(); } + bool has_vsync_id() const { return at<2>().valid(); } + int64_t vsync_id() const { return at<2>().as_int64(); } + bool has_window_id() const { return at<3>().valid(); } + int32_t window_id() const { return at<3>().as_int32(); } + bool has_dispatched_pointer() const { return at<4>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> dispatched_pointer() const { return GetRepeated<::protozero::ConstBytes>(4); } + bool has_resolved_flags() const { return at<5>().valid(); } + uint32_t resolved_flags() const { return at<5>().as_uint32(); } +}; + +class AndroidWindowInputDispatchEvent : public ::protozero::Message { + public: + using Decoder = AndroidWindowInputDispatchEvent_Decoder; + enum : int32_t { + kEventIdFieldNumber = 1, + kVsyncIdFieldNumber = 2, + kWindowIdFieldNumber = 3, + kDispatchedPointerFieldNumber = 4, + kResolvedFlagsFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.AndroidWindowInputDispatchEvent"; } + + using DispatchedPointer = ::perfetto::protos::pbzero::AndroidWindowInputDispatchEvent_DispatchedPointer; + + using FieldMetadata_EventId = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFixed32, + uint32_t, + AndroidWindowInputDispatchEvent>; + + static constexpr FieldMetadata_EventId kEventId{}; + void set_event_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_EventId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFixed32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_VsyncId = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + AndroidWindowInputDispatchEvent>; + + static constexpr FieldMetadata_VsyncId kVsyncId{}; + void set_vsync_id(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_VsyncId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_WindowId = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + AndroidWindowInputDispatchEvent>; + + static constexpr FieldMetadata_WindowId kWindowId{}; + void set_window_id(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_WindowId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DispatchedPointer = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + AndroidWindowInputDispatchEvent_DispatchedPointer, + AndroidWindowInputDispatchEvent>; + + static constexpr FieldMetadata_DispatchedPointer kDispatchedPointer{}; + template T* add_dispatched_pointer() { + return BeginNestedMessage(4); + } + + + using FieldMetadata_ResolvedFlags = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + AndroidWindowInputDispatchEvent>; + + static constexpr FieldMetadata_ResolvedFlags kResolvedFlags{}; + void set_resolved_flags(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ResolvedFlags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class AndroidWindowInputDispatchEvent_DispatchedPointer_Decoder : public ::protozero::TypedProtoDecoder { + public: + AndroidWindowInputDispatchEvent_DispatchedPointer_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit AndroidWindowInputDispatchEvent_DispatchedPointer_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit AndroidWindowInputDispatchEvent_DispatchedPointer_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_pointer_id() const { return at<1>().valid(); } + int32_t pointer_id() const { return at<1>().as_int32(); } + bool has_x_in_display() const { return at<2>().valid(); } + float x_in_display() const { return at<2>().as_float(); } + bool has_y_in_display() const { return at<3>().valid(); } + float y_in_display() const { return at<3>().as_float(); } + bool has_axis_value_in_window() const { return at<4>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> axis_value_in_window() const { return GetRepeated<::protozero::ConstBytes>(4); } +}; + +class AndroidWindowInputDispatchEvent_DispatchedPointer : public ::protozero::Message { + public: + using Decoder = AndroidWindowInputDispatchEvent_DispatchedPointer_Decoder; + enum : int32_t { + kPointerIdFieldNumber = 1, + kXInDisplayFieldNumber = 2, + kYInDisplayFieldNumber = 3, + kAxisValueInWindowFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.AndroidWindowInputDispatchEvent.DispatchedPointer"; } + + + using FieldMetadata_PointerId = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + AndroidWindowInputDispatchEvent_DispatchedPointer>; + + static constexpr FieldMetadata_PointerId kPointerId{}; + void set_pointer_id(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_PointerId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_XInDisplay = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + AndroidWindowInputDispatchEvent_DispatchedPointer>; + + static constexpr FieldMetadata_XInDisplay kXInDisplay{}; + void set_x_in_display(float value) { + static constexpr uint32_t field_id = FieldMetadata_XInDisplay::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } + + using FieldMetadata_YInDisplay = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + AndroidWindowInputDispatchEvent_DispatchedPointer>; + + static constexpr FieldMetadata_YInDisplay kYInDisplay{}; + void set_y_in_display(float value) { + static constexpr uint32_t field_id = FieldMetadata_YInDisplay::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } + + using FieldMetadata_AxisValueInWindow = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + AndroidMotionEvent_Pointer_AxisValue, + AndroidWindowInputDispatchEvent_DispatchedPointer>; + + static constexpr FieldMetadata_AxisValueInWindow kAxisValueInWindow{}; + template T* add_axis_value_in_window() { + return BeginNestedMessage(4); + } + +}; + +class AndroidKeyEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + AndroidKeyEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit AndroidKeyEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit AndroidKeyEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_event_id() const { return at<1>().valid(); } + uint32_t event_id() const { return at<1>().as_uint32(); } + bool has_event_time_nanos() const { return at<2>().valid(); } + int64_t event_time_nanos() const { return at<2>().as_int64(); } + bool has_down_time_nanos() const { return at<3>().valid(); } + int64_t down_time_nanos() const { return at<3>().as_int64(); } + bool has_source() const { return at<4>().valid(); } + uint32_t source() const { return at<4>().as_uint32(); } + bool has_action() const { return at<5>().valid(); } + int32_t action() const { return at<5>().as_int32(); } + bool has_device_id() const { return at<6>().valid(); } + int32_t device_id() const { return at<6>().as_int32(); } + bool has_display_id() const { return at<7>().valid(); } + int32_t display_id() const { return at<7>().as_sint32(); } + bool has_key_code() const { return at<8>().valid(); } + int32_t key_code() const { return at<8>().as_int32(); } + bool has_scan_code() const { return at<9>().valid(); } + uint32_t scan_code() const { return at<9>().as_uint32(); } + bool has_meta_state() const { return at<10>().valid(); } + uint32_t meta_state() const { return at<10>().as_uint32(); } + bool has_repeat_count() const { return at<11>().valid(); } + int32_t repeat_count() const { return at<11>().as_int32(); } + bool has_flags() const { return at<12>().valid(); } + uint32_t flags() const { return at<12>().as_uint32(); } + bool has_policy_flags() const { return at<13>().valid(); } + uint32_t policy_flags() const { return at<13>().as_uint32(); } +}; + +class AndroidKeyEvent : public ::protozero::Message { + public: + using Decoder = AndroidKeyEvent_Decoder; + enum : int32_t { + kEventIdFieldNumber = 1, + kEventTimeNanosFieldNumber = 2, + kDownTimeNanosFieldNumber = 3, + kSourceFieldNumber = 4, + kActionFieldNumber = 5, + kDeviceIdFieldNumber = 6, + kDisplayIdFieldNumber = 7, + kKeyCodeFieldNumber = 8, + kScanCodeFieldNumber = 9, + kMetaStateFieldNumber = 10, + kRepeatCountFieldNumber = 11, + kFlagsFieldNumber = 12, + kPolicyFlagsFieldNumber = 13, + }; + static constexpr const char* GetName() { return ".perfetto.protos.AndroidKeyEvent"; } + + + using FieldMetadata_EventId = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFixed32, + uint32_t, + AndroidKeyEvent>; + + static constexpr FieldMetadata_EventId kEventId{}; + void set_event_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_EventId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFixed32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_EventTimeNanos = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + AndroidKeyEvent>; + + static constexpr FieldMetadata_EventTimeNanos kEventTimeNanos{}; + void set_event_time_nanos(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_EventTimeNanos::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DownTimeNanos = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + AndroidKeyEvent>; + + static constexpr FieldMetadata_DownTimeNanos kDownTimeNanos{}; + void set_down_time_nanos(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_DownTimeNanos::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Source = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + AndroidKeyEvent>; + + static constexpr FieldMetadata_Source kSource{}; + void set_source(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Source::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Action = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + AndroidKeyEvent>; + + static constexpr FieldMetadata_Action kAction{}; + void set_action(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Action::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DeviceId = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + AndroidKeyEvent>; + + static constexpr FieldMetadata_DeviceId kDeviceId{}; + void set_device_id(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_DeviceId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DisplayId = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kSint32, + int32_t, + AndroidKeyEvent>; + + static constexpr FieldMetadata_DisplayId kDisplayId{}; + void set_display_id(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_DisplayId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kSint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_KeyCode = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + AndroidKeyEvent>; + + static constexpr FieldMetadata_KeyCode kKeyCode{}; + void set_key_code(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_KeyCode::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ScanCode = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + AndroidKeyEvent>; + + static constexpr FieldMetadata_ScanCode kScanCode{}; + void set_scan_code(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ScanCode::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_MetaState = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + AndroidKeyEvent>; + + static constexpr FieldMetadata_MetaState kMetaState{}; + void set_meta_state(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_MetaState::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_RepeatCount = + ::protozero::proto_utils::FieldMetadata< + 11, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + AndroidKeyEvent>; + + static constexpr FieldMetadata_RepeatCount kRepeatCount{}; + void set_repeat_count(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_RepeatCount::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Flags = + ::protozero::proto_utils::FieldMetadata< + 12, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + AndroidKeyEvent>; + + static constexpr FieldMetadata_Flags kFlags{}; + void set_flags(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PolicyFlags = + ::protozero::proto_utils::FieldMetadata< + 13, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + AndroidKeyEvent>; + + static constexpr FieldMetadata_PolicyFlags kPolicyFlags{}; + void set_policy_flags(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_PolicyFlags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class AndroidMotionEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + AndroidMotionEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit AndroidMotionEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit AndroidMotionEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_event_id() const { return at<1>().valid(); } + uint32_t event_id() const { return at<1>().as_uint32(); } + bool has_event_time_nanos() const { return at<2>().valid(); } + int64_t event_time_nanos() const { return at<2>().as_int64(); } + bool has_source() const { return at<3>().valid(); } + uint32_t source() const { return at<3>().as_uint32(); } + bool has_action() const { return at<4>().valid(); } + int32_t action() const { return at<4>().as_int32(); } + bool has_device_id() const { return at<5>().valid(); } + int32_t device_id() const { return at<5>().as_int32(); } + bool has_display_id() const { return at<6>().valid(); } + int32_t display_id() const { return at<6>().as_sint32(); } + bool has_classification() const { return at<7>().valid(); } + int32_t classification() const { return at<7>().as_int32(); } + bool has_flags() const { return at<8>().valid(); } + uint32_t flags() const { return at<8>().as_uint32(); } + bool has_pointer() const { return at<9>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> pointer() const { return GetRepeated<::protozero::ConstBytes>(9); } + bool has_original_event_id() const { return at<16>().valid(); } + ::protozero::PackedRepeatedFieldIterator<::protozero::proto_utils::ProtoWireType::kFixed32, uint32_t> original_event_id(bool* parse_error_ptr) const { return GetPackedRepeated<::protozero::proto_utils::ProtoWireType::kFixed32, uint32_t>(16, parse_error_ptr); } + bool has_down_time_nanos() const { return at<17>().valid(); } + int64_t down_time_nanos() const { return at<17>().as_int64(); } + bool has_cursor_position_x() const { return at<18>().valid(); } + float cursor_position_x() const { return at<18>().as_float(); } + bool has_cursor_position_y() const { return at<19>().valid(); } + float cursor_position_y() const { return at<19>().as_float(); } + bool has_action_button() const { return at<20>().valid(); } + int32_t action_button() const { return at<20>().as_int32(); } + bool has_button_state() const { return at<21>().valid(); } + uint32_t button_state() const { return at<21>().as_uint32(); } + bool has_meta_state() const { return at<22>().valid(); } + uint32_t meta_state() const { return at<22>().as_uint32(); } + bool has_policy_flags() const { return at<23>().valid(); } + uint32_t policy_flags() const { return at<23>().as_uint32(); } + bool has_precision_x() const { return at<24>().valid(); } + float precision_x() const { return at<24>().as_float(); } + bool has_precision_y() const { return at<25>().valid(); } + float precision_y() const { return at<25>().as_float(); } +}; + +class AndroidMotionEvent : public ::protozero::Message { + public: + using Decoder = AndroidMotionEvent_Decoder; + enum : int32_t { + kEventIdFieldNumber = 1, + kEventTimeNanosFieldNumber = 2, + kSourceFieldNumber = 3, + kActionFieldNumber = 4, + kDeviceIdFieldNumber = 5, + kDisplayIdFieldNumber = 6, + kClassificationFieldNumber = 7, + kFlagsFieldNumber = 8, + kPointerFieldNumber = 9, + kOriginalEventIdFieldNumber = 16, + kDownTimeNanosFieldNumber = 17, + kCursorPositionXFieldNumber = 18, + kCursorPositionYFieldNumber = 19, + kActionButtonFieldNumber = 20, + kButtonStateFieldNumber = 21, + kMetaStateFieldNumber = 22, + kPolicyFlagsFieldNumber = 23, + kPrecisionXFieldNumber = 24, + kPrecisionYFieldNumber = 25, + }; + static constexpr const char* GetName() { return ".perfetto.protos.AndroidMotionEvent"; } + + using Pointer = ::perfetto::protos::pbzero::AndroidMotionEvent_Pointer; + + using FieldMetadata_EventId = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFixed32, + uint32_t, + AndroidMotionEvent>; + + static constexpr FieldMetadata_EventId kEventId{}; + void set_event_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_EventId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFixed32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_EventTimeNanos = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + AndroidMotionEvent>; + + static constexpr FieldMetadata_EventTimeNanos kEventTimeNanos{}; + void set_event_time_nanos(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_EventTimeNanos::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Source = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + AndroidMotionEvent>; + + static constexpr FieldMetadata_Source kSource{}; + void set_source(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Source::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Action = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + AndroidMotionEvent>; + + static constexpr FieldMetadata_Action kAction{}; + void set_action(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Action::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DeviceId = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + AndroidMotionEvent>; + + static constexpr FieldMetadata_DeviceId kDeviceId{}; + void set_device_id(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_DeviceId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DisplayId = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kSint32, + int32_t, + AndroidMotionEvent>; + + static constexpr FieldMetadata_DisplayId kDisplayId{}; + void set_display_id(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_DisplayId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kSint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Classification = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + AndroidMotionEvent>; + + static constexpr FieldMetadata_Classification kClassification{}; + void set_classification(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Classification::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Flags = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + AndroidMotionEvent>; + + static constexpr FieldMetadata_Flags kFlags{}; + void set_flags(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pointer = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + AndroidMotionEvent_Pointer, + AndroidMotionEvent>; + + static constexpr FieldMetadata_Pointer kPointer{}; + template T* add_pointer() { + return BeginNestedMessage(9); + } + + + using FieldMetadata_OriginalEventId = + ::protozero::proto_utils::FieldMetadata< + 16, + ::protozero::proto_utils::RepetitionType::kRepeatedPacked, + ::protozero::proto_utils::ProtoSchemaType::kFixed32, + uint32_t, + AndroidMotionEvent>; + + static constexpr FieldMetadata_OriginalEventId kOriginalEventId{}; + void set_original_event_id(const ::protozero::PackedFixedSizeInt& packed_buffer) { + AppendBytes(FieldMetadata_OriginalEventId::kFieldId, packed_buffer.data(), + packed_buffer.size()); + } + + using FieldMetadata_DownTimeNanos = + ::protozero::proto_utils::FieldMetadata< + 17, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + AndroidMotionEvent>; + + static constexpr FieldMetadata_DownTimeNanos kDownTimeNanos{}; + void set_down_time_nanos(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_DownTimeNanos::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CursorPositionX = + ::protozero::proto_utils::FieldMetadata< + 18, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + AndroidMotionEvent>; + + static constexpr FieldMetadata_CursorPositionX kCursorPositionX{}; + void set_cursor_position_x(float value) { + static constexpr uint32_t field_id = FieldMetadata_CursorPositionX::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CursorPositionY = + ::protozero::proto_utils::FieldMetadata< + 19, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + AndroidMotionEvent>; + + static constexpr FieldMetadata_CursorPositionY kCursorPositionY{}; + void set_cursor_position_y(float value) { + static constexpr uint32_t field_id = FieldMetadata_CursorPositionY::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ActionButton = + ::protozero::proto_utils::FieldMetadata< + 20, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + AndroidMotionEvent>; + + static constexpr FieldMetadata_ActionButton kActionButton{}; + void set_action_button(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ActionButton::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ButtonState = + ::protozero::proto_utils::FieldMetadata< + 21, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + AndroidMotionEvent>; + + static constexpr FieldMetadata_ButtonState kButtonState{}; + void set_button_state(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ButtonState::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_MetaState = + ::protozero::proto_utils::FieldMetadata< + 22, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + AndroidMotionEvent>; + + static constexpr FieldMetadata_MetaState kMetaState{}; + void set_meta_state(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_MetaState::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PolicyFlags = + ::protozero::proto_utils::FieldMetadata< + 23, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + AndroidMotionEvent>; + + static constexpr FieldMetadata_PolicyFlags kPolicyFlags{}; + void set_policy_flags(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_PolicyFlags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PrecisionX = + ::protozero::proto_utils::FieldMetadata< + 24, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + AndroidMotionEvent>; + + static constexpr FieldMetadata_PrecisionX kPrecisionX{}; + void set_precision_x(float value) { + static constexpr uint32_t field_id = FieldMetadata_PrecisionX::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PrecisionY = + ::protozero::proto_utils::FieldMetadata< + 25, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + AndroidMotionEvent>; + + static constexpr FieldMetadata_PrecisionY kPrecisionY{}; + void set_precision_y(float value) { + static constexpr uint32_t field_id = FieldMetadata_PrecisionY::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } +}; + +class AndroidMotionEvent_Pointer_Decoder : public ::protozero::TypedProtoDecoder { + public: + AndroidMotionEvent_Pointer_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit AndroidMotionEvent_Pointer_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit AndroidMotionEvent_Pointer_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_axis_value() const { return at<1>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> axis_value() const { return GetRepeated<::protozero::ConstBytes>(1); } + bool has_pointer_id() const { return at<2>().valid(); } + int32_t pointer_id() const { return at<2>().as_int32(); } + bool has_tool_type() const { return at<3>().valid(); } + int32_t tool_type() const { return at<3>().as_int32(); } +}; + +class AndroidMotionEvent_Pointer : public ::protozero::Message { + public: + using Decoder = AndroidMotionEvent_Pointer_Decoder; + enum : int32_t { + kAxisValueFieldNumber = 1, + kPointerIdFieldNumber = 2, + kToolTypeFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.AndroidMotionEvent.Pointer"; } + + using AxisValue = ::perfetto::protos::pbzero::AndroidMotionEvent_Pointer_AxisValue; + + using FieldMetadata_AxisValue = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + AndroidMotionEvent_Pointer_AxisValue, + AndroidMotionEvent_Pointer>; + + static constexpr FieldMetadata_AxisValue kAxisValue{}; + template T* add_axis_value() { + return BeginNestedMessage(1); + } + + + using FieldMetadata_PointerId = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + AndroidMotionEvent_Pointer>; + + static constexpr FieldMetadata_PointerId kPointerId{}; + void set_pointer_id(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_PointerId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ToolType = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + AndroidMotionEvent_Pointer>; + + static constexpr FieldMetadata_ToolType kToolType{}; + void set_tool_type(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ToolType::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class AndroidMotionEvent_Pointer_AxisValue_Decoder : public ::protozero::TypedProtoDecoder { + public: + AndroidMotionEvent_Pointer_AxisValue_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit AndroidMotionEvent_Pointer_AxisValue_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit AndroidMotionEvent_Pointer_AxisValue_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_axis() const { return at<1>().valid(); } + int32_t axis() const { return at<1>().as_int32(); } + bool has_value() const { return at<2>().valid(); } + float value() const { return at<2>().as_float(); } +}; + +class AndroidMotionEvent_Pointer_AxisValue : public ::protozero::Message { + public: + using Decoder = AndroidMotionEvent_Pointer_AxisValue_Decoder; + enum : int32_t { + kAxisFieldNumber = 1, + kValueFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.AndroidMotionEvent.Pointer.AxisValue"; } + + + using FieldMetadata_Axis = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + AndroidMotionEvent_Pointer_AxisValue>; + + static constexpr FieldMetadata_Axis kAxis{}; + void set_axis(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Axis::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Value = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + AndroidMotionEvent_Pointer_AxisValue>; + + static constexpr FieldMetadata_Value kValue{}; + void set_value(float value) { + static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } +}; + +class AndroidGameInterventionList_Decoder : public ::protozero::TypedProtoDecoder { + public: + AndroidGameInterventionList_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit AndroidGameInterventionList_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit AndroidGameInterventionList_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_game_packages() const { return at<1>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> game_packages() const { return GetRepeated<::protozero::ConstBytes>(1); } + bool has_parse_error() const { return at<2>().valid(); } + bool parse_error() const { return at<2>().as_bool(); } + bool has_read_error() const { return at<3>().valid(); } + bool read_error() const { return at<3>().as_bool(); } +}; + +class AndroidGameInterventionList : public ::protozero::Message { + public: + using Decoder = AndroidGameInterventionList_Decoder; + enum : int32_t { + kGamePackagesFieldNumber = 1, + kParseErrorFieldNumber = 2, + kReadErrorFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.AndroidGameInterventionList"; } + + using GameModeInfo = ::perfetto::protos::pbzero::AndroidGameInterventionList_GameModeInfo; + using GamePackageInfo = ::perfetto::protos::pbzero::AndroidGameInterventionList_GamePackageInfo; + + using FieldMetadata_GamePackages = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + AndroidGameInterventionList_GamePackageInfo, + AndroidGameInterventionList>; + + static constexpr FieldMetadata_GamePackages kGamePackages{}; + template T* add_game_packages() { + return BeginNestedMessage(1); + } + + + using FieldMetadata_ParseError = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + AndroidGameInterventionList>; + + static constexpr FieldMetadata_ParseError kParseError{}; + void set_parse_error(bool value) { + static constexpr uint32_t field_id = FieldMetadata_ParseError::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ReadError = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + AndroidGameInterventionList>; + + static constexpr FieldMetadata_ReadError kReadError{}; + void set_read_error(bool value) { + static constexpr uint32_t field_id = FieldMetadata_ReadError::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } +}; + +class AndroidGameInterventionList_GamePackageInfo_Decoder : public ::protozero::TypedProtoDecoder { + public: + AndroidGameInterventionList_GamePackageInfo_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit AndroidGameInterventionList_GamePackageInfo_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit AndroidGameInterventionList_GamePackageInfo_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_name() const { return at<1>().valid(); } + ::protozero::ConstChars name() const { return at<1>().as_string(); } + bool has_uid() const { return at<2>().valid(); } + uint64_t uid() const { return at<2>().as_uint64(); } + bool has_current_mode() const { return at<3>().valid(); } + uint32_t current_mode() const { return at<3>().as_uint32(); } + bool has_game_mode_info() const { return at<4>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> game_mode_info() const { return GetRepeated<::protozero::ConstBytes>(4); } +}; + +class AndroidGameInterventionList_GamePackageInfo : public ::protozero::Message { + public: + using Decoder = AndroidGameInterventionList_GamePackageInfo_Decoder; + enum : int32_t { + kNameFieldNumber = 1, + kUidFieldNumber = 2, + kCurrentModeFieldNumber = 3, + kGameModeInfoFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.AndroidGameInterventionList.GamePackageInfo"; } + + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + AndroidGameInterventionList_GamePackageInfo>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Uid = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + AndroidGameInterventionList_GamePackageInfo>; + + static constexpr FieldMetadata_Uid kUid{}; + void set_uid(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Uid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CurrentMode = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + AndroidGameInterventionList_GamePackageInfo>; + + static constexpr FieldMetadata_CurrentMode kCurrentMode{}; + void set_current_mode(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_CurrentMode::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_GameModeInfo = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + AndroidGameInterventionList_GameModeInfo, + AndroidGameInterventionList_GamePackageInfo>; + + static constexpr FieldMetadata_GameModeInfo kGameModeInfo{}; + template T* add_game_mode_info() { + return BeginNestedMessage(4); + } + +}; + +class AndroidGameInterventionList_GameModeInfo_Decoder : public ::protozero::TypedProtoDecoder { + public: + AndroidGameInterventionList_GameModeInfo_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit AndroidGameInterventionList_GameModeInfo_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit AndroidGameInterventionList_GameModeInfo_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_mode() const { return at<1>().valid(); } + uint32_t mode() const { return at<1>().as_uint32(); } + bool has_use_angle() const { return at<2>().valid(); } + bool use_angle() const { return at<2>().as_bool(); } + bool has_resolution_downscale() const { return at<3>().valid(); } + float resolution_downscale() const { return at<3>().as_float(); } + bool has_fps() const { return at<4>().valid(); } + float fps() const { return at<4>().as_float(); } +}; + +class AndroidGameInterventionList_GameModeInfo : public ::protozero::Message { + public: + using Decoder = AndroidGameInterventionList_GameModeInfo_Decoder; + enum : int32_t { + kModeFieldNumber = 1, + kUseAngleFieldNumber = 2, + kResolutionDownscaleFieldNumber = 3, + kFpsFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.AndroidGameInterventionList.GameModeInfo"; } + + + using FieldMetadata_Mode = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + AndroidGameInterventionList_GameModeInfo>; + + static constexpr FieldMetadata_Mode kMode{}; + void set_mode(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Mode::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_UseAngle = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + AndroidGameInterventionList_GameModeInfo>; + + static constexpr FieldMetadata_UseAngle kUseAngle{}; + void set_use_angle(bool value) { + static constexpr uint32_t field_id = FieldMetadata_UseAngle::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ResolutionDownscale = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + AndroidGameInterventionList_GameModeInfo>; + + static constexpr FieldMetadata_ResolutionDownscale kResolutionDownscale{}; + void set_resolution_downscale(float value) { + static constexpr uint32_t field_id = FieldMetadata_ResolutionDownscale::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Fps = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + AndroidGameInterventionList_GameModeInfo>; + + static constexpr FieldMetadata_Fps kFps{}; + void set_fps(float value) { + static constexpr uint32_t field_id = FieldMetadata_Fps::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } +}; + +class TraceStats_Decoder : public ::protozero::TypedProtoDecoder { + public: + TraceStats_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TraceStats_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TraceStats_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_buffer_stats() const { return at<1>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> buffer_stats() const { return GetRepeated<::protozero::ConstBytes>(1); } + bool has_chunk_payload_histogram_def() const { return at<17>().valid(); } + ::protozero::RepeatedFieldIterator chunk_payload_histogram_def() const { return GetRepeated(17); } + bool has_writer_stats() const { return at<18>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> writer_stats() const { return GetRepeated<::protozero::ConstBytes>(18); } + bool has_producers_connected() const { return at<2>().valid(); } + uint32_t producers_connected() const { return at<2>().as_uint32(); } + bool has_producers_seen() const { return at<3>().valid(); } + uint64_t producers_seen() const { return at<3>().as_uint64(); } + bool has_data_sources_registered() const { return at<4>().valid(); } + uint32_t data_sources_registered() const { return at<4>().as_uint32(); } + bool has_data_sources_seen() const { return at<5>().valid(); } + uint64_t data_sources_seen() const { return at<5>().as_uint64(); } + bool has_tracing_sessions() const { return at<6>().valid(); } + uint32_t tracing_sessions() const { return at<6>().as_uint32(); } + bool has_total_buffers() const { return at<7>().valid(); } + uint32_t total_buffers() const { return at<7>().as_uint32(); } + bool has_chunks_discarded() const { return at<8>().valid(); } + uint64_t chunks_discarded() const { return at<8>().as_uint64(); } + bool has_patches_discarded() const { return at<9>().valid(); } + uint64_t patches_discarded() const { return at<9>().as_uint64(); } + bool has_invalid_packets() const { return at<10>().valid(); } + uint64_t invalid_packets() const { return at<10>().as_uint64(); } + bool has_filter_stats() const { return at<11>().valid(); } + ::protozero::ConstBytes filter_stats() const { return at<11>().as_bytes(); } + bool has_flushes_requested() const { return at<12>().valid(); } + uint64_t flushes_requested() const { return at<12>().as_uint64(); } + bool has_flushes_succeeded() const { return at<13>().valid(); } + uint64_t flushes_succeeded() const { return at<13>().as_uint64(); } + bool has_flushes_failed() const { return at<14>().valid(); } + uint64_t flushes_failed() const { return at<14>().as_uint64(); } + bool has_final_flush_outcome() const { return at<15>().valid(); } + int32_t final_flush_outcome() const { return at<15>().as_int32(); } +}; + +class TraceStats : public ::protozero::Message { + public: + using Decoder = TraceStats_Decoder; + enum : int32_t { + kBufferStatsFieldNumber = 1, + kChunkPayloadHistogramDefFieldNumber = 17, + kWriterStatsFieldNumber = 18, + kProducersConnectedFieldNumber = 2, + kProducersSeenFieldNumber = 3, + kDataSourcesRegisteredFieldNumber = 4, + kDataSourcesSeenFieldNumber = 5, + kTracingSessionsFieldNumber = 6, + kTotalBuffersFieldNumber = 7, + kChunksDiscardedFieldNumber = 8, + kPatchesDiscardedFieldNumber = 9, + kInvalidPacketsFieldNumber = 10, + kFilterStatsFieldNumber = 11, + kFlushesRequestedFieldNumber = 12, + kFlushesSucceededFieldNumber = 13, + kFlushesFailedFieldNumber = 14, + kFinalFlushOutcomeFieldNumber = 15, + }; + static constexpr const char* GetName() { return ".perfetto.protos.TraceStats"; } + + using BufferStats = ::perfetto::protos::pbzero::TraceStats_BufferStats; + using WriterStats = ::perfetto::protos::pbzero::TraceStats_WriterStats; + using FilterStats = ::perfetto::protos::pbzero::TraceStats_FilterStats; + + using FinalFlushOutcome = ::perfetto::protos::pbzero::TraceStats_FinalFlushOutcome; + static inline const char* FinalFlushOutcome_Name(FinalFlushOutcome value) { + return ::perfetto::protos::pbzero::TraceStats_FinalFlushOutcome_Name(value); + } + static inline const FinalFlushOutcome FINAL_FLUSH_UNSPECIFIED = FinalFlushOutcome::FINAL_FLUSH_UNSPECIFIED; + static inline const FinalFlushOutcome FINAL_FLUSH_SUCCEEDED = FinalFlushOutcome::FINAL_FLUSH_SUCCEEDED; + static inline const FinalFlushOutcome FINAL_FLUSH_FAILED = FinalFlushOutcome::FINAL_FLUSH_FAILED; + + using FieldMetadata_BufferStats = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TraceStats_BufferStats, + TraceStats>; + + static constexpr FieldMetadata_BufferStats kBufferStats{}; + template T* add_buffer_stats() { + return BeginNestedMessage(1); + } + + + using FieldMetadata_ChunkPayloadHistogramDef = + ::protozero::proto_utils::FieldMetadata< + 17, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + TraceStats>; + + static constexpr FieldMetadata_ChunkPayloadHistogramDef kChunkPayloadHistogramDef{}; + void add_chunk_payload_histogram_def(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_ChunkPayloadHistogramDef::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_WriterStats = + ::protozero::proto_utils::FieldMetadata< + 18, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TraceStats_WriterStats, + TraceStats>; + + static constexpr FieldMetadata_WriterStats kWriterStats{}; + template T* add_writer_stats() { + return BeginNestedMessage(18); + } + + + using FieldMetadata_ProducersConnected = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + TraceStats>; + + static constexpr FieldMetadata_ProducersConnected kProducersConnected{}; + void set_producers_connected(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ProducersConnected::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ProducersSeen = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TraceStats>; + + static constexpr FieldMetadata_ProducersSeen kProducersSeen{}; + void set_producers_seen(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_ProducersSeen::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DataSourcesRegistered = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + TraceStats>; + + static constexpr FieldMetadata_DataSourcesRegistered kDataSourcesRegistered{}; + void set_data_sources_registered(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_DataSourcesRegistered::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DataSourcesSeen = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TraceStats>; + + static constexpr FieldMetadata_DataSourcesSeen kDataSourcesSeen{}; + void set_data_sources_seen(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_DataSourcesSeen::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TracingSessions = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + TraceStats>; + + static constexpr FieldMetadata_TracingSessions kTracingSessions{}; + void set_tracing_sessions(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TracingSessions::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TotalBuffers = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + TraceStats>; + + static constexpr FieldMetadata_TotalBuffers kTotalBuffers{}; + void set_total_buffers(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TotalBuffers::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ChunksDiscarded = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TraceStats>; + + static constexpr FieldMetadata_ChunksDiscarded kChunksDiscarded{}; + void set_chunks_discarded(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_ChunksDiscarded::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PatchesDiscarded = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TraceStats>; + + static constexpr FieldMetadata_PatchesDiscarded kPatchesDiscarded{}; + void set_patches_discarded(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_PatchesDiscarded::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_InvalidPackets = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TraceStats>; + + static constexpr FieldMetadata_InvalidPackets kInvalidPackets{}; + void set_invalid_packets(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_InvalidPackets::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FilterStats = + ::protozero::proto_utils::FieldMetadata< + 11, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TraceStats_FilterStats, + TraceStats>; + + static constexpr FieldMetadata_FilterStats kFilterStats{}; + template T* set_filter_stats() { + return BeginNestedMessage(11); + } + + + using FieldMetadata_FlushesRequested = + ::protozero::proto_utils::FieldMetadata< + 12, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TraceStats>; + + static constexpr FieldMetadata_FlushesRequested kFlushesRequested{}; + void set_flushes_requested(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_FlushesRequested::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FlushesSucceeded = + ::protozero::proto_utils::FieldMetadata< + 13, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TraceStats>; + + static constexpr FieldMetadata_FlushesSucceeded kFlushesSucceeded{}; + void set_flushes_succeeded(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_FlushesSucceeded::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FlushesFailed = + ::protozero::proto_utils::FieldMetadata< + 14, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TraceStats>; + + static constexpr FieldMetadata_FlushesFailed kFlushesFailed{}; + void set_flushes_failed(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_FlushesFailed::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FinalFlushOutcome = + ::protozero::proto_utils::FieldMetadata< + 15, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + TraceStats_FinalFlushOutcome, + TraceStats>; + + static constexpr FieldMetadata_FinalFlushOutcome kFinalFlushOutcome{}; + void set_final_flush_outcome(TraceStats_FinalFlushOutcome value) { + static constexpr uint32_t field_id = FieldMetadata_FinalFlushOutcome::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } +}; + +class TraceStats_FilterStats_Decoder : public ::protozero::TypedProtoDecoder { + public: + TraceStats_FilterStats_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TraceStats_FilterStats_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TraceStats_FilterStats_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_input_packets() const { return at<1>().valid(); } + uint64_t input_packets() const { return at<1>().as_uint64(); } + bool has_input_bytes() const { return at<2>().valid(); } + uint64_t input_bytes() const { return at<2>().as_uint64(); } + bool has_output_bytes() const { return at<3>().valid(); } + uint64_t output_bytes() const { return at<3>().as_uint64(); } + bool has_errors() const { return at<4>().valid(); } + uint64_t errors() const { return at<4>().as_uint64(); } + bool has_time_taken_ns() const { return at<5>().valid(); } + uint64_t time_taken_ns() const { return at<5>().as_uint64(); } + bool has_bytes_discarded_per_buffer() const { return at<20>().valid(); } + ::protozero::RepeatedFieldIterator bytes_discarded_per_buffer() const { return GetRepeated(20); } +}; + +class TraceStats_FilterStats : public ::protozero::Message { + public: + using Decoder = TraceStats_FilterStats_Decoder; + enum : int32_t { + kInputPacketsFieldNumber = 1, + kInputBytesFieldNumber = 2, + kOutputBytesFieldNumber = 3, + kErrorsFieldNumber = 4, + kTimeTakenNsFieldNumber = 5, + kBytesDiscardedPerBufferFieldNumber = 20, + }; + static constexpr const char* GetName() { return ".perfetto.protos.TraceStats.FilterStats"; } + + + using FieldMetadata_InputPackets = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TraceStats_FilterStats>; + + static constexpr FieldMetadata_InputPackets kInputPackets{}; + void set_input_packets(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_InputPackets::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_InputBytes = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TraceStats_FilterStats>; + + static constexpr FieldMetadata_InputBytes kInputBytes{}; + void set_input_bytes(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_InputBytes::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_OutputBytes = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TraceStats_FilterStats>; + + static constexpr FieldMetadata_OutputBytes kOutputBytes{}; + void set_output_bytes(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_OutputBytes::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Errors = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TraceStats_FilterStats>; + + static constexpr FieldMetadata_Errors kErrors{}; + void set_errors(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Errors::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TimeTakenNs = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TraceStats_FilterStats>; + + static constexpr FieldMetadata_TimeTakenNs kTimeTakenNs{}; + void set_time_taken_ns(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_TimeTakenNs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_BytesDiscardedPerBuffer = + ::protozero::proto_utils::FieldMetadata< + 20, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TraceStats_FilterStats>; + + static constexpr FieldMetadata_BytesDiscardedPerBuffer kBytesDiscardedPerBuffer{}; + void add_bytes_discarded_per_buffer(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_BytesDiscardedPerBuffer::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class TraceStats_WriterStats_Decoder : public ::protozero::TypedProtoDecoder { + public: + TraceStats_WriterStats_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TraceStats_WriterStats_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TraceStats_WriterStats_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_sequence_id() const { return at<1>().valid(); } + uint64_t sequence_id() const { return at<1>().as_uint64(); } + bool has_buffer() const { return at<4>().valid(); } + uint32_t buffer() const { return at<4>().as_uint32(); } + bool has_chunk_payload_histogram_counts() const { return at<2>().valid(); } + ::protozero::PackedRepeatedFieldIterator<::protozero::proto_utils::ProtoWireType::kVarInt, uint64_t> chunk_payload_histogram_counts(bool* parse_error_ptr) const { return GetPackedRepeated<::protozero::proto_utils::ProtoWireType::kVarInt, uint64_t>(2, parse_error_ptr); } + bool has_chunk_payload_histogram_sum() const { return at<3>().valid(); } + ::protozero::PackedRepeatedFieldIterator<::protozero::proto_utils::ProtoWireType::kVarInt, int64_t> chunk_payload_histogram_sum(bool* parse_error_ptr) const { return GetPackedRepeated<::protozero::proto_utils::ProtoWireType::kVarInt, int64_t>(3, parse_error_ptr); } +}; + +class TraceStats_WriterStats : public ::protozero::Message { + public: + using Decoder = TraceStats_WriterStats_Decoder; + enum : int32_t { + kSequenceIdFieldNumber = 1, + kBufferFieldNumber = 4, + kChunkPayloadHistogramCountsFieldNumber = 2, + kChunkPayloadHistogramSumFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.TraceStats.WriterStats"; } + + + using FieldMetadata_SequenceId = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TraceStats_WriterStats>; + + static constexpr FieldMetadata_SequenceId kSequenceId{}; + void set_sequence_id(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_SequenceId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Buffer = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + TraceStats_WriterStats>; + + static constexpr FieldMetadata_Buffer kBuffer{}; + void set_buffer(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Buffer::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ChunkPayloadHistogramCounts = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kRepeatedPacked, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TraceStats_WriterStats>; + + static constexpr FieldMetadata_ChunkPayloadHistogramCounts kChunkPayloadHistogramCounts{}; + void set_chunk_payload_histogram_counts(const ::protozero::PackedVarInt& packed_buffer) { + AppendBytes(FieldMetadata_ChunkPayloadHistogramCounts::kFieldId, packed_buffer.data(), + packed_buffer.size()); + } + + using FieldMetadata_ChunkPayloadHistogramSum = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kRepeatedPacked, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + TraceStats_WriterStats>; + + static constexpr FieldMetadata_ChunkPayloadHistogramSum kChunkPayloadHistogramSum{}; + void set_chunk_payload_histogram_sum(const ::protozero::PackedVarInt& packed_buffer) { + AppendBytes(FieldMetadata_ChunkPayloadHistogramSum::kFieldId, packed_buffer.data(), + packed_buffer.size()); + } +}; + +class TraceStats_BufferStats_Decoder : public ::protozero::TypedProtoDecoder { + public: + TraceStats_BufferStats_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TraceStats_BufferStats_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TraceStats_BufferStats_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_buffer_size() const { return at<12>().valid(); } + uint64_t buffer_size() const { return at<12>().as_uint64(); } + bool has_bytes_written() const { return at<1>().valid(); } + uint64_t bytes_written() const { return at<1>().as_uint64(); } + bool has_bytes_overwritten() const { return at<13>().valid(); } + uint64_t bytes_overwritten() const { return at<13>().as_uint64(); } + bool has_bytes_read() const { return at<14>().valid(); } + uint64_t bytes_read() const { return at<14>().as_uint64(); } + bool has_padding_bytes_written() const { return at<15>().valid(); } + uint64_t padding_bytes_written() const { return at<15>().as_uint64(); } + bool has_padding_bytes_cleared() const { return at<16>().valid(); } + uint64_t padding_bytes_cleared() const { return at<16>().as_uint64(); } + bool has_chunks_written() const { return at<2>().valid(); } + uint64_t chunks_written() const { return at<2>().as_uint64(); } + bool has_chunks_rewritten() const { return at<10>().valid(); } + uint64_t chunks_rewritten() const { return at<10>().as_uint64(); } + bool has_chunks_overwritten() const { return at<3>().valid(); } + uint64_t chunks_overwritten() const { return at<3>().as_uint64(); } + bool has_chunks_discarded() const { return at<18>().valid(); } + uint64_t chunks_discarded() const { return at<18>().as_uint64(); } + bool has_chunks_read() const { return at<17>().valid(); } + uint64_t chunks_read() const { return at<17>().as_uint64(); } + bool has_chunks_committed_out_of_order() const { return at<11>().valid(); } + uint64_t chunks_committed_out_of_order() const { return at<11>().as_uint64(); } + bool has_write_wrap_count() const { return at<4>().valid(); } + uint64_t write_wrap_count() const { return at<4>().as_uint64(); } + bool has_patches_succeeded() const { return at<5>().valid(); } + uint64_t patches_succeeded() const { return at<5>().as_uint64(); } + bool has_patches_failed() const { return at<6>().valid(); } + uint64_t patches_failed() const { return at<6>().as_uint64(); } + bool has_readaheads_succeeded() const { return at<7>().valid(); } + uint64_t readaheads_succeeded() const { return at<7>().as_uint64(); } + bool has_readaheads_failed() const { return at<8>().valid(); } + uint64_t readaheads_failed() const { return at<8>().as_uint64(); } + bool has_abi_violations() const { return at<9>().valid(); } + uint64_t abi_violations() const { return at<9>().as_uint64(); } + bool has_trace_writer_packet_loss() const { return at<19>().valid(); } + uint64_t trace_writer_packet_loss() const { return at<19>().as_uint64(); } +}; + +class TraceStats_BufferStats : public ::protozero::Message { + public: + using Decoder = TraceStats_BufferStats_Decoder; + enum : int32_t { + kBufferSizeFieldNumber = 12, + kBytesWrittenFieldNumber = 1, + kBytesOverwrittenFieldNumber = 13, + kBytesReadFieldNumber = 14, + kPaddingBytesWrittenFieldNumber = 15, + kPaddingBytesClearedFieldNumber = 16, + kChunksWrittenFieldNumber = 2, + kChunksRewrittenFieldNumber = 10, + kChunksOverwrittenFieldNumber = 3, + kChunksDiscardedFieldNumber = 18, + kChunksReadFieldNumber = 17, + kChunksCommittedOutOfOrderFieldNumber = 11, + kWriteWrapCountFieldNumber = 4, + kPatchesSucceededFieldNumber = 5, + kPatchesFailedFieldNumber = 6, + kReadaheadsSucceededFieldNumber = 7, + kReadaheadsFailedFieldNumber = 8, + kAbiViolationsFieldNumber = 9, + kTraceWriterPacketLossFieldNumber = 19, + }; + static constexpr const char* GetName() { return ".perfetto.protos.TraceStats.BufferStats"; } + + + using FieldMetadata_BufferSize = + ::protozero::proto_utils::FieldMetadata< + 12, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TraceStats_BufferStats>; + + static constexpr FieldMetadata_BufferSize kBufferSize{}; + void set_buffer_size(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_BufferSize::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_BytesWritten = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TraceStats_BufferStats>; + + static constexpr FieldMetadata_BytesWritten kBytesWritten{}; + void set_bytes_written(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_BytesWritten::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_BytesOverwritten = + ::protozero::proto_utils::FieldMetadata< + 13, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TraceStats_BufferStats>; + + static constexpr FieldMetadata_BytesOverwritten kBytesOverwritten{}; + void set_bytes_overwritten(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_BytesOverwritten::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_BytesRead = + ::protozero::proto_utils::FieldMetadata< + 14, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TraceStats_BufferStats>; + + static constexpr FieldMetadata_BytesRead kBytesRead{}; + void set_bytes_read(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_BytesRead::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PaddingBytesWritten = + ::protozero::proto_utils::FieldMetadata< + 15, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TraceStats_BufferStats>; + + static constexpr FieldMetadata_PaddingBytesWritten kPaddingBytesWritten{}; + void set_padding_bytes_written(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_PaddingBytesWritten::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PaddingBytesCleared = + ::protozero::proto_utils::FieldMetadata< + 16, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TraceStats_BufferStats>; + + static constexpr FieldMetadata_PaddingBytesCleared kPaddingBytesCleared{}; + void set_padding_bytes_cleared(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_PaddingBytesCleared::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ChunksWritten = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TraceStats_BufferStats>; + + static constexpr FieldMetadata_ChunksWritten kChunksWritten{}; + void set_chunks_written(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_ChunksWritten::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ChunksRewritten = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TraceStats_BufferStats>; + + static constexpr FieldMetadata_ChunksRewritten kChunksRewritten{}; + void set_chunks_rewritten(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_ChunksRewritten::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ChunksOverwritten = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TraceStats_BufferStats>; + + static constexpr FieldMetadata_ChunksOverwritten kChunksOverwritten{}; + void set_chunks_overwritten(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_ChunksOverwritten::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ChunksDiscarded = + ::protozero::proto_utils::FieldMetadata< + 18, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TraceStats_BufferStats>; + + static constexpr FieldMetadata_ChunksDiscarded kChunksDiscarded{}; + void set_chunks_discarded(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_ChunksDiscarded::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ChunksRead = + ::protozero::proto_utils::FieldMetadata< + 17, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TraceStats_BufferStats>; + + static constexpr FieldMetadata_ChunksRead kChunksRead{}; + void set_chunks_read(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_ChunksRead::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ChunksCommittedOutOfOrder = + ::protozero::proto_utils::FieldMetadata< + 11, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TraceStats_BufferStats>; + + static constexpr FieldMetadata_ChunksCommittedOutOfOrder kChunksCommittedOutOfOrder{}; + void set_chunks_committed_out_of_order(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_ChunksCommittedOutOfOrder::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_WriteWrapCount = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TraceStats_BufferStats>; + + static constexpr FieldMetadata_WriteWrapCount kWriteWrapCount{}; + void set_write_wrap_count(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_WriteWrapCount::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PatchesSucceeded = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TraceStats_BufferStats>; + + static constexpr FieldMetadata_PatchesSucceeded kPatchesSucceeded{}; + void set_patches_succeeded(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_PatchesSucceeded::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PatchesFailed = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TraceStats_BufferStats>; + + static constexpr FieldMetadata_PatchesFailed kPatchesFailed{}; + void set_patches_failed(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_PatchesFailed::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ReadaheadsSucceeded = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TraceStats_BufferStats>; + + static constexpr FieldMetadata_ReadaheadsSucceeded kReadaheadsSucceeded{}; + void set_readaheads_succeeded(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_ReadaheadsSucceeded::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ReadaheadsFailed = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TraceStats_BufferStats>; + + static constexpr FieldMetadata_ReadaheadsFailed kReadaheadsFailed{}; + void set_readaheads_failed(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_ReadaheadsFailed::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_AbiViolations = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TraceStats_BufferStats>; + + static constexpr FieldMetadata_AbiViolations kAbiViolations{}; + void set_abi_violations(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_AbiViolations::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TraceWriterPacketLoss = + ::protozero::proto_utils::FieldMetadata< + 19, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TraceStats_BufferStats>; + + static constexpr FieldMetadata_TraceWriterPacketLoss kTraceWriterPacketLoss{}; + void set_trace_writer_packet_loss(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_TraceWriterPacketLoss::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class TraceConfig_Decoder : public ::protozero::TypedProtoDecoder { + public: + TraceConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TraceConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TraceConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_buffers() const { return at<1>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> buffers() const { return GetRepeated<::protozero::ConstBytes>(1); } + bool has_data_sources() const { return at<2>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> data_sources() const { return GetRepeated<::protozero::ConstBytes>(2); } + bool has_builtin_data_sources() const { return at<20>().valid(); } + ::protozero::ConstBytes builtin_data_sources() const { return at<20>().as_bytes(); } + bool has_duration_ms() const { return at<3>().valid(); } + uint32_t duration_ms() const { return at<3>().as_uint32(); } + bool has_prefer_suspend_clock_for_duration() const { return at<36>().valid(); } + bool prefer_suspend_clock_for_duration() const { return at<36>().as_bool(); } + bool has_enable_extra_guardrails() const { return at<4>().valid(); } + bool enable_extra_guardrails() const { return at<4>().as_bool(); } + bool has_lockdown_mode() const { return at<5>().valid(); } + int32_t lockdown_mode() const { return at<5>().as_int32(); } + bool has_producers() const { return at<6>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> producers() const { return GetRepeated<::protozero::ConstBytes>(6); } + bool has_statsd_metadata() const { return at<7>().valid(); } + ::protozero::ConstBytes statsd_metadata() const { return at<7>().as_bytes(); } + bool has_write_into_file() const { return at<8>().valid(); } + bool write_into_file() const { return at<8>().as_bool(); } + bool has_output_path() const { return at<29>().valid(); } + ::protozero::ConstChars output_path() const { return at<29>().as_string(); } + bool has_file_write_period_ms() const { return at<9>().valid(); } + uint32_t file_write_period_ms() const { return at<9>().as_uint32(); } + bool has_max_file_size_bytes() const { return at<10>().valid(); } + uint64_t max_file_size_bytes() const { return at<10>().as_uint64(); } + bool has_guardrail_overrides() const { return at<11>().valid(); } + ::protozero::ConstBytes guardrail_overrides() const { return at<11>().as_bytes(); } + bool has_deferred_start() const { return at<12>().valid(); } + bool deferred_start() const { return at<12>().as_bool(); } + bool has_flush_period_ms() const { return at<13>().valid(); } + uint32_t flush_period_ms() const { return at<13>().as_uint32(); } + bool has_flush_timeout_ms() const { return at<14>().valid(); } + uint32_t flush_timeout_ms() const { return at<14>().as_uint32(); } + bool has_data_source_stop_timeout_ms() const { return at<23>().valid(); } + uint32_t data_source_stop_timeout_ms() const { return at<23>().as_uint32(); } + bool has_notify_traceur() const { return at<16>().valid(); } + bool notify_traceur() const { return at<16>().as_bool(); } + bool has_bugreport_score() const { return at<30>().valid(); } + int32_t bugreport_score() const { return at<30>().as_int32(); } + bool has_bugreport_filename() const { return at<38>().valid(); } + ::protozero::ConstChars bugreport_filename() const { return at<38>().as_string(); } + bool has_trigger_config() const { return at<17>().valid(); } + ::protozero::ConstBytes trigger_config() const { return at<17>().as_bytes(); } + bool has_activate_triggers() const { return at<18>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstChars> activate_triggers() const { return GetRepeated<::protozero::ConstChars>(18); } + bool has_incremental_state_config() const { return at<21>().valid(); } + ::protozero::ConstBytes incremental_state_config() const { return at<21>().as_bytes(); } + bool has_allow_user_build_tracing() const { return at<19>().valid(); } + bool allow_user_build_tracing() const { return at<19>().as_bool(); } + bool has_unique_session_name() const { return at<22>().valid(); } + ::protozero::ConstChars unique_session_name() const { return at<22>().as_string(); } + bool has_compression_type() const { return at<24>().valid(); } + int32_t compression_type() const { return at<24>().as_int32(); } + bool has_incident_report_config() const { return at<25>().valid(); } + ::protozero::ConstBytes incident_report_config() const { return at<25>().as_bytes(); } + bool has_statsd_logging() const { return at<31>().valid(); } + int32_t statsd_logging() const { return at<31>().as_int32(); } + bool has_trace_uuid_msb() const { return at<27>().valid(); } + int64_t trace_uuid_msb() const { return at<27>().as_int64(); } + bool has_trace_uuid_lsb() const { return at<28>().valid(); } + int64_t trace_uuid_lsb() const { return at<28>().as_int64(); } + bool has_trace_filter() const { return at<33>().valid(); } + ::protozero::ConstBytes trace_filter() const { return at<33>().as_bytes(); } + bool has_android_report_config() const { return at<34>().valid(); } + ::protozero::ConstBytes android_report_config() const { return at<34>().as_bytes(); } + bool has_cmd_trace_start_delay() const { return at<35>().valid(); } + ::protozero::ConstBytes cmd_trace_start_delay() const { return at<35>().as_bytes(); } +}; + +class TraceConfig : public ::protozero::Message { + public: + using Decoder = TraceConfig_Decoder; + enum : int32_t { + kBuffersFieldNumber = 1, + kDataSourcesFieldNumber = 2, + kBuiltinDataSourcesFieldNumber = 20, + kDurationMsFieldNumber = 3, + kPreferSuspendClockForDurationFieldNumber = 36, + kEnableExtraGuardrailsFieldNumber = 4, + kLockdownModeFieldNumber = 5, + kProducersFieldNumber = 6, + kStatsdMetadataFieldNumber = 7, + kWriteIntoFileFieldNumber = 8, + kOutputPathFieldNumber = 29, + kFileWritePeriodMsFieldNumber = 9, + kMaxFileSizeBytesFieldNumber = 10, + kGuardrailOverridesFieldNumber = 11, + kDeferredStartFieldNumber = 12, + kFlushPeriodMsFieldNumber = 13, + kFlushTimeoutMsFieldNumber = 14, + kDataSourceStopTimeoutMsFieldNumber = 23, + kNotifyTraceurFieldNumber = 16, + kBugreportScoreFieldNumber = 30, + kBugreportFilenameFieldNumber = 38, + kTriggerConfigFieldNumber = 17, + kActivateTriggersFieldNumber = 18, + kIncrementalStateConfigFieldNumber = 21, + kAllowUserBuildTracingFieldNumber = 19, + kUniqueSessionNameFieldNumber = 22, + kCompressionTypeFieldNumber = 24, + kIncidentReportConfigFieldNumber = 25, + kStatsdLoggingFieldNumber = 31, + kTraceUuidMsbFieldNumber = 27, + kTraceUuidLsbFieldNumber = 28, + kTraceFilterFieldNumber = 33, + kAndroidReportConfigFieldNumber = 34, + kCmdTraceStartDelayFieldNumber = 35, + }; + static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig"; } + + using BufferConfig = ::perfetto::protos::pbzero::TraceConfig_BufferConfig; + using DataSource = ::perfetto::protos::pbzero::TraceConfig_DataSource; + using BuiltinDataSource = ::perfetto::protos::pbzero::TraceConfig_BuiltinDataSource; + using ProducerConfig = ::perfetto::protos::pbzero::TraceConfig_ProducerConfig; + using StatsdMetadata = ::perfetto::protos::pbzero::TraceConfig_StatsdMetadata; + using GuardrailOverrides = ::perfetto::protos::pbzero::TraceConfig_GuardrailOverrides; + using TriggerConfig = ::perfetto::protos::pbzero::TraceConfig_TriggerConfig; + using IncrementalStateConfig = ::perfetto::protos::pbzero::TraceConfig_IncrementalStateConfig; + using IncidentReportConfig = ::perfetto::protos::pbzero::TraceConfig_IncidentReportConfig; + using TraceFilter = ::perfetto::protos::pbzero::TraceConfig_TraceFilter; + using AndroidReportConfig = ::perfetto::protos::pbzero::TraceConfig_AndroidReportConfig; + using CmdTraceStartDelay = ::perfetto::protos::pbzero::TraceConfig_CmdTraceStartDelay; + + using LockdownModeOperation = ::perfetto::protos::pbzero::TraceConfig_LockdownModeOperation; + static inline const char* LockdownModeOperation_Name(LockdownModeOperation value) { + return ::perfetto::protos::pbzero::TraceConfig_LockdownModeOperation_Name(value); + } + + using CompressionType = ::perfetto::protos::pbzero::TraceConfig_CompressionType; + static inline const char* CompressionType_Name(CompressionType value) { + return ::perfetto::protos::pbzero::TraceConfig_CompressionType_Name(value); + } + + using StatsdLogging = ::perfetto::protos::pbzero::TraceConfig_StatsdLogging; + static inline const char* StatsdLogging_Name(StatsdLogging value) { + return ::perfetto::protos::pbzero::TraceConfig_StatsdLogging_Name(value); + } + static inline const LockdownModeOperation LOCKDOWN_UNCHANGED = LockdownModeOperation::LOCKDOWN_UNCHANGED; + static inline const LockdownModeOperation LOCKDOWN_CLEAR = LockdownModeOperation::LOCKDOWN_CLEAR; + static inline const LockdownModeOperation LOCKDOWN_SET = LockdownModeOperation::LOCKDOWN_SET; + static inline const CompressionType COMPRESSION_TYPE_UNSPECIFIED = CompressionType::COMPRESSION_TYPE_UNSPECIFIED; + static inline const CompressionType COMPRESSION_TYPE_DEFLATE = CompressionType::COMPRESSION_TYPE_DEFLATE; + static inline const StatsdLogging STATSD_LOGGING_UNSPECIFIED = StatsdLogging::STATSD_LOGGING_UNSPECIFIED; + static inline const StatsdLogging STATSD_LOGGING_ENABLED = StatsdLogging::STATSD_LOGGING_ENABLED; + static inline const StatsdLogging STATSD_LOGGING_DISABLED = StatsdLogging::STATSD_LOGGING_DISABLED; + + using FieldMetadata_Buffers = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TraceConfig_BufferConfig, + TraceConfig>; + + static constexpr FieldMetadata_Buffers kBuffers{}; + template T* add_buffers() { + return BeginNestedMessage(1); + } + + + using FieldMetadata_DataSources = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TraceConfig_DataSource, + TraceConfig>; + + static constexpr FieldMetadata_DataSources kDataSources{}; + template T* add_data_sources() { + return BeginNestedMessage(2); + } + + + using FieldMetadata_BuiltinDataSources = + ::protozero::proto_utils::FieldMetadata< + 20, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TraceConfig_BuiltinDataSource, + TraceConfig>; + + static constexpr FieldMetadata_BuiltinDataSources kBuiltinDataSources{}; + template T* set_builtin_data_sources() { + return BeginNestedMessage(20); + } + + + using FieldMetadata_DurationMs = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + TraceConfig>; + + static constexpr FieldMetadata_DurationMs kDurationMs{}; + void set_duration_ms(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_DurationMs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PreferSuspendClockForDuration = + ::protozero::proto_utils::FieldMetadata< + 36, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + TraceConfig>; + + static constexpr FieldMetadata_PreferSuspendClockForDuration kPreferSuspendClockForDuration{}; + void set_prefer_suspend_clock_for_duration(bool value) { + static constexpr uint32_t field_id = FieldMetadata_PreferSuspendClockForDuration::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_EnableExtraGuardrails = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + TraceConfig>; + + static constexpr FieldMetadata_EnableExtraGuardrails kEnableExtraGuardrails{}; + void set_enable_extra_guardrails(bool value) { + static constexpr uint32_t field_id = FieldMetadata_EnableExtraGuardrails::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_LockdownMode = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + TraceConfig_LockdownModeOperation, + TraceConfig>; + + static constexpr FieldMetadata_LockdownMode kLockdownMode{}; + void set_lockdown_mode(TraceConfig_LockdownModeOperation value) { + static constexpr uint32_t field_id = FieldMetadata_LockdownMode::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Producers = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TraceConfig_ProducerConfig, + TraceConfig>; + + static constexpr FieldMetadata_Producers kProducers{}; + template T* add_producers() { + return BeginNestedMessage(6); + } + + + using FieldMetadata_StatsdMetadata = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TraceConfig_StatsdMetadata, + TraceConfig>; + + static constexpr FieldMetadata_StatsdMetadata kStatsdMetadata{}; + template T* set_statsd_metadata() { + return BeginNestedMessage(7); + } + + + using FieldMetadata_WriteIntoFile = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + TraceConfig>; + + static constexpr FieldMetadata_WriteIntoFile kWriteIntoFile{}; + void set_write_into_file(bool value) { + static constexpr uint32_t field_id = FieldMetadata_WriteIntoFile::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_OutputPath = + ::protozero::proto_utils::FieldMetadata< + 29, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + TraceConfig>; + + static constexpr FieldMetadata_OutputPath kOutputPath{}; + void set_output_path(const char* data, size_t size) { + AppendBytes(FieldMetadata_OutputPath::kFieldId, data, size); + } + void set_output_path(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_OutputPath::kFieldId, chars.data, chars.size); + } + void set_output_path(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_OutputPath::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FileWritePeriodMs = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + TraceConfig>; + + static constexpr FieldMetadata_FileWritePeriodMs kFileWritePeriodMs{}; + void set_file_write_period_ms(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_FileWritePeriodMs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_MaxFileSizeBytes = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TraceConfig>; + + static constexpr FieldMetadata_MaxFileSizeBytes kMaxFileSizeBytes{}; + void set_max_file_size_bytes(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_MaxFileSizeBytes::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_GuardrailOverrides = + ::protozero::proto_utils::FieldMetadata< + 11, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TraceConfig_GuardrailOverrides, + TraceConfig>; + + static constexpr FieldMetadata_GuardrailOverrides kGuardrailOverrides{}; + template T* set_guardrail_overrides() { + return BeginNestedMessage(11); + } + + + using FieldMetadata_DeferredStart = + ::protozero::proto_utils::FieldMetadata< + 12, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + TraceConfig>; + + static constexpr FieldMetadata_DeferredStart kDeferredStart{}; + void set_deferred_start(bool value) { + static constexpr uint32_t field_id = FieldMetadata_DeferredStart::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FlushPeriodMs = + ::protozero::proto_utils::FieldMetadata< + 13, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + TraceConfig>; + + static constexpr FieldMetadata_FlushPeriodMs kFlushPeriodMs{}; + void set_flush_period_ms(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_FlushPeriodMs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FlushTimeoutMs = + ::protozero::proto_utils::FieldMetadata< + 14, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + TraceConfig>; + + static constexpr FieldMetadata_FlushTimeoutMs kFlushTimeoutMs{}; + void set_flush_timeout_ms(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_FlushTimeoutMs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DataSourceStopTimeoutMs = + ::protozero::proto_utils::FieldMetadata< + 23, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + TraceConfig>; + + static constexpr FieldMetadata_DataSourceStopTimeoutMs kDataSourceStopTimeoutMs{}; + void set_data_source_stop_timeout_ms(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_DataSourceStopTimeoutMs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NotifyTraceur = + ::protozero::proto_utils::FieldMetadata< + 16, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + TraceConfig>; + + static constexpr FieldMetadata_NotifyTraceur kNotifyTraceur{}; + void set_notify_traceur(bool value) { + static constexpr uint32_t field_id = FieldMetadata_NotifyTraceur::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_BugreportScore = + ::protozero::proto_utils::FieldMetadata< + 30, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + TraceConfig>; + + static constexpr FieldMetadata_BugreportScore kBugreportScore{}; + void set_bugreport_score(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_BugreportScore::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_BugreportFilename = + ::protozero::proto_utils::FieldMetadata< + 38, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + TraceConfig>; + + static constexpr FieldMetadata_BugreportFilename kBugreportFilename{}; + void set_bugreport_filename(const char* data, size_t size) { + AppendBytes(FieldMetadata_BugreportFilename::kFieldId, data, size); + } + void set_bugreport_filename(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_BugreportFilename::kFieldId, chars.data, chars.size); + } + void set_bugreport_filename(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_BugreportFilename::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TriggerConfig = + ::protozero::proto_utils::FieldMetadata< + 17, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TraceConfig_TriggerConfig, + TraceConfig>; + + static constexpr FieldMetadata_TriggerConfig kTriggerConfig{}; + template T* set_trigger_config() { + return BeginNestedMessage(17); + } + + + using FieldMetadata_ActivateTriggers = + ::protozero::proto_utils::FieldMetadata< + 18, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + TraceConfig>; + + static constexpr FieldMetadata_ActivateTriggers kActivateTriggers{}; + void add_activate_triggers(const char* data, size_t size) { + AppendBytes(FieldMetadata_ActivateTriggers::kFieldId, data, size); + } + void add_activate_triggers(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_ActivateTriggers::kFieldId, chars.data, chars.size); + } + void add_activate_triggers(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_ActivateTriggers::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_IncrementalStateConfig = + ::protozero::proto_utils::FieldMetadata< + 21, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TraceConfig_IncrementalStateConfig, + TraceConfig>; + + static constexpr FieldMetadata_IncrementalStateConfig kIncrementalStateConfig{}; + template T* set_incremental_state_config() { + return BeginNestedMessage(21); + } + + + using FieldMetadata_AllowUserBuildTracing = + ::protozero::proto_utils::FieldMetadata< + 19, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + TraceConfig>; + + static constexpr FieldMetadata_AllowUserBuildTracing kAllowUserBuildTracing{}; + void set_allow_user_build_tracing(bool value) { + static constexpr uint32_t field_id = FieldMetadata_AllowUserBuildTracing::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_UniqueSessionName = + ::protozero::proto_utils::FieldMetadata< + 22, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + TraceConfig>; + + static constexpr FieldMetadata_UniqueSessionName kUniqueSessionName{}; + void set_unique_session_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_UniqueSessionName::kFieldId, data, size); + } + void set_unique_session_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_UniqueSessionName::kFieldId, chars.data, chars.size); + } + void set_unique_session_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_UniqueSessionName::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CompressionType = + ::protozero::proto_utils::FieldMetadata< + 24, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + TraceConfig_CompressionType, + TraceConfig>; + + static constexpr FieldMetadata_CompressionType kCompressionType{}; + void set_compression_type(TraceConfig_CompressionType value) { + static constexpr uint32_t field_id = FieldMetadata_CompressionType::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_IncidentReportConfig = + ::protozero::proto_utils::FieldMetadata< + 25, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TraceConfig_IncidentReportConfig, + TraceConfig>; + + static constexpr FieldMetadata_IncidentReportConfig kIncidentReportConfig{}; + template T* set_incident_report_config() { + return BeginNestedMessage(25); + } + + + using FieldMetadata_StatsdLogging = + ::protozero::proto_utils::FieldMetadata< + 31, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + TraceConfig_StatsdLogging, + TraceConfig>; + + static constexpr FieldMetadata_StatsdLogging kStatsdLogging{}; + void set_statsd_logging(TraceConfig_StatsdLogging value) { + static constexpr uint32_t field_id = FieldMetadata_StatsdLogging::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TraceUuidMsb = + ::protozero::proto_utils::FieldMetadata< + 27, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + TraceConfig>; + + static constexpr FieldMetadata_TraceUuidMsb kTraceUuidMsb{}; + void set_trace_uuid_msb(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_TraceUuidMsb::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TraceUuidLsb = + ::protozero::proto_utils::FieldMetadata< + 28, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + TraceConfig>; + + static constexpr FieldMetadata_TraceUuidLsb kTraceUuidLsb{}; + void set_trace_uuid_lsb(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_TraceUuidLsb::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TraceFilter = + ::protozero::proto_utils::FieldMetadata< + 33, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TraceConfig_TraceFilter, + TraceConfig>; + + static constexpr FieldMetadata_TraceFilter kTraceFilter{}; + template T* set_trace_filter() { + return BeginNestedMessage(33); + } + + + using FieldMetadata_AndroidReportConfig = + ::protozero::proto_utils::FieldMetadata< + 34, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TraceConfig_AndroidReportConfig, + TraceConfig>; + + static constexpr FieldMetadata_AndroidReportConfig kAndroidReportConfig{}; + template T* set_android_report_config() { + return BeginNestedMessage(34); + } + + + using FieldMetadata_CmdTraceStartDelay = + ::protozero::proto_utils::FieldMetadata< + 35, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TraceConfig_CmdTraceStartDelay, + TraceConfig>; + + static constexpr FieldMetadata_CmdTraceStartDelay kCmdTraceStartDelay{}; + template T* set_cmd_trace_start_delay() { + return BeginNestedMessage(35); + } + +}; + +class TraceConfig_CmdTraceStartDelay_Decoder : public ::protozero::TypedProtoDecoder { + public: + TraceConfig_CmdTraceStartDelay_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TraceConfig_CmdTraceStartDelay_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TraceConfig_CmdTraceStartDelay_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_min_delay_ms() const { return at<1>().valid(); } + uint32_t min_delay_ms() const { return at<1>().as_uint32(); } + bool has_max_delay_ms() const { return at<2>().valid(); } + uint32_t max_delay_ms() const { return at<2>().as_uint32(); } +}; + +class TraceConfig_CmdTraceStartDelay : public ::protozero::Message { + public: + using Decoder = TraceConfig_CmdTraceStartDelay_Decoder; + enum : int32_t { + kMinDelayMsFieldNumber = 1, + kMaxDelayMsFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig.CmdTraceStartDelay"; } + + + using FieldMetadata_MinDelayMs = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + TraceConfig_CmdTraceStartDelay>; + + static constexpr FieldMetadata_MinDelayMs kMinDelayMs{}; + void set_min_delay_ms(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_MinDelayMs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_MaxDelayMs = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + TraceConfig_CmdTraceStartDelay>; + + static constexpr FieldMetadata_MaxDelayMs kMaxDelayMs{}; + void set_max_delay_ms(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_MaxDelayMs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class TraceConfig_AndroidReportConfig_Decoder : public ::protozero::TypedProtoDecoder { + public: + TraceConfig_AndroidReportConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TraceConfig_AndroidReportConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TraceConfig_AndroidReportConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_reporter_service_package() const { return at<1>().valid(); } + ::protozero::ConstChars reporter_service_package() const { return at<1>().as_string(); } + bool has_reporter_service_class() const { return at<2>().valid(); } + ::protozero::ConstChars reporter_service_class() const { return at<2>().as_string(); } + bool has_skip_report() const { return at<3>().valid(); } + bool skip_report() const { return at<3>().as_bool(); } + bool has_use_pipe_in_framework_for_testing() const { return at<4>().valid(); } + bool use_pipe_in_framework_for_testing() const { return at<4>().as_bool(); } +}; + +class TraceConfig_AndroidReportConfig : public ::protozero::Message { + public: + using Decoder = TraceConfig_AndroidReportConfig_Decoder; + enum : int32_t { + kReporterServicePackageFieldNumber = 1, + kReporterServiceClassFieldNumber = 2, + kSkipReportFieldNumber = 3, + kUsePipeInFrameworkForTestingFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig.AndroidReportConfig"; } + + + using FieldMetadata_ReporterServicePackage = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + TraceConfig_AndroidReportConfig>; + + static constexpr FieldMetadata_ReporterServicePackage kReporterServicePackage{}; + void set_reporter_service_package(const char* data, size_t size) { + AppendBytes(FieldMetadata_ReporterServicePackage::kFieldId, data, size); + } + void set_reporter_service_package(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_ReporterServicePackage::kFieldId, chars.data, chars.size); + } + void set_reporter_service_package(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_ReporterServicePackage::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ReporterServiceClass = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + TraceConfig_AndroidReportConfig>; + + static constexpr FieldMetadata_ReporterServiceClass kReporterServiceClass{}; + void set_reporter_service_class(const char* data, size_t size) { + AppendBytes(FieldMetadata_ReporterServiceClass::kFieldId, data, size); + } + void set_reporter_service_class(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_ReporterServiceClass::kFieldId, chars.data, chars.size); + } + void set_reporter_service_class(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_ReporterServiceClass::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SkipReport = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + TraceConfig_AndroidReportConfig>; + + static constexpr FieldMetadata_SkipReport kSkipReport{}; + void set_skip_report(bool value) { + static constexpr uint32_t field_id = FieldMetadata_SkipReport::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_UsePipeInFrameworkForTesting = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + TraceConfig_AndroidReportConfig>; + + static constexpr FieldMetadata_UsePipeInFrameworkForTesting kUsePipeInFrameworkForTesting{}; + void set_use_pipe_in_framework_for_testing(bool value) { + static constexpr uint32_t field_id = FieldMetadata_UsePipeInFrameworkForTesting::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } +}; + +class TraceConfig_TraceFilter_Decoder : public ::protozero::TypedProtoDecoder { + public: + TraceConfig_TraceFilter_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TraceConfig_TraceFilter_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TraceConfig_TraceFilter_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_bytecode() const { return at<1>().valid(); } + ::protozero::ConstBytes bytecode() const { return at<1>().as_bytes(); } + bool has_bytecode_v2() const { return at<2>().valid(); } + ::protozero::ConstBytes bytecode_v2() const { return at<2>().as_bytes(); } + bool has_string_filter_chain() const { return at<3>().valid(); } + ::protozero::ConstBytes string_filter_chain() const { return at<3>().as_bytes(); } +}; + +class TraceConfig_TraceFilter : public ::protozero::Message { + public: + using Decoder = TraceConfig_TraceFilter_Decoder; + enum : int32_t { + kBytecodeFieldNumber = 1, + kBytecodeV2FieldNumber = 2, + kStringFilterChainFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig.TraceFilter"; } + + using StringFilterRule = ::perfetto::protos::pbzero::TraceConfig_TraceFilter_StringFilterRule; + using StringFilterChain = ::perfetto::protos::pbzero::TraceConfig_TraceFilter_StringFilterChain; + + using StringFilterPolicy = ::perfetto::protos::pbzero::TraceConfig_TraceFilter_StringFilterPolicy; + static inline const char* StringFilterPolicy_Name(StringFilterPolicy value) { + return ::perfetto::protos::pbzero::TraceConfig_TraceFilter_StringFilterPolicy_Name(value); + } + static inline const StringFilterPolicy SFP_UNSPECIFIED = StringFilterPolicy::SFP_UNSPECIFIED; + static inline const StringFilterPolicy SFP_MATCH_REDACT_GROUPS = StringFilterPolicy::SFP_MATCH_REDACT_GROUPS; + static inline const StringFilterPolicy SFP_ATRACE_MATCH_REDACT_GROUPS = StringFilterPolicy::SFP_ATRACE_MATCH_REDACT_GROUPS; + static inline const StringFilterPolicy SFP_MATCH_BREAK = StringFilterPolicy::SFP_MATCH_BREAK; + static inline const StringFilterPolicy SFP_ATRACE_MATCH_BREAK = StringFilterPolicy::SFP_ATRACE_MATCH_BREAK; + static inline const StringFilterPolicy SFP_ATRACE_REPEATED_SEARCH_REDACT_GROUPS = StringFilterPolicy::SFP_ATRACE_REPEATED_SEARCH_REDACT_GROUPS; + + using FieldMetadata_Bytecode = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBytes, + std::string, + TraceConfig_TraceFilter>; + + static constexpr FieldMetadata_Bytecode kBytecode{}; + void set_bytecode(const uint8_t* data, size_t size) { + AppendBytes(FieldMetadata_Bytecode::kFieldId, data, size); + } + void set_bytecode(::protozero::ConstBytes bytes) { + AppendBytes(FieldMetadata_Bytecode::kFieldId, bytes.data, bytes.size); + } + void set_bytecode(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Bytecode::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBytes> + ::Append(*this, field_id, value); + } + + using FieldMetadata_BytecodeV2 = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBytes, + std::string, + TraceConfig_TraceFilter>; + + static constexpr FieldMetadata_BytecodeV2 kBytecodeV2{}; + void set_bytecode_v2(const uint8_t* data, size_t size) { + AppendBytes(FieldMetadata_BytecodeV2::kFieldId, data, size); + } + void set_bytecode_v2(::protozero::ConstBytes bytes) { + AppendBytes(FieldMetadata_BytecodeV2::kFieldId, bytes.data, bytes.size); + } + void set_bytecode_v2(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_BytecodeV2::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBytes> + ::Append(*this, field_id, value); + } + + using FieldMetadata_StringFilterChain = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TraceConfig_TraceFilter_StringFilterChain, + TraceConfig_TraceFilter>; + + static constexpr FieldMetadata_StringFilterChain kStringFilterChain{}; + template T* set_string_filter_chain() { + return BeginNestedMessage(3); + } + +}; + +class TraceConfig_TraceFilter_StringFilterChain_Decoder : public ::protozero::TypedProtoDecoder { + public: + TraceConfig_TraceFilter_StringFilterChain_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TraceConfig_TraceFilter_StringFilterChain_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TraceConfig_TraceFilter_StringFilterChain_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_rules() const { return at<1>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> rules() const { return GetRepeated<::protozero::ConstBytes>(1); } +}; + +class TraceConfig_TraceFilter_StringFilterChain : public ::protozero::Message { + public: + using Decoder = TraceConfig_TraceFilter_StringFilterChain_Decoder; + enum : int32_t { + kRulesFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig.TraceFilter.StringFilterChain"; } + + + using FieldMetadata_Rules = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TraceConfig_TraceFilter_StringFilterRule, + TraceConfig_TraceFilter_StringFilterChain>; + + static constexpr FieldMetadata_Rules kRules{}; + template T* add_rules() { + return BeginNestedMessage(1); + } + +}; + +class TraceConfig_TraceFilter_StringFilterRule_Decoder : public ::protozero::TypedProtoDecoder { + public: + TraceConfig_TraceFilter_StringFilterRule_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TraceConfig_TraceFilter_StringFilterRule_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TraceConfig_TraceFilter_StringFilterRule_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_policy() const { return at<1>().valid(); } + int32_t policy() const { return at<1>().as_int32(); } + bool has_regex_pattern() const { return at<2>().valid(); } + ::protozero::ConstChars regex_pattern() const { return at<2>().as_string(); } + bool has_atrace_payload_starts_with() const { return at<3>().valid(); } + ::protozero::ConstChars atrace_payload_starts_with() const { return at<3>().as_string(); } +}; + +class TraceConfig_TraceFilter_StringFilterRule : public ::protozero::Message { + public: + using Decoder = TraceConfig_TraceFilter_StringFilterRule_Decoder; + enum : int32_t { + kPolicyFieldNumber = 1, + kRegexPatternFieldNumber = 2, + kAtracePayloadStartsWithFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig.TraceFilter.StringFilterRule"; } + + + using FieldMetadata_Policy = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + TraceConfig_TraceFilter_StringFilterPolicy, + TraceConfig_TraceFilter_StringFilterRule>; + + static constexpr FieldMetadata_Policy kPolicy{}; + void set_policy(TraceConfig_TraceFilter_StringFilterPolicy value) { + static constexpr uint32_t field_id = FieldMetadata_Policy::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_RegexPattern = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + TraceConfig_TraceFilter_StringFilterRule>; + + static constexpr FieldMetadata_RegexPattern kRegexPattern{}; + void set_regex_pattern(const char* data, size_t size) { + AppendBytes(FieldMetadata_RegexPattern::kFieldId, data, size); + } + void set_regex_pattern(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_RegexPattern::kFieldId, chars.data, chars.size); + } + void set_regex_pattern(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_RegexPattern::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_AtracePayloadStartsWith = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + TraceConfig_TraceFilter_StringFilterRule>; + + static constexpr FieldMetadata_AtracePayloadStartsWith kAtracePayloadStartsWith{}; + void set_atrace_payload_starts_with(const char* data, size_t size) { + AppendBytes(FieldMetadata_AtracePayloadStartsWith::kFieldId, data, size); + } + void set_atrace_payload_starts_with(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_AtracePayloadStartsWith::kFieldId, chars.data, chars.size); + } + void set_atrace_payload_starts_with(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_AtracePayloadStartsWith::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class TraceConfig_IncidentReportConfig_Decoder : public ::protozero::TypedProtoDecoder { + public: + TraceConfig_IncidentReportConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TraceConfig_IncidentReportConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TraceConfig_IncidentReportConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_destination_package() const { return at<1>().valid(); } + ::protozero::ConstChars destination_package() const { return at<1>().as_string(); } + bool has_destination_class() const { return at<2>().valid(); } + ::protozero::ConstChars destination_class() const { return at<2>().as_string(); } + bool has_privacy_level() const { return at<3>().valid(); } + int32_t privacy_level() const { return at<3>().as_int32(); } + bool has_skip_incidentd() const { return at<5>().valid(); } + bool skip_incidentd() const { return at<5>().as_bool(); } + bool has_skip_dropbox() const { return at<4>().valid(); } + bool skip_dropbox() const { return at<4>().as_bool(); } +}; + +class TraceConfig_IncidentReportConfig : public ::protozero::Message { + public: + using Decoder = TraceConfig_IncidentReportConfig_Decoder; + enum : int32_t { + kDestinationPackageFieldNumber = 1, + kDestinationClassFieldNumber = 2, + kPrivacyLevelFieldNumber = 3, + kSkipIncidentdFieldNumber = 5, + kSkipDropboxFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig.IncidentReportConfig"; } + + + using FieldMetadata_DestinationPackage = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + TraceConfig_IncidentReportConfig>; + + static constexpr FieldMetadata_DestinationPackage kDestinationPackage{}; + void set_destination_package(const char* data, size_t size) { + AppendBytes(FieldMetadata_DestinationPackage::kFieldId, data, size); + } + void set_destination_package(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_DestinationPackage::kFieldId, chars.data, chars.size); + } + void set_destination_package(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_DestinationPackage::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DestinationClass = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + TraceConfig_IncidentReportConfig>; + + static constexpr FieldMetadata_DestinationClass kDestinationClass{}; + void set_destination_class(const char* data, size_t size) { + AppendBytes(FieldMetadata_DestinationClass::kFieldId, data, size); + } + void set_destination_class(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_DestinationClass::kFieldId, chars.data, chars.size); + } + void set_destination_class(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_DestinationClass::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PrivacyLevel = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + TraceConfig_IncidentReportConfig>; + + static constexpr FieldMetadata_PrivacyLevel kPrivacyLevel{}; + void set_privacy_level(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_PrivacyLevel::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SkipIncidentd = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + TraceConfig_IncidentReportConfig>; + + static constexpr FieldMetadata_SkipIncidentd kSkipIncidentd{}; + void set_skip_incidentd(bool value) { + static constexpr uint32_t field_id = FieldMetadata_SkipIncidentd::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SkipDropbox = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + TraceConfig_IncidentReportConfig>; + + static constexpr FieldMetadata_SkipDropbox kSkipDropbox{}; + void set_skip_dropbox(bool value) { + static constexpr uint32_t field_id = FieldMetadata_SkipDropbox::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } +}; + +class TraceConfig_IncrementalStateConfig_Decoder : public ::protozero::TypedProtoDecoder { + public: + TraceConfig_IncrementalStateConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TraceConfig_IncrementalStateConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TraceConfig_IncrementalStateConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_clear_period_ms() const { return at<1>().valid(); } + uint32_t clear_period_ms() const { return at<1>().as_uint32(); } +}; + +class TraceConfig_IncrementalStateConfig : public ::protozero::Message { + public: + using Decoder = TraceConfig_IncrementalStateConfig_Decoder; + enum : int32_t { + kClearPeriodMsFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig.IncrementalStateConfig"; } + + + using FieldMetadata_ClearPeriodMs = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + TraceConfig_IncrementalStateConfig>; + + static constexpr FieldMetadata_ClearPeriodMs kClearPeriodMs{}; + void set_clear_period_ms(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ClearPeriodMs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class TraceConfig_TriggerConfig_Decoder : public ::protozero::TypedProtoDecoder { + public: + TraceConfig_TriggerConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TraceConfig_TriggerConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TraceConfig_TriggerConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_trigger_mode() const { return at<1>().valid(); } + int32_t trigger_mode() const { return at<1>().as_int32(); } + bool has_use_clone_snapshot_if_available() const { return at<5>().valid(); } + bool use_clone_snapshot_if_available() const { return at<5>().as_bool(); } + bool has_triggers() const { return at<2>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> triggers() const { return GetRepeated<::protozero::ConstBytes>(2); } + bool has_trigger_timeout_ms() const { return at<3>().valid(); } + uint32_t trigger_timeout_ms() const { return at<3>().as_uint32(); } +}; + +class TraceConfig_TriggerConfig : public ::protozero::Message { + public: + using Decoder = TraceConfig_TriggerConfig_Decoder; + enum : int32_t { + kTriggerModeFieldNumber = 1, + kUseCloneSnapshotIfAvailableFieldNumber = 5, + kTriggersFieldNumber = 2, + kTriggerTimeoutMsFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig.TriggerConfig"; } + + using Trigger = ::perfetto::protos::pbzero::TraceConfig_TriggerConfig_Trigger; + + using TriggerMode = ::perfetto::protos::pbzero::TraceConfig_TriggerConfig_TriggerMode; + static inline const char* TriggerMode_Name(TriggerMode value) { + return ::perfetto::protos::pbzero::TraceConfig_TriggerConfig_TriggerMode_Name(value); + } + static inline const TriggerMode UNSPECIFIED = TriggerMode::UNSPECIFIED; + static inline const TriggerMode START_TRACING = TriggerMode::START_TRACING; + static inline const TriggerMode STOP_TRACING = TriggerMode::STOP_TRACING; + static inline const TriggerMode CLONE_SNAPSHOT = TriggerMode::CLONE_SNAPSHOT; + + using FieldMetadata_TriggerMode = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + TraceConfig_TriggerConfig_TriggerMode, + TraceConfig_TriggerConfig>; + + static constexpr FieldMetadata_TriggerMode kTriggerMode{}; + void set_trigger_mode(TraceConfig_TriggerConfig_TriggerMode value) { + static constexpr uint32_t field_id = FieldMetadata_TriggerMode::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_UseCloneSnapshotIfAvailable = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + TraceConfig_TriggerConfig>; + + static constexpr FieldMetadata_UseCloneSnapshotIfAvailable kUseCloneSnapshotIfAvailable{}; + void set_use_clone_snapshot_if_available(bool value) { + static constexpr uint32_t field_id = FieldMetadata_UseCloneSnapshotIfAvailable::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Triggers = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TraceConfig_TriggerConfig_Trigger, + TraceConfig_TriggerConfig>; + + static constexpr FieldMetadata_Triggers kTriggers{}; + template T* add_triggers() { + return BeginNestedMessage(2); + } + + + using FieldMetadata_TriggerTimeoutMs = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + TraceConfig_TriggerConfig>; + + static constexpr FieldMetadata_TriggerTimeoutMs kTriggerTimeoutMs{}; + void set_trigger_timeout_ms(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TriggerTimeoutMs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class TraceConfig_TriggerConfig_Trigger_Decoder : public ::protozero::TypedProtoDecoder { + public: + TraceConfig_TriggerConfig_Trigger_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TraceConfig_TriggerConfig_Trigger_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TraceConfig_TriggerConfig_Trigger_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_name() const { return at<1>().valid(); } + ::protozero::ConstChars name() const { return at<1>().as_string(); } + bool has_producer_name_regex() const { return at<2>().valid(); } + ::protozero::ConstChars producer_name_regex() const { return at<2>().as_string(); } + bool has_stop_delay_ms() const { return at<3>().valid(); } + uint32_t stop_delay_ms() const { return at<3>().as_uint32(); } + bool has_max_per_24_h() const { return at<4>().valid(); } + uint32_t max_per_24_h() const { return at<4>().as_uint32(); } + bool has_skip_probability() const { return at<5>().valid(); } + double skip_probability() const { return at<5>().as_double(); } +}; + +class TraceConfig_TriggerConfig_Trigger : public ::protozero::Message { + public: + using Decoder = TraceConfig_TriggerConfig_Trigger_Decoder; + enum : int32_t { + kNameFieldNumber = 1, + kProducerNameRegexFieldNumber = 2, + kStopDelayMsFieldNumber = 3, + kMaxPer24HFieldNumber = 4, + kSkipProbabilityFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig.TriggerConfig.Trigger"; } + + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + TraceConfig_TriggerConfig_Trigger>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ProducerNameRegex = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + TraceConfig_TriggerConfig_Trigger>; + + static constexpr FieldMetadata_ProducerNameRegex kProducerNameRegex{}; + void set_producer_name_regex(const char* data, size_t size) { + AppendBytes(FieldMetadata_ProducerNameRegex::kFieldId, data, size); + } + void set_producer_name_regex(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_ProducerNameRegex::kFieldId, chars.data, chars.size); + } + void set_producer_name_regex(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_ProducerNameRegex::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_StopDelayMs = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + TraceConfig_TriggerConfig_Trigger>; + + static constexpr FieldMetadata_StopDelayMs kStopDelayMs{}; + void set_stop_delay_ms(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_StopDelayMs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_MaxPer24H = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + TraceConfig_TriggerConfig_Trigger>; + + static constexpr FieldMetadata_MaxPer24H kMaxPer24H{}; + void set_max_per_24_h(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_MaxPer24H::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SkipProbability = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kDouble, + double, + TraceConfig_TriggerConfig_Trigger>; + + static constexpr FieldMetadata_SkipProbability kSkipProbability{}; + void set_skip_probability(double value) { + static constexpr uint32_t field_id = FieldMetadata_SkipProbability::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kDouble> + ::Append(*this, field_id, value); + } +}; + +class TraceConfig_GuardrailOverrides_Decoder : public ::protozero::TypedProtoDecoder { + public: + TraceConfig_GuardrailOverrides_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TraceConfig_GuardrailOverrides_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TraceConfig_GuardrailOverrides_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_max_upload_per_day_bytes() const { return at<1>().valid(); } + uint64_t max_upload_per_day_bytes() const { return at<1>().as_uint64(); } + bool has_max_tracing_buffer_size_kb() const { return at<2>().valid(); } + uint32_t max_tracing_buffer_size_kb() const { return at<2>().as_uint32(); } +}; + +class TraceConfig_GuardrailOverrides : public ::protozero::Message { + public: + using Decoder = TraceConfig_GuardrailOverrides_Decoder; + enum : int32_t { + kMaxUploadPerDayBytesFieldNumber = 1, + kMaxTracingBufferSizeKbFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig.GuardrailOverrides"; } + + + using FieldMetadata_MaxUploadPerDayBytes = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TraceConfig_GuardrailOverrides>; + + static constexpr FieldMetadata_MaxUploadPerDayBytes kMaxUploadPerDayBytes{}; + void set_max_upload_per_day_bytes(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_MaxUploadPerDayBytes::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_MaxTracingBufferSizeKb = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + TraceConfig_GuardrailOverrides>; + + static constexpr FieldMetadata_MaxTracingBufferSizeKb kMaxTracingBufferSizeKb{}; + void set_max_tracing_buffer_size_kb(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_MaxTracingBufferSizeKb::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class TraceConfig_StatsdMetadata_Decoder : public ::protozero::TypedProtoDecoder { + public: + TraceConfig_StatsdMetadata_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TraceConfig_StatsdMetadata_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TraceConfig_StatsdMetadata_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_triggering_alert_id() const { return at<1>().valid(); } + int64_t triggering_alert_id() const { return at<1>().as_int64(); } + bool has_triggering_config_uid() const { return at<2>().valid(); } + int32_t triggering_config_uid() const { return at<2>().as_int32(); } + bool has_triggering_config_id() const { return at<3>().valid(); } + int64_t triggering_config_id() const { return at<3>().as_int64(); } + bool has_triggering_subscription_id() const { return at<4>().valid(); } + int64_t triggering_subscription_id() const { return at<4>().as_int64(); } +}; + +class TraceConfig_StatsdMetadata : public ::protozero::Message { + public: + using Decoder = TraceConfig_StatsdMetadata_Decoder; + enum : int32_t { + kTriggeringAlertIdFieldNumber = 1, + kTriggeringConfigUidFieldNumber = 2, + kTriggeringConfigIdFieldNumber = 3, + kTriggeringSubscriptionIdFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig.StatsdMetadata"; } + + + using FieldMetadata_TriggeringAlertId = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + TraceConfig_StatsdMetadata>; + + static constexpr FieldMetadata_TriggeringAlertId kTriggeringAlertId{}; + void set_triggering_alert_id(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_TriggeringAlertId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TriggeringConfigUid = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + TraceConfig_StatsdMetadata>; + + static constexpr FieldMetadata_TriggeringConfigUid kTriggeringConfigUid{}; + void set_triggering_config_uid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TriggeringConfigUid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TriggeringConfigId = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + TraceConfig_StatsdMetadata>; + + static constexpr FieldMetadata_TriggeringConfigId kTriggeringConfigId{}; + void set_triggering_config_id(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_TriggeringConfigId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TriggeringSubscriptionId = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + TraceConfig_StatsdMetadata>; + + static constexpr FieldMetadata_TriggeringSubscriptionId kTriggeringSubscriptionId{}; + void set_triggering_subscription_id(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_TriggeringSubscriptionId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } +}; + +class TraceConfig_ProducerConfig_Decoder : public ::protozero::TypedProtoDecoder { + public: + TraceConfig_ProducerConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TraceConfig_ProducerConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TraceConfig_ProducerConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_producer_name() const { return at<1>().valid(); } + ::protozero::ConstChars producer_name() const { return at<1>().as_string(); } + bool has_shm_size_kb() const { return at<2>().valid(); } + uint32_t shm_size_kb() const { return at<2>().as_uint32(); } + bool has_page_size_kb() const { return at<3>().valid(); } + uint32_t page_size_kb() const { return at<3>().as_uint32(); } +}; + +class TraceConfig_ProducerConfig : public ::protozero::Message { + public: + using Decoder = TraceConfig_ProducerConfig_Decoder; + enum : int32_t { + kProducerNameFieldNumber = 1, + kShmSizeKbFieldNumber = 2, + kPageSizeKbFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig.ProducerConfig"; } + + + using FieldMetadata_ProducerName = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + TraceConfig_ProducerConfig>; + + static constexpr FieldMetadata_ProducerName kProducerName{}; + void set_producer_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_ProducerName::kFieldId, data, size); + } + void set_producer_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_ProducerName::kFieldId, chars.data, chars.size); + } + void set_producer_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_ProducerName::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ShmSizeKb = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + TraceConfig_ProducerConfig>; + + static constexpr FieldMetadata_ShmSizeKb kShmSizeKb{}; + void set_shm_size_kb(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ShmSizeKb::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PageSizeKb = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + TraceConfig_ProducerConfig>; + + static constexpr FieldMetadata_PageSizeKb kPageSizeKb{}; + void set_page_size_kb(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_PageSizeKb::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class TraceConfig_BuiltinDataSource_Decoder : public ::protozero::TypedProtoDecoder { + public: + TraceConfig_BuiltinDataSource_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TraceConfig_BuiltinDataSource_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TraceConfig_BuiltinDataSource_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_disable_clock_snapshotting() const { return at<1>().valid(); } + bool disable_clock_snapshotting() const { return at<1>().as_bool(); } + bool has_disable_trace_config() const { return at<2>().valid(); } + bool disable_trace_config() const { return at<2>().as_bool(); } + bool has_disable_system_info() const { return at<3>().valid(); } + bool disable_system_info() const { return at<3>().as_bool(); } + bool has_disable_service_events() const { return at<4>().valid(); } + bool disable_service_events() const { return at<4>().as_bool(); } + bool has_primary_trace_clock() const { return at<5>().valid(); } + int32_t primary_trace_clock() const { return at<5>().as_int32(); } + bool has_snapshot_interval_ms() const { return at<6>().valid(); } + uint32_t snapshot_interval_ms() const { return at<6>().as_uint32(); } + bool has_prefer_suspend_clock_for_snapshot() const { return at<7>().valid(); } + bool prefer_suspend_clock_for_snapshot() const { return at<7>().as_bool(); } + bool has_disable_chunk_usage_histograms() const { return at<8>().valid(); } + bool disable_chunk_usage_histograms() const { return at<8>().as_bool(); } +}; + +class TraceConfig_BuiltinDataSource : public ::protozero::Message { + public: + using Decoder = TraceConfig_BuiltinDataSource_Decoder; + enum : int32_t { + kDisableClockSnapshottingFieldNumber = 1, + kDisableTraceConfigFieldNumber = 2, + kDisableSystemInfoFieldNumber = 3, + kDisableServiceEventsFieldNumber = 4, + kPrimaryTraceClockFieldNumber = 5, + kSnapshotIntervalMsFieldNumber = 6, + kPreferSuspendClockForSnapshotFieldNumber = 7, + kDisableChunkUsageHistogramsFieldNumber = 8, + }; + static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig.BuiltinDataSource"; } + + + using FieldMetadata_DisableClockSnapshotting = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + TraceConfig_BuiltinDataSource>; + + static constexpr FieldMetadata_DisableClockSnapshotting kDisableClockSnapshotting{}; + void set_disable_clock_snapshotting(bool value) { + static constexpr uint32_t field_id = FieldMetadata_DisableClockSnapshotting::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DisableTraceConfig = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + TraceConfig_BuiltinDataSource>; + + static constexpr FieldMetadata_DisableTraceConfig kDisableTraceConfig{}; + void set_disable_trace_config(bool value) { + static constexpr uint32_t field_id = FieldMetadata_DisableTraceConfig::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DisableSystemInfo = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + TraceConfig_BuiltinDataSource>; + + static constexpr FieldMetadata_DisableSystemInfo kDisableSystemInfo{}; + void set_disable_system_info(bool value) { + static constexpr uint32_t field_id = FieldMetadata_DisableSystemInfo::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DisableServiceEvents = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + TraceConfig_BuiltinDataSource>; + + static constexpr FieldMetadata_DisableServiceEvents kDisableServiceEvents{}; + void set_disable_service_events(bool value) { + static constexpr uint32_t field_id = FieldMetadata_DisableServiceEvents::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PrimaryTraceClock = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + BuiltinClock, + TraceConfig_BuiltinDataSource>; + + static constexpr FieldMetadata_PrimaryTraceClock kPrimaryTraceClock{}; + void set_primary_trace_clock(BuiltinClock value) { + static constexpr uint32_t field_id = FieldMetadata_PrimaryTraceClock::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SnapshotIntervalMs = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + TraceConfig_BuiltinDataSource>; + + static constexpr FieldMetadata_SnapshotIntervalMs kSnapshotIntervalMs{}; + void set_snapshot_interval_ms(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_SnapshotIntervalMs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PreferSuspendClockForSnapshot = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + TraceConfig_BuiltinDataSource>; + + static constexpr FieldMetadata_PreferSuspendClockForSnapshot kPreferSuspendClockForSnapshot{}; + void set_prefer_suspend_clock_for_snapshot(bool value) { + static constexpr uint32_t field_id = FieldMetadata_PreferSuspendClockForSnapshot::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DisableChunkUsageHistograms = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + TraceConfig_BuiltinDataSource>; + + static constexpr FieldMetadata_DisableChunkUsageHistograms kDisableChunkUsageHistograms{}; + void set_disable_chunk_usage_histograms(bool value) { + static constexpr uint32_t field_id = FieldMetadata_DisableChunkUsageHistograms::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } +}; + +class TraceConfig_DataSource_Decoder : public ::protozero::TypedProtoDecoder { + public: + TraceConfig_DataSource_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TraceConfig_DataSource_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TraceConfig_DataSource_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_config() const { return at<1>().valid(); } + ::protozero::ConstBytes config() const { return at<1>().as_bytes(); } + bool has_producer_name_filter() const { return at<2>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstChars> producer_name_filter() const { return GetRepeated<::protozero::ConstChars>(2); } + bool has_producer_name_regex_filter() const { return at<3>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstChars> producer_name_regex_filter() const { return GetRepeated<::protozero::ConstChars>(3); } +}; + +class TraceConfig_DataSource : public ::protozero::Message { + public: + using Decoder = TraceConfig_DataSource_Decoder; + enum : int32_t { + kConfigFieldNumber = 1, + kProducerNameFilterFieldNumber = 2, + kProducerNameRegexFilterFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig.DataSource"; } + + + using FieldMetadata_Config = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + DataSourceConfig, + TraceConfig_DataSource>; + + static constexpr FieldMetadata_Config kConfig{}; + template T* set_config() { + return BeginNestedMessage(1); + } + + + using FieldMetadata_ProducerNameFilter = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + TraceConfig_DataSource>; + + static constexpr FieldMetadata_ProducerNameFilter kProducerNameFilter{}; + void add_producer_name_filter(const char* data, size_t size) { + AppendBytes(FieldMetadata_ProducerNameFilter::kFieldId, data, size); + } + void add_producer_name_filter(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_ProducerNameFilter::kFieldId, chars.data, chars.size); + } + void add_producer_name_filter(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_ProducerNameFilter::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ProducerNameRegexFilter = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + TraceConfig_DataSource>; + + static constexpr FieldMetadata_ProducerNameRegexFilter kProducerNameRegexFilter{}; + void add_producer_name_regex_filter(const char* data, size_t size) { + AppendBytes(FieldMetadata_ProducerNameRegexFilter::kFieldId, data, size); + } + void add_producer_name_regex_filter(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_ProducerNameRegexFilter::kFieldId, chars.data, chars.size); + } + void add_producer_name_regex_filter(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_ProducerNameRegexFilter::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class TraceConfig_BufferConfig_Decoder : public ::protozero::TypedProtoDecoder { + public: + TraceConfig_BufferConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TraceConfig_BufferConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TraceConfig_BufferConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_size_kb() const { return at<1>().valid(); } + uint32_t size_kb() const { return at<1>().as_uint32(); } + bool has_fill_policy() const { return at<4>().valid(); } + int32_t fill_policy() const { return at<4>().as_int32(); } + bool has_transfer_on_clone() const { return at<5>().valid(); } + bool transfer_on_clone() const { return at<5>().as_bool(); } + bool has_clear_before_clone() const { return at<6>().valid(); } + bool clear_before_clone() const { return at<6>().as_bool(); } +}; + +class TraceConfig_BufferConfig : public ::protozero::Message { + public: + using Decoder = TraceConfig_BufferConfig_Decoder; + enum : int32_t { + kSizeKbFieldNumber = 1, + kFillPolicyFieldNumber = 4, + kTransferOnCloneFieldNumber = 5, + kClearBeforeCloneFieldNumber = 6, + }; + static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig.BufferConfig"; } + + + using FillPolicy = ::perfetto::protos::pbzero::TraceConfig_BufferConfig_FillPolicy; + static inline const char* FillPolicy_Name(FillPolicy value) { + return ::perfetto::protos::pbzero::TraceConfig_BufferConfig_FillPolicy_Name(value); + } + static inline const FillPolicy UNSPECIFIED = FillPolicy::UNSPECIFIED; + static inline const FillPolicy RING_BUFFER = FillPolicy::RING_BUFFER; + static inline const FillPolicy DISCARD = FillPolicy::DISCARD; + + using FieldMetadata_SizeKb = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + TraceConfig_BufferConfig>; + + static constexpr FieldMetadata_SizeKb kSizeKb{}; + void set_size_kb(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_SizeKb::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FillPolicy = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + TraceConfig_BufferConfig_FillPolicy, + TraceConfig_BufferConfig>; + + static constexpr FieldMetadata_FillPolicy kFillPolicy{}; + void set_fill_policy(TraceConfig_BufferConfig_FillPolicy value) { + static constexpr uint32_t field_id = FieldMetadata_FillPolicy::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TransferOnClone = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + TraceConfig_BufferConfig>; + + static constexpr FieldMetadata_TransferOnClone kTransferOnClone{}; + void set_transfer_on_clone(bool value) { + static constexpr uint32_t field_id = FieldMetadata_TransferOnClone::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ClearBeforeClone = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + TraceConfig_BufferConfig>; + + static constexpr FieldMetadata_ClearBeforeClone kClearBeforeClone{}; + void set_clear_before_clone(bool value) { + static constexpr uint32_t field_id = FieldMetadata_ClearBeforeClone::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } +}; + +class DataSourceConfig_Decoder : public ::protozero::TypedProtoDecoder { + public: + DataSourceConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit DataSourceConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit DataSourceConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_name() const { return at<1>().valid(); } + ::protozero::ConstChars name() const { return at<1>().as_string(); } + bool has_target_buffer() const { return at<2>().valid(); } + uint32_t target_buffer() const { return at<2>().as_uint32(); } + bool has_trace_duration_ms() const { return at<3>().valid(); } + uint32_t trace_duration_ms() const { return at<3>().as_uint32(); } + bool has_prefer_suspend_clock_for_duration() const { return at<122>().valid(); } + bool prefer_suspend_clock_for_duration() const { return at<122>().as_bool(); } + bool has_stop_timeout_ms() const { return at<7>().valid(); } + uint32_t stop_timeout_ms() const { return at<7>().as_uint32(); } + bool has_enable_extra_guardrails() const { return at<6>().valid(); } + bool enable_extra_guardrails() const { return at<6>().as_bool(); } + bool has_session_initiator() const { return at<8>().valid(); } + int32_t session_initiator() const { return at<8>().as_int32(); } + bool has_tracing_session_id() const { return at<4>().valid(); } + uint64_t tracing_session_id() const { return at<4>().as_uint64(); } + bool has_ftrace_config() const { return at<100>().valid(); } + ::protozero::ConstBytes ftrace_config() const { return at<100>().as_bytes(); } + bool has_inode_file_config() const { return at<102>().valid(); } + ::protozero::ConstBytes inode_file_config() const { return at<102>().as_bytes(); } + bool has_process_stats_config() const { return at<103>().valid(); } + ::protozero::ConstBytes process_stats_config() const { return at<103>().as_bytes(); } + bool has_sys_stats_config() const { return at<104>().valid(); } + ::protozero::ConstBytes sys_stats_config() const { return at<104>().as_bytes(); } + bool has_heapprofd_config() const { return at<105>().valid(); } + ::protozero::ConstBytes heapprofd_config() const { return at<105>().as_bytes(); } + bool has_java_hprof_config() const { return at<110>().valid(); } + ::protozero::ConstBytes java_hprof_config() const { return at<110>().as_bytes(); } + bool has_android_power_config() const { return at<106>().valid(); } + ::protozero::ConstBytes android_power_config() const { return at<106>().as_bytes(); } + bool has_android_log_config() const { return at<107>().valid(); } + ::protozero::ConstBytes android_log_config() const { return at<107>().as_bytes(); } + bool has_gpu_counter_config() const { return at<108>().valid(); } + ::protozero::ConstBytes gpu_counter_config() const { return at<108>().as_bytes(); } + bool has_android_game_intervention_list_config() const { return at<116>().valid(); } + ::protozero::ConstBytes android_game_intervention_list_config() const { return at<116>().as_bytes(); } + bool has_packages_list_config() const { return at<109>().valid(); } + ::protozero::ConstBytes packages_list_config() const { return at<109>().as_bytes(); } + bool has_perf_event_config() const { return at<111>().valid(); } + ::protozero::ConstBytes perf_event_config() const { return at<111>().as_bytes(); } + bool has_vulkan_memory_config() const { return at<112>().valid(); } + ::protozero::ConstBytes vulkan_memory_config() const { return at<112>().as_bytes(); } + bool has_track_event_config() const { return at<113>().valid(); } + ::protozero::ConstBytes track_event_config() const { return at<113>().as_bytes(); } + bool has_android_polled_state_config() const { return at<114>().valid(); } + ::protozero::ConstBytes android_polled_state_config() const { return at<114>().as_bytes(); } + bool has_android_system_property_config() const { return at<118>().valid(); } + ::protozero::ConstBytes android_system_property_config() const { return at<118>().as_bytes(); } + bool has_statsd_tracing_config() const { return at<117>().valid(); } + ::protozero::ConstBytes statsd_tracing_config() const { return at<117>().as_bytes(); } + bool has_system_info_config() const { return at<119>().valid(); } + ::protozero::ConstBytes system_info_config() const { return at<119>().as_bytes(); } + bool has_chrome_config() const { return at<101>().valid(); } + ::protozero::ConstBytes chrome_config() const { return at<101>().as_bytes(); } + bool has_v8_config() const { return at<127>().valid(); } + ::protozero::ConstBytes v8_config() const { return at<127>().as_bytes(); } + bool has_interceptor_config() const { return at<115>().valid(); } + ::protozero::ConstBytes interceptor_config() const { return at<115>().as_bytes(); } + bool has_network_packet_trace_config() const { return at<120>().valid(); } + ::protozero::ConstBytes network_packet_trace_config() const { return at<120>().as_bytes(); } + bool has_surfaceflinger_layers_config() const { return at<121>().valid(); } + ::protozero::ConstBytes surfaceflinger_layers_config() const { return at<121>().as_bytes(); } + bool has_surfaceflinger_transactions_config() const { return at<123>().valid(); } + ::protozero::ConstBytes surfaceflinger_transactions_config() const { return at<123>().as_bytes(); } + bool has_android_sdk_sysprop_guard_config() const { return at<124>().valid(); } + ::protozero::ConstBytes android_sdk_sysprop_guard_config() const { return at<124>().as_bytes(); } + bool has_etw_config() const { return at<125>().valid(); } + ::protozero::ConstBytes etw_config() const { return at<125>().as_bytes(); } + bool has_protolog_config() const { return at<126>().valid(); } + ::protozero::ConstBytes protolog_config() const { return at<126>().as_bytes(); } + bool has_android_input_event_config() const { return at<128>().valid(); } + ::protozero::ConstBytes android_input_event_config() const { return at<128>().as_bytes(); } + // field legacy_config omitted because its id is too high + // field for_testing omitted because its id is too high +}; + +class DataSourceConfig : public ::protozero::Message { + public: + using Decoder = DataSourceConfig_Decoder; + enum : int32_t { + kNameFieldNumber = 1, + kTargetBufferFieldNumber = 2, + kTraceDurationMsFieldNumber = 3, + kPreferSuspendClockForDurationFieldNumber = 122, + kStopTimeoutMsFieldNumber = 7, + kEnableExtraGuardrailsFieldNumber = 6, + kSessionInitiatorFieldNumber = 8, + kTracingSessionIdFieldNumber = 4, + kFtraceConfigFieldNumber = 100, + kInodeFileConfigFieldNumber = 102, + kProcessStatsConfigFieldNumber = 103, + kSysStatsConfigFieldNumber = 104, + kHeapprofdConfigFieldNumber = 105, + kJavaHprofConfigFieldNumber = 110, + kAndroidPowerConfigFieldNumber = 106, + kAndroidLogConfigFieldNumber = 107, + kGpuCounterConfigFieldNumber = 108, + kAndroidGameInterventionListConfigFieldNumber = 116, + kPackagesListConfigFieldNumber = 109, + kPerfEventConfigFieldNumber = 111, + kVulkanMemoryConfigFieldNumber = 112, + kTrackEventConfigFieldNumber = 113, + kAndroidPolledStateConfigFieldNumber = 114, + kAndroidSystemPropertyConfigFieldNumber = 118, + kStatsdTracingConfigFieldNumber = 117, + kSystemInfoConfigFieldNumber = 119, + kChromeConfigFieldNumber = 101, + kV8ConfigFieldNumber = 127, + kInterceptorConfigFieldNumber = 115, + kNetworkPacketTraceConfigFieldNumber = 120, + kSurfaceflingerLayersConfigFieldNumber = 121, + kSurfaceflingerTransactionsConfigFieldNumber = 123, + kAndroidSdkSyspropGuardConfigFieldNumber = 124, + kEtwConfigFieldNumber = 125, + kProtologConfigFieldNumber = 126, + kAndroidInputEventConfigFieldNumber = 128, + kLegacyConfigFieldNumber = 1000, + kForTestingFieldNumber = 1001, + }; + static constexpr const char* GetName() { return ".perfetto.protos.DataSourceConfig"; } + + + using SessionInitiator = ::perfetto::protos::pbzero::DataSourceConfig_SessionInitiator; + static inline const char* SessionInitiator_Name(SessionInitiator value) { + return ::perfetto::protos::pbzero::DataSourceConfig_SessionInitiator_Name(value); + } + static inline const SessionInitiator SESSION_INITIATOR_UNSPECIFIED = SessionInitiator::SESSION_INITIATOR_UNSPECIFIED; + static inline const SessionInitiator SESSION_INITIATOR_TRUSTED_SYSTEM = SessionInitiator::SESSION_INITIATOR_TRUSTED_SYSTEM; + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + DataSourceConfig>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TargetBuffer = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + DataSourceConfig>; + + static constexpr FieldMetadata_TargetBuffer kTargetBuffer{}; + void set_target_buffer(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TargetBuffer::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TraceDurationMs = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + DataSourceConfig>; + + static constexpr FieldMetadata_TraceDurationMs kTraceDurationMs{}; + void set_trace_duration_ms(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TraceDurationMs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PreferSuspendClockForDuration = + ::protozero::proto_utils::FieldMetadata< + 122, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + DataSourceConfig>; + + static constexpr FieldMetadata_PreferSuspendClockForDuration kPreferSuspendClockForDuration{}; + void set_prefer_suspend_clock_for_duration(bool value) { + static constexpr uint32_t field_id = FieldMetadata_PreferSuspendClockForDuration::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_StopTimeoutMs = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + DataSourceConfig>; + + static constexpr FieldMetadata_StopTimeoutMs kStopTimeoutMs{}; + void set_stop_timeout_ms(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_StopTimeoutMs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_EnableExtraGuardrails = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + DataSourceConfig>; + + static constexpr FieldMetadata_EnableExtraGuardrails kEnableExtraGuardrails{}; + void set_enable_extra_guardrails(bool value) { + static constexpr uint32_t field_id = FieldMetadata_EnableExtraGuardrails::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SessionInitiator = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + DataSourceConfig_SessionInitiator, + DataSourceConfig>; + + static constexpr FieldMetadata_SessionInitiator kSessionInitiator{}; + void set_session_initiator(DataSourceConfig_SessionInitiator value) { + static constexpr uint32_t field_id = FieldMetadata_SessionInitiator::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TracingSessionId = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + DataSourceConfig>; + + static constexpr FieldMetadata_TracingSessionId kTracingSessionId{}; + void set_tracing_session_id(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_TracingSessionId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FtraceConfig = + ::protozero::proto_utils::FieldMetadata< + 100, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + FtraceConfig, + DataSourceConfig>; + + static constexpr FieldMetadata_FtraceConfig kFtraceConfig{}; + template T* set_ftrace_config() { + return BeginNestedMessage(100); + } + + void set_ftrace_config_raw(const std::string& raw) { + return AppendBytes(100, raw.data(), raw.size()); + } + + + using FieldMetadata_InodeFileConfig = + ::protozero::proto_utils::FieldMetadata< + 102, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + InodeFileConfig, + DataSourceConfig>; + + static constexpr FieldMetadata_InodeFileConfig kInodeFileConfig{}; + template T* set_inode_file_config() { + return BeginNestedMessage(102); + } + + void set_inode_file_config_raw(const std::string& raw) { + return AppendBytes(102, raw.data(), raw.size()); + } + + + using FieldMetadata_ProcessStatsConfig = + ::protozero::proto_utils::FieldMetadata< + 103, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ProcessStatsConfig, + DataSourceConfig>; + + static constexpr FieldMetadata_ProcessStatsConfig kProcessStatsConfig{}; + template T* set_process_stats_config() { + return BeginNestedMessage(103); + } + + void set_process_stats_config_raw(const std::string& raw) { + return AppendBytes(103, raw.data(), raw.size()); + } + + + using FieldMetadata_SysStatsConfig = + ::protozero::proto_utils::FieldMetadata< + 104, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + SysStatsConfig, + DataSourceConfig>; + + static constexpr FieldMetadata_SysStatsConfig kSysStatsConfig{}; + template T* set_sys_stats_config() { + return BeginNestedMessage(104); + } + + void set_sys_stats_config_raw(const std::string& raw) { + return AppendBytes(104, raw.data(), raw.size()); + } + + + using FieldMetadata_HeapprofdConfig = + ::protozero::proto_utils::FieldMetadata< + 105, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + HeapprofdConfig, + DataSourceConfig>; + + static constexpr FieldMetadata_HeapprofdConfig kHeapprofdConfig{}; + template T* set_heapprofd_config() { + return BeginNestedMessage(105); + } + + void set_heapprofd_config_raw(const std::string& raw) { + return AppendBytes(105, raw.data(), raw.size()); + } + + + using FieldMetadata_JavaHprofConfig = + ::protozero::proto_utils::FieldMetadata< + 110, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + JavaHprofConfig, + DataSourceConfig>; + + static constexpr FieldMetadata_JavaHprofConfig kJavaHprofConfig{}; + template T* set_java_hprof_config() { + return BeginNestedMessage(110); + } + + void set_java_hprof_config_raw(const std::string& raw) { + return AppendBytes(110, raw.data(), raw.size()); + } + + + using FieldMetadata_AndroidPowerConfig = + ::protozero::proto_utils::FieldMetadata< + 106, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + AndroidPowerConfig, + DataSourceConfig>; + + static constexpr FieldMetadata_AndroidPowerConfig kAndroidPowerConfig{}; + template T* set_android_power_config() { + return BeginNestedMessage(106); + } + + void set_android_power_config_raw(const std::string& raw) { + return AppendBytes(106, raw.data(), raw.size()); + } + + + using FieldMetadata_AndroidLogConfig = + ::protozero::proto_utils::FieldMetadata< + 107, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + AndroidLogConfig, + DataSourceConfig>; + + static constexpr FieldMetadata_AndroidLogConfig kAndroidLogConfig{}; + template T* set_android_log_config() { + return BeginNestedMessage(107); + } + + void set_android_log_config_raw(const std::string& raw) { + return AppendBytes(107, raw.data(), raw.size()); + } + + + using FieldMetadata_GpuCounterConfig = + ::protozero::proto_utils::FieldMetadata< + 108, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + GpuCounterConfig, + DataSourceConfig>; + + static constexpr FieldMetadata_GpuCounterConfig kGpuCounterConfig{}; + template T* set_gpu_counter_config() { + return BeginNestedMessage(108); + } + + void set_gpu_counter_config_raw(const std::string& raw) { + return AppendBytes(108, raw.data(), raw.size()); + } + + + using FieldMetadata_AndroidGameInterventionListConfig = + ::protozero::proto_utils::FieldMetadata< + 116, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + AndroidGameInterventionListConfig, + DataSourceConfig>; + + static constexpr FieldMetadata_AndroidGameInterventionListConfig kAndroidGameInterventionListConfig{}; + template T* set_android_game_intervention_list_config() { + return BeginNestedMessage(116); + } + + void set_android_game_intervention_list_config_raw(const std::string& raw) { + return AppendBytes(116, raw.data(), raw.size()); + } + + + using FieldMetadata_PackagesListConfig = + ::protozero::proto_utils::FieldMetadata< + 109, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + PackagesListConfig, + DataSourceConfig>; + + static constexpr FieldMetadata_PackagesListConfig kPackagesListConfig{}; + template T* set_packages_list_config() { + return BeginNestedMessage(109); + } + + void set_packages_list_config_raw(const std::string& raw) { + return AppendBytes(109, raw.data(), raw.size()); + } + + + using FieldMetadata_PerfEventConfig = + ::protozero::proto_utils::FieldMetadata< + 111, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + PerfEventConfig, + DataSourceConfig>; + + static constexpr FieldMetadata_PerfEventConfig kPerfEventConfig{}; + template T* set_perf_event_config() { + return BeginNestedMessage(111); + } + + void set_perf_event_config_raw(const std::string& raw) { + return AppendBytes(111, raw.data(), raw.size()); + } + + + using FieldMetadata_VulkanMemoryConfig = + ::protozero::proto_utils::FieldMetadata< + 112, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + VulkanMemoryConfig, + DataSourceConfig>; + + static constexpr FieldMetadata_VulkanMemoryConfig kVulkanMemoryConfig{}; + template T* set_vulkan_memory_config() { + return BeginNestedMessage(112); + } + + void set_vulkan_memory_config_raw(const std::string& raw) { + return AppendBytes(112, raw.data(), raw.size()); + } + + + using FieldMetadata_TrackEventConfig = + ::protozero::proto_utils::FieldMetadata< + 113, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TrackEventConfig, + DataSourceConfig>; + + static constexpr FieldMetadata_TrackEventConfig kTrackEventConfig{}; + template T* set_track_event_config() { + return BeginNestedMessage(113); + } + + void set_track_event_config_raw(const std::string& raw) { + return AppendBytes(113, raw.data(), raw.size()); + } + + + using FieldMetadata_AndroidPolledStateConfig = + ::protozero::proto_utils::FieldMetadata< + 114, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + AndroidPolledStateConfig, + DataSourceConfig>; + + static constexpr FieldMetadata_AndroidPolledStateConfig kAndroidPolledStateConfig{}; + template T* set_android_polled_state_config() { + return BeginNestedMessage(114); + } + + void set_android_polled_state_config_raw(const std::string& raw) { + return AppendBytes(114, raw.data(), raw.size()); + } + + + using FieldMetadata_AndroidSystemPropertyConfig = + ::protozero::proto_utils::FieldMetadata< + 118, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + AndroidSystemPropertyConfig, + DataSourceConfig>; + + static constexpr FieldMetadata_AndroidSystemPropertyConfig kAndroidSystemPropertyConfig{}; + template T* set_android_system_property_config() { + return BeginNestedMessage(118); + } + + void set_android_system_property_config_raw(const std::string& raw) { + return AppendBytes(118, raw.data(), raw.size()); + } + + + using FieldMetadata_StatsdTracingConfig = + ::protozero::proto_utils::FieldMetadata< + 117, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + StatsdTracingConfig, + DataSourceConfig>; + + static constexpr FieldMetadata_StatsdTracingConfig kStatsdTracingConfig{}; + template T* set_statsd_tracing_config() { + return BeginNestedMessage(117); + } + + void set_statsd_tracing_config_raw(const std::string& raw) { + return AppendBytes(117, raw.data(), raw.size()); + } + + + using FieldMetadata_SystemInfoConfig = + ::protozero::proto_utils::FieldMetadata< + 119, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + SystemInfoConfig, + DataSourceConfig>; + + static constexpr FieldMetadata_SystemInfoConfig kSystemInfoConfig{}; + template T* set_system_info_config() { + return BeginNestedMessage(119); + } + + + using FieldMetadata_ChromeConfig = + ::protozero::proto_utils::FieldMetadata< + 101, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ChromeConfig, + DataSourceConfig>; + + static constexpr FieldMetadata_ChromeConfig kChromeConfig{}; + template T* set_chrome_config() { + return BeginNestedMessage(101); + } + + + using FieldMetadata_V8Config = + ::protozero::proto_utils::FieldMetadata< + 127, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + V8Config, + DataSourceConfig>; + + static constexpr FieldMetadata_V8Config kV8Config{}; + template T* set_v8_config() { + return BeginNestedMessage(127); + } + + void set_v8_config_raw(const std::string& raw) { + return AppendBytes(127, raw.data(), raw.size()); + } + + + using FieldMetadata_InterceptorConfig = + ::protozero::proto_utils::FieldMetadata< + 115, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + InterceptorConfig, + DataSourceConfig>; + + static constexpr FieldMetadata_InterceptorConfig kInterceptorConfig{}; + template T* set_interceptor_config() { + return BeginNestedMessage(115); + } + + + using FieldMetadata_NetworkPacketTraceConfig = + ::protozero::proto_utils::FieldMetadata< + 120, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + NetworkPacketTraceConfig, + DataSourceConfig>; + + static constexpr FieldMetadata_NetworkPacketTraceConfig kNetworkPacketTraceConfig{}; + template T* set_network_packet_trace_config() { + return BeginNestedMessage(120); + } + + void set_network_packet_trace_config_raw(const std::string& raw) { + return AppendBytes(120, raw.data(), raw.size()); + } + + + using FieldMetadata_SurfaceflingerLayersConfig = + ::protozero::proto_utils::FieldMetadata< + 121, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + SurfaceFlingerLayersConfig, + DataSourceConfig>; + + static constexpr FieldMetadata_SurfaceflingerLayersConfig kSurfaceflingerLayersConfig{}; + template T* set_surfaceflinger_layers_config() { + return BeginNestedMessage(121); + } + + void set_surfaceflinger_layers_config_raw(const std::string& raw) { + return AppendBytes(121, raw.data(), raw.size()); + } + + + using FieldMetadata_SurfaceflingerTransactionsConfig = + ::protozero::proto_utils::FieldMetadata< + 123, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + SurfaceFlingerTransactionsConfig, + DataSourceConfig>; + + static constexpr FieldMetadata_SurfaceflingerTransactionsConfig kSurfaceflingerTransactionsConfig{}; + template T* set_surfaceflinger_transactions_config() { + return BeginNestedMessage(123); + } + + void set_surfaceflinger_transactions_config_raw(const std::string& raw) { + return AppendBytes(123, raw.data(), raw.size()); + } + + + using FieldMetadata_AndroidSdkSyspropGuardConfig = + ::protozero::proto_utils::FieldMetadata< + 124, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + AndroidSdkSyspropGuardConfig, + DataSourceConfig>; + + static constexpr FieldMetadata_AndroidSdkSyspropGuardConfig kAndroidSdkSyspropGuardConfig{}; + template T* set_android_sdk_sysprop_guard_config() { + return BeginNestedMessage(124); + } + + void set_android_sdk_sysprop_guard_config_raw(const std::string& raw) { + return AppendBytes(124, raw.data(), raw.size()); + } + + + using FieldMetadata_EtwConfig = + ::protozero::proto_utils::FieldMetadata< + 125, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + EtwConfig, + DataSourceConfig>; + + static constexpr FieldMetadata_EtwConfig kEtwConfig{}; + template T* set_etw_config() { + return BeginNestedMessage(125); + } + + void set_etw_config_raw(const std::string& raw) { + return AppendBytes(125, raw.data(), raw.size()); + } + + + using FieldMetadata_ProtologConfig = + ::protozero::proto_utils::FieldMetadata< + 126, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ProtoLogConfig, + DataSourceConfig>; + + static constexpr FieldMetadata_ProtologConfig kProtologConfig{}; + template T* set_protolog_config() { + return BeginNestedMessage(126); + } + + void set_protolog_config_raw(const std::string& raw) { + return AppendBytes(126, raw.data(), raw.size()); + } + + + using FieldMetadata_AndroidInputEventConfig = + ::protozero::proto_utils::FieldMetadata< + 128, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + AndroidInputEventConfig, + DataSourceConfig>; + + static constexpr FieldMetadata_AndroidInputEventConfig kAndroidInputEventConfig{}; + template T* set_android_input_event_config() { + return BeginNestedMessage(128); + } + + void set_android_input_event_config_raw(const std::string& raw) { + return AppendBytes(128, raw.data(), raw.size()); + } + + + using FieldMetadata_LegacyConfig = + ::protozero::proto_utils::FieldMetadata< + 1000, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + DataSourceConfig>; + + static constexpr FieldMetadata_LegacyConfig kLegacyConfig{}; + void set_legacy_config(const char* data, size_t size) { + AppendBytes(FieldMetadata_LegacyConfig::kFieldId, data, size); + } + void set_legacy_config(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_LegacyConfig::kFieldId, chars.data, chars.size); + } + void set_legacy_config(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_LegacyConfig::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ForTesting = + ::protozero::proto_utils::FieldMetadata< + 1001, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TestConfig, + DataSourceConfig>; + + static constexpr FieldMetadata_ForTesting kForTesting{}; + template T* set_for_testing() { + return BeginNestedMessage(1001); + } + +}; + +class TrackEventConfig_Decoder : public ::protozero::TypedProtoDecoder { + public: + TrackEventConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TrackEventConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TrackEventConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_disabled_categories() const { return at<1>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstChars> disabled_categories() const { return GetRepeated<::protozero::ConstChars>(1); } + bool has_enabled_categories() const { return at<2>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstChars> enabled_categories() const { return GetRepeated<::protozero::ConstChars>(2); } + bool has_disabled_tags() const { return at<3>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstChars> disabled_tags() const { return GetRepeated<::protozero::ConstChars>(3); } + bool has_enabled_tags() const { return at<4>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstChars> enabled_tags() const { return GetRepeated<::protozero::ConstChars>(4); } + bool has_disable_incremental_timestamps() const { return at<5>().valid(); } + bool disable_incremental_timestamps() const { return at<5>().as_bool(); } + bool has_timestamp_unit_multiplier() const { return at<6>().valid(); } + uint64_t timestamp_unit_multiplier() const { return at<6>().as_uint64(); } + bool has_filter_debug_annotations() const { return at<7>().valid(); } + bool filter_debug_annotations() const { return at<7>().as_bool(); } + bool has_enable_thread_time_sampling() const { return at<8>().valid(); } + bool enable_thread_time_sampling() const { return at<8>().as_bool(); } + bool has_filter_dynamic_event_names() const { return at<9>().valid(); } + bool filter_dynamic_event_names() const { return at<9>().as_bool(); } +}; + +class TrackEventConfig : public ::protozero::Message { + public: + using Decoder = TrackEventConfig_Decoder; + enum : int32_t { + kDisabledCategoriesFieldNumber = 1, + kEnabledCategoriesFieldNumber = 2, + kDisabledTagsFieldNumber = 3, + kEnabledTagsFieldNumber = 4, + kDisableIncrementalTimestampsFieldNumber = 5, + kTimestampUnitMultiplierFieldNumber = 6, + kFilterDebugAnnotationsFieldNumber = 7, + kEnableThreadTimeSamplingFieldNumber = 8, + kFilterDynamicEventNamesFieldNumber = 9, + }; + static constexpr const char* GetName() { return ".perfetto.protos.TrackEventConfig"; } + + + using FieldMetadata_DisabledCategories = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + TrackEventConfig>; + + static constexpr FieldMetadata_DisabledCategories kDisabledCategories{}; + void add_disabled_categories(const char* data, size_t size) { + AppendBytes(FieldMetadata_DisabledCategories::kFieldId, data, size); + } + void add_disabled_categories(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_DisabledCategories::kFieldId, chars.data, chars.size); + } + void add_disabled_categories(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_DisabledCategories::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_EnabledCategories = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + TrackEventConfig>; + + static constexpr FieldMetadata_EnabledCategories kEnabledCategories{}; + void add_enabled_categories(const char* data, size_t size) { + AppendBytes(FieldMetadata_EnabledCategories::kFieldId, data, size); + } + void add_enabled_categories(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_EnabledCategories::kFieldId, chars.data, chars.size); + } + void add_enabled_categories(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_EnabledCategories::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DisabledTags = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + TrackEventConfig>; + + static constexpr FieldMetadata_DisabledTags kDisabledTags{}; + void add_disabled_tags(const char* data, size_t size) { + AppendBytes(FieldMetadata_DisabledTags::kFieldId, data, size); + } + void add_disabled_tags(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_DisabledTags::kFieldId, chars.data, chars.size); + } + void add_disabled_tags(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_DisabledTags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_EnabledTags = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + TrackEventConfig>; + + static constexpr FieldMetadata_EnabledTags kEnabledTags{}; + void add_enabled_tags(const char* data, size_t size) { + AppendBytes(FieldMetadata_EnabledTags::kFieldId, data, size); + } + void add_enabled_tags(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_EnabledTags::kFieldId, chars.data, chars.size); + } + void add_enabled_tags(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_EnabledTags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DisableIncrementalTimestamps = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + TrackEventConfig>; + + static constexpr FieldMetadata_DisableIncrementalTimestamps kDisableIncrementalTimestamps{}; + void set_disable_incremental_timestamps(bool value) { + static constexpr uint32_t field_id = FieldMetadata_DisableIncrementalTimestamps::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TimestampUnitMultiplier = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TrackEventConfig>; + + static constexpr FieldMetadata_TimestampUnitMultiplier kTimestampUnitMultiplier{}; + void set_timestamp_unit_multiplier(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_TimestampUnitMultiplier::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FilterDebugAnnotations = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + TrackEventConfig>; + + static constexpr FieldMetadata_FilterDebugAnnotations kFilterDebugAnnotations{}; + void set_filter_debug_annotations(bool value) { + static constexpr uint32_t field_id = FieldMetadata_FilterDebugAnnotations::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_EnableThreadTimeSampling = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + TrackEventConfig>; + + static constexpr FieldMetadata_EnableThreadTimeSampling kEnableThreadTimeSampling{}; + void set_enable_thread_time_sampling(bool value) { + static constexpr uint32_t field_id = FieldMetadata_EnableThreadTimeSampling::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FilterDynamicEventNames = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + TrackEventConfig>; + + static constexpr FieldMetadata_FilterDynamicEventNames kFilterDynamicEventNames{}; + void set_filter_dynamic_event_names(bool value) { + static constexpr uint32_t field_id = FieldMetadata_FilterDynamicEventNames::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } +}; + +class TestConfig_Decoder : public ::protozero::TypedProtoDecoder { + public: + TestConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TestConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TestConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_message_count() const { return at<1>().valid(); } + uint32_t message_count() const { return at<1>().as_uint32(); } + bool has_max_messages_per_second() const { return at<2>().valid(); } + uint32_t max_messages_per_second() const { return at<2>().as_uint32(); } + bool has_seed() const { return at<3>().valid(); } + uint32_t seed() const { return at<3>().as_uint32(); } + bool has_message_size() const { return at<4>().valid(); } + uint32_t message_size() const { return at<4>().as_uint32(); } + bool has_send_batch_on_register() const { return at<5>().valid(); } + bool send_batch_on_register() const { return at<5>().as_bool(); } + bool has_dummy_fields() const { return at<6>().valid(); } + ::protozero::ConstBytes dummy_fields() const { return at<6>().as_bytes(); } +}; + +class TestConfig : public ::protozero::Message { + public: + using Decoder = TestConfig_Decoder; + enum : int32_t { + kMessageCountFieldNumber = 1, + kMaxMessagesPerSecondFieldNumber = 2, + kSeedFieldNumber = 3, + kMessageSizeFieldNumber = 4, + kSendBatchOnRegisterFieldNumber = 5, + kDummyFieldsFieldNumber = 6, + }; + static constexpr const char* GetName() { return ".perfetto.protos.TestConfig"; } + + using DummyFields = ::perfetto::protos::pbzero::TestConfig_DummyFields; + + using FieldMetadata_MessageCount = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + TestConfig>; + + static constexpr FieldMetadata_MessageCount kMessageCount{}; + void set_message_count(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_MessageCount::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_MaxMessagesPerSecond = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + TestConfig>; + + static constexpr FieldMetadata_MaxMessagesPerSecond kMaxMessagesPerSecond{}; + void set_max_messages_per_second(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_MaxMessagesPerSecond::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Seed = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + TestConfig>; + + static constexpr FieldMetadata_Seed kSeed{}; + void set_seed(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Seed::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_MessageSize = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + TestConfig>; + + static constexpr FieldMetadata_MessageSize kMessageSize{}; + void set_message_size(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_MessageSize::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SendBatchOnRegister = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + TestConfig>; + + static constexpr FieldMetadata_SendBatchOnRegister kSendBatchOnRegister{}; + void set_send_batch_on_register(bool value) { + static constexpr uint32_t field_id = FieldMetadata_SendBatchOnRegister::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DummyFields = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TestConfig_DummyFields, + TestConfig>; + + static constexpr FieldMetadata_DummyFields kDummyFields{}; + template T* set_dummy_fields() { + return BeginNestedMessage(6); + } + +}; + +class TestConfig_DummyFields_Decoder : public ::protozero::TypedProtoDecoder { + public: + TestConfig_DummyFields_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TestConfig_DummyFields_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TestConfig_DummyFields_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_field_uint32() const { return at<1>().valid(); } + uint32_t field_uint32() const { return at<1>().as_uint32(); } + bool has_field_int32() const { return at<2>().valid(); } + int32_t field_int32() const { return at<2>().as_int32(); } + bool has_field_uint64() const { return at<3>().valid(); } + uint64_t field_uint64() const { return at<3>().as_uint64(); } + bool has_field_int64() const { return at<4>().valid(); } + int64_t field_int64() const { return at<4>().as_int64(); } + bool has_field_fixed64() const { return at<5>().valid(); } + uint64_t field_fixed64() const { return at<5>().as_uint64(); } + bool has_field_sfixed64() const { return at<6>().valid(); } + int64_t field_sfixed64() const { return at<6>().as_int64(); } + bool has_field_fixed32() const { return at<7>().valid(); } + uint32_t field_fixed32() const { return at<7>().as_uint32(); } + bool has_field_sfixed32() const { return at<8>().valid(); } + int32_t field_sfixed32() const { return at<8>().as_int32(); } + bool has_field_double() const { return at<9>().valid(); } + double field_double() const { return at<9>().as_double(); } + bool has_field_float() const { return at<10>().valid(); } + float field_float() const { return at<10>().as_float(); } + bool has_field_sint64() const { return at<11>().valid(); } + int64_t field_sint64() const { return at<11>().as_sint64(); } + bool has_field_sint32() const { return at<12>().valid(); } + int32_t field_sint32() const { return at<12>().as_sint32(); } + bool has_field_string() const { return at<13>().valid(); } + ::protozero::ConstChars field_string() const { return at<13>().as_string(); } + bool has_field_bytes() const { return at<14>().valid(); } + ::protozero::ConstBytes field_bytes() const { return at<14>().as_bytes(); } +}; + +class TestConfig_DummyFields : public ::protozero::Message { + public: + using Decoder = TestConfig_DummyFields_Decoder; + enum : int32_t { + kFieldUint32FieldNumber = 1, + kFieldInt32FieldNumber = 2, + kFieldUint64FieldNumber = 3, + kFieldInt64FieldNumber = 4, + kFieldFixed64FieldNumber = 5, + kFieldSfixed64FieldNumber = 6, + kFieldFixed32FieldNumber = 7, + kFieldSfixed32FieldNumber = 8, + kFieldDoubleFieldNumber = 9, + kFieldFloatFieldNumber = 10, + kFieldSint64FieldNumber = 11, + kFieldSint32FieldNumber = 12, + kFieldStringFieldNumber = 13, + kFieldBytesFieldNumber = 14, + }; + static constexpr const char* GetName() { return ".perfetto.protos.TestConfig.DummyFields"; } + + + using FieldMetadata_FieldUint32 = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + TestConfig_DummyFields>; + + static constexpr FieldMetadata_FieldUint32 kFieldUint32{}; + void set_field_uint32(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_FieldUint32::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FieldInt32 = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + TestConfig_DummyFields>; + + static constexpr FieldMetadata_FieldInt32 kFieldInt32{}; + void set_field_int32(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_FieldInt32::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FieldUint64 = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TestConfig_DummyFields>; + + static constexpr FieldMetadata_FieldUint64 kFieldUint64{}; + void set_field_uint64(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_FieldUint64::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FieldInt64 = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + TestConfig_DummyFields>; + + static constexpr FieldMetadata_FieldInt64 kFieldInt64{}; + void set_field_int64(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_FieldInt64::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FieldFixed64 = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFixed64, + uint64_t, + TestConfig_DummyFields>; + + static constexpr FieldMetadata_FieldFixed64 kFieldFixed64{}; + void set_field_fixed64(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_FieldFixed64::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFixed64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FieldSfixed64 = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kSfixed64, + int64_t, + TestConfig_DummyFields>; + + static constexpr FieldMetadata_FieldSfixed64 kFieldSfixed64{}; + void set_field_sfixed64(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_FieldSfixed64::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kSfixed64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FieldFixed32 = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFixed32, + uint32_t, + TestConfig_DummyFields>; + + static constexpr FieldMetadata_FieldFixed32 kFieldFixed32{}; + void set_field_fixed32(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_FieldFixed32::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFixed32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FieldSfixed32 = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kSfixed32, + int32_t, + TestConfig_DummyFields>; + + static constexpr FieldMetadata_FieldSfixed32 kFieldSfixed32{}; + void set_field_sfixed32(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_FieldSfixed32::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kSfixed32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FieldDouble = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kDouble, + double, + TestConfig_DummyFields>; + + static constexpr FieldMetadata_FieldDouble kFieldDouble{}; + void set_field_double(double value) { + static constexpr uint32_t field_id = FieldMetadata_FieldDouble::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kDouble> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FieldFloat = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + TestConfig_DummyFields>; + + static constexpr FieldMetadata_FieldFloat kFieldFloat{}; + void set_field_float(float value) { + static constexpr uint32_t field_id = FieldMetadata_FieldFloat::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FieldSint64 = + ::protozero::proto_utils::FieldMetadata< + 11, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kSint64, + int64_t, + TestConfig_DummyFields>; + + static constexpr FieldMetadata_FieldSint64 kFieldSint64{}; + void set_field_sint64(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_FieldSint64::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kSint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FieldSint32 = + ::protozero::proto_utils::FieldMetadata< + 12, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kSint32, + int32_t, + TestConfig_DummyFields>; + + static constexpr FieldMetadata_FieldSint32 kFieldSint32{}; + void set_field_sint32(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_FieldSint32::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kSint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FieldString = + ::protozero::proto_utils::FieldMetadata< + 13, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + TestConfig_DummyFields>; + + static constexpr FieldMetadata_FieldString kFieldString{}; + void set_field_string(const char* data, size_t size) { + AppendBytes(FieldMetadata_FieldString::kFieldId, data, size); + } + void set_field_string(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_FieldString::kFieldId, chars.data, chars.size); + } + void set_field_string(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_FieldString::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FieldBytes = + ::protozero::proto_utils::FieldMetadata< + 14, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBytes, + std::string, + TestConfig_DummyFields>; + + static constexpr FieldMetadata_FieldBytes kFieldBytes{}; + void set_field_bytes(const uint8_t* data, size_t size) { + AppendBytes(FieldMetadata_FieldBytes::kFieldId, data, size); + } + void set_field_bytes(::protozero::ConstBytes bytes) { + AppendBytes(FieldMetadata_FieldBytes::kFieldId, bytes.data, bytes.size); + } + void set_field_bytes(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_FieldBytes::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBytes> + ::Append(*this, field_id, value); + } +}; + +class SystemInfoConfig_Decoder : public ::protozero::TypedProtoDecoder { + public: + SystemInfoConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit SystemInfoConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit SystemInfoConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} +}; + +class SystemInfoConfig : public ::protozero::Message { + public: + using Decoder = SystemInfoConfig_Decoder; + static constexpr const char* GetName() { return ".perfetto.protos.SystemInfoConfig"; } + +}; + +class SysStatsConfig_Decoder : public ::protozero::TypedProtoDecoder { + public: + SysStatsConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit SysStatsConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit SysStatsConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_meminfo_period_ms() const { return at<1>().valid(); } + uint32_t meminfo_period_ms() const { return at<1>().as_uint32(); } + bool has_meminfo_counters() const { return at<2>().valid(); } + ::protozero::RepeatedFieldIterator meminfo_counters() const { return GetRepeated(2); } + bool has_vmstat_period_ms() const { return at<3>().valid(); } + uint32_t vmstat_period_ms() const { return at<3>().as_uint32(); } + bool has_vmstat_counters() const { return at<4>().valid(); } + ::protozero::RepeatedFieldIterator vmstat_counters() const { return GetRepeated(4); } + bool has_stat_period_ms() const { return at<5>().valid(); } + uint32_t stat_period_ms() const { return at<5>().as_uint32(); } + bool has_stat_counters() const { return at<6>().valid(); } + ::protozero::RepeatedFieldIterator stat_counters() const { return GetRepeated(6); } + bool has_devfreq_period_ms() const { return at<7>().valid(); } + uint32_t devfreq_period_ms() const { return at<7>().as_uint32(); } + bool has_cpufreq_period_ms() const { return at<8>().valid(); } + uint32_t cpufreq_period_ms() const { return at<8>().as_uint32(); } + bool has_buddyinfo_period_ms() const { return at<9>().valid(); } + uint32_t buddyinfo_period_ms() const { return at<9>().as_uint32(); } + bool has_diskstat_period_ms() const { return at<10>().valid(); } + uint32_t diskstat_period_ms() const { return at<10>().as_uint32(); } + bool has_psi_period_ms() const { return at<11>().valid(); } + uint32_t psi_period_ms() const { return at<11>().as_uint32(); } +}; + +class SysStatsConfig : public ::protozero::Message { + public: + using Decoder = SysStatsConfig_Decoder; + enum : int32_t { + kMeminfoPeriodMsFieldNumber = 1, + kMeminfoCountersFieldNumber = 2, + kVmstatPeriodMsFieldNumber = 3, + kVmstatCountersFieldNumber = 4, + kStatPeriodMsFieldNumber = 5, + kStatCountersFieldNumber = 6, + kDevfreqPeriodMsFieldNumber = 7, + kCpufreqPeriodMsFieldNumber = 8, + kBuddyinfoPeriodMsFieldNumber = 9, + kDiskstatPeriodMsFieldNumber = 10, + kPsiPeriodMsFieldNumber = 11, + }; + static constexpr const char* GetName() { return ".perfetto.protos.SysStatsConfig"; } + + + using StatCounters = ::perfetto::protos::pbzero::SysStatsConfig_StatCounters; + static inline const char* StatCounters_Name(StatCounters value) { + return ::perfetto::protos::pbzero::SysStatsConfig_StatCounters_Name(value); + } + static inline const StatCounters STAT_UNSPECIFIED = StatCounters::STAT_UNSPECIFIED; + static inline const StatCounters STAT_CPU_TIMES = StatCounters::STAT_CPU_TIMES; + static inline const StatCounters STAT_IRQ_COUNTS = StatCounters::STAT_IRQ_COUNTS; + static inline const StatCounters STAT_SOFTIRQ_COUNTS = StatCounters::STAT_SOFTIRQ_COUNTS; + static inline const StatCounters STAT_FORK_COUNT = StatCounters::STAT_FORK_COUNT; + + using FieldMetadata_MeminfoPeriodMs = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SysStatsConfig>; + + static constexpr FieldMetadata_MeminfoPeriodMs kMeminfoPeriodMs{}; + void set_meminfo_period_ms(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_MeminfoPeriodMs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_MeminfoCounters = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + MeminfoCounters, + SysStatsConfig>; + + static constexpr FieldMetadata_MeminfoCounters kMeminfoCounters{}; + void add_meminfo_counters(MeminfoCounters value) { + static constexpr uint32_t field_id = FieldMetadata_MeminfoCounters::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_VmstatPeriodMs = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SysStatsConfig>; + + static constexpr FieldMetadata_VmstatPeriodMs kVmstatPeriodMs{}; + void set_vmstat_period_ms(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_VmstatPeriodMs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_VmstatCounters = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + VmstatCounters, + SysStatsConfig>; + + static constexpr FieldMetadata_VmstatCounters kVmstatCounters{}; + void add_vmstat_counters(VmstatCounters value) { + static constexpr uint32_t field_id = FieldMetadata_VmstatCounters::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_StatPeriodMs = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SysStatsConfig>; + + static constexpr FieldMetadata_StatPeriodMs kStatPeriodMs{}; + void set_stat_period_ms(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_StatPeriodMs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_StatCounters = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + SysStatsConfig_StatCounters, + SysStatsConfig>; + + static constexpr FieldMetadata_StatCounters kStatCounters{}; + void add_stat_counters(SysStatsConfig_StatCounters value) { + static constexpr uint32_t field_id = FieldMetadata_StatCounters::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DevfreqPeriodMs = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SysStatsConfig>; + + static constexpr FieldMetadata_DevfreqPeriodMs kDevfreqPeriodMs{}; + void set_devfreq_period_ms(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_DevfreqPeriodMs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CpufreqPeriodMs = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SysStatsConfig>; + + static constexpr FieldMetadata_CpufreqPeriodMs kCpufreqPeriodMs{}; + void set_cpufreq_period_ms(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_CpufreqPeriodMs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_BuddyinfoPeriodMs = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SysStatsConfig>; + + static constexpr FieldMetadata_BuddyinfoPeriodMs kBuddyinfoPeriodMs{}; + void set_buddyinfo_period_ms(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_BuddyinfoPeriodMs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DiskstatPeriodMs = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SysStatsConfig>; + + static constexpr FieldMetadata_DiskstatPeriodMs kDiskstatPeriodMs{}; + void set_diskstat_period_ms(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_DiskstatPeriodMs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PsiPeriodMs = + ::protozero::proto_utils::FieldMetadata< + 11, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + SysStatsConfig>; + + static constexpr FieldMetadata_PsiPeriodMs kPsiPeriodMs{}; + void set_psi_period_ms(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_PsiPeriodMs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class StatsdPullAtomConfig_Decoder : public ::protozero::TypedProtoDecoder { + public: + StatsdPullAtomConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit StatsdPullAtomConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit StatsdPullAtomConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_pull_atom_id() const { return at<1>().valid(); } + ::protozero::RepeatedFieldIterator pull_atom_id() const { return GetRepeated(1); } + bool has_raw_pull_atom_id() const { return at<2>().valid(); } + ::protozero::RepeatedFieldIterator raw_pull_atom_id() const { return GetRepeated(2); } + bool has_pull_frequency_ms() const { return at<3>().valid(); } + int32_t pull_frequency_ms() const { return at<3>().as_int32(); } + bool has_packages() const { return at<4>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstChars> packages() const { return GetRepeated<::protozero::ConstChars>(4); } +}; + +class StatsdPullAtomConfig : public ::protozero::Message { + public: + using Decoder = StatsdPullAtomConfig_Decoder; + enum : int32_t { + kPullAtomIdFieldNumber = 1, + kRawPullAtomIdFieldNumber = 2, + kPullFrequencyMsFieldNumber = 3, + kPackagesFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.StatsdPullAtomConfig"; } + + + using FieldMetadata_PullAtomId = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + AtomId, + StatsdPullAtomConfig>; + + static constexpr FieldMetadata_PullAtomId kPullAtomId{}; + void add_pull_atom_id(AtomId value) { + static constexpr uint32_t field_id = FieldMetadata_PullAtomId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_RawPullAtomId = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + StatsdPullAtomConfig>; + + static constexpr FieldMetadata_RawPullAtomId kRawPullAtomId{}; + void add_raw_pull_atom_id(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_RawPullAtomId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PullFrequencyMs = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + StatsdPullAtomConfig>; + + static constexpr FieldMetadata_PullFrequencyMs kPullFrequencyMs{}; + void set_pull_frequency_ms(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_PullFrequencyMs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Packages = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + StatsdPullAtomConfig>; + + static constexpr FieldMetadata_Packages kPackages{}; + void add_packages(const char* data, size_t size) { + AppendBytes(FieldMetadata_Packages::kFieldId, data, size); + } + void add_packages(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Packages::kFieldId, chars.data, chars.size); + } + void add_packages(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Packages::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class StatsdTracingConfig_Decoder : public ::protozero::TypedProtoDecoder { + public: + StatsdTracingConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit StatsdTracingConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit StatsdTracingConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_push_atom_id() const { return at<1>().valid(); } + ::protozero::RepeatedFieldIterator push_atom_id() const { return GetRepeated(1); } + bool has_raw_push_atom_id() const { return at<2>().valid(); } + ::protozero::RepeatedFieldIterator raw_push_atom_id() const { return GetRepeated(2); } + bool has_pull_config() const { return at<3>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> pull_config() const { return GetRepeated<::protozero::ConstBytes>(3); } +}; + +class StatsdTracingConfig : public ::protozero::Message { + public: + using Decoder = StatsdTracingConfig_Decoder; + enum : int32_t { + kPushAtomIdFieldNumber = 1, + kRawPushAtomIdFieldNumber = 2, + kPullConfigFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.StatsdTracingConfig"; } + + + using FieldMetadata_PushAtomId = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + AtomId, + StatsdTracingConfig>; + + static constexpr FieldMetadata_PushAtomId kPushAtomId{}; + void add_push_atom_id(AtomId value) { + static constexpr uint32_t field_id = FieldMetadata_PushAtomId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_RawPushAtomId = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + StatsdTracingConfig>; + + static constexpr FieldMetadata_RawPushAtomId kRawPushAtomId{}; + void add_raw_push_atom_id(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_RawPushAtomId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PullConfig = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + StatsdPullAtomConfig, + StatsdTracingConfig>; + + static constexpr FieldMetadata_PullConfig kPullConfig{}; + template T* add_pull_config() { + return BeginNestedMessage(3); + } + +}; + +class PerfEventConfig_Decoder : public ::protozero::TypedProtoDecoder { + public: + PerfEventConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit PerfEventConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit PerfEventConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_timebase() const { return at<15>().valid(); } + ::protozero::ConstBytes timebase() const { return at<15>().as_bytes(); } + bool has_callstack_sampling() const { return at<16>().valid(); } + ::protozero::ConstBytes callstack_sampling() const { return at<16>().as_bytes(); } + bool has_ring_buffer_read_period_ms() const { return at<8>().valid(); } + uint32_t ring_buffer_read_period_ms() const { return at<8>().as_uint32(); } + bool has_ring_buffer_pages() const { return at<3>().valid(); } + uint32_t ring_buffer_pages() const { return at<3>().as_uint32(); } + bool has_max_enqueued_footprint_kb() const { return at<17>().valid(); } + uint64_t max_enqueued_footprint_kb() const { return at<17>().as_uint64(); } + bool has_max_daemon_memory_kb() const { return at<13>().valid(); } + uint32_t max_daemon_memory_kb() const { return at<13>().as_uint32(); } + bool has_remote_descriptor_timeout_ms() const { return at<9>().valid(); } + uint32_t remote_descriptor_timeout_ms() const { return at<9>().as_uint32(); } + bool has_unwind_state_clear_period_ms() const { return at<10>().valid(); } + uint32_t unwind_state_clear_period_ms() const { return at<10>().as_uint32(); } + bool has_target_installed_by() const { return at<18>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstChars> target_installed_by() const { return GetRepeated<::protozero::ConstChars>(18); } + bool has_all_cpus() const { return at<1>().valid(); } + bool all_cpus() const { return at<1>().as_bool(); } + bool has_sampling_frequency() const { return at<2>().valid(); } + uint32_t sampling_frequency() const { return at<2>().as_uint32(); } + bool has_kernel_frames() const { return at<12>().valid(); } + bool kernel_frames() const { return at<12>().as_bool(); } + bool has_target_pid() const { return at<4>().valid(); } + ::protozero::RepeatedFieldIterator target_pid() const { return GetRepeated(4); } + bool has_target_cmdline() const { return at<5>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstChars> target_cmdline() const { return GetRepeated<::protozero::ConstChars>(5); } + bool has_exclude_pid() const { return at<6>().valid(); } + ::protozero::RepeatedFieldIterator exclude_pid() const { return GetRepeated(6); } + bool has_exclude_cmdline() const { return at<7>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstChars> exclude_cmdline() const { return GetRepeated<::protozero::ConstChars>(7); } + bool has_additional_cmdline_count() const { return at<11>().valid(); } + uint32_t additional_cmdline_count() const { return at<11>().as_uint32(); } +}; + +class PerfEventConfig : public ::protozero::Message { + public: + using Decoder = PerfEventConfig_Decoder; + enum : int32_t { + kTimebaseFieldNumber = 15, + kCallstackSamplingFieldNumber = 16, + kRingBufferReadPeriodMsFieldNumber = 8, + kRingBufferPagesFieldNumber = 3, + kMaxEnqueuedFootprintKbFieldNumber = 17, + kMaxDaemonMemoryKbFieldNumber = 13, + kRemoteDescriptorTimeoutMsFieldNumber = 9, + kUnwindStateClearPeriodMsFieldNumber = 10, + kTargetInstalledByFieldNumber = 18, + kAllCpusFieldNumber = 1, + kSamplingFrequencyFieldNumber = 2, + kKernelFramesFieldNumber = 12, + kTargetPidFieldNumber = 4, + kTargetCmdlineFieldNumber = 5, + kExcludePidFieldNumber = 6, + kExcludeCmdlineFieldNumber = 7, + kAdditionalCmdlineCountFieldNumber = 11, + }; + static constexpr const char* GetName() { return ".perfetto.protos.PerfEventConfig"; } + + using CallstackSampling = ::perfetto::protos::pbzero::PerfEventConfig_CallstackSampling; + using Scope = ::perfetto::protos::pbzero::PerfEventConfig_Scope; + + using UnwindMode = ::perfetto::protos::pbzero::PerfEventConfig_UnwindMode; + static inline const char* UnwindMode_Name(UnwindMode value) { + return ::perfetto::protos::pbzero::PerfEventConfig_UnwindMode_Name(value); + } + static inline const UnwindMode UNWIND_UNKNOWN = UnwindMode::UNWIND_UNKNOWN; + static inline const UnwindMode UNWIND_SKIP = UnwindMode::UNWIND_SKIP; + static inline const UnwindMode UNWIND_DWARF = UnwindMode::UNWIND_DWARF; + + using FieldMetadata_Timebase = + ::protozero::proto_utils::FieldMetadata< + 15, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + PerfEvents_Timebase, + PerfEventConfig>; + + static constexpr FieldMetadata_Timebase kTimebase{}; + template T* set_timebase() { + return BeginNestedMessage(15); + } + + + using FieldMetadata_CallstackSampling = + ::protozero::proto_utils::FieldMetadata< + 16, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + PerfEventConfig_CallstackSampling, + PerfEventConfig>; + + static constexpr FieldMetadata_CallstackSampling kCallstackSampling{}; + template T* set_callstack_sampling() { + return BeginNestedMessage(16); + } + + + using FieldMetadata_RingBufferReadPeriodMs = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + PerfEventConfig>; + + static constexpr FieldMetadata_RingBufferReadPeriodMs kRingBufferReadPeriodMs{}; + void set_ring_buffer_read_period_ms(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_RingBufferReadPeriodMs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_RingBufferPages = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + PerfEventConfig>; + + static constexpr FieldMetadata_RingBufferPages kRingBufferPages{}; + void set_ring_buffer_pages(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_RingBufferPages::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_MaxEnqueuedFootprintKb = + ::protozero::proto_utils::FieldMetadata< + 17, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + PerfEventConfig>; + + static constexpr FieldMetadata_MaxEnqueuedFootprintKb kMaxEnqueuedFootprintKb{}; + void set_max_enqueued_footprint_kb(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_MaxEnqueuedFootprintKb::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_MaxDaemonMemoryKb = + ::protozero::proto_utils::FieldMetadata< + 13, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + PerfEventConfig>; + + static constexpr FieldMetadata_MaxDaemonMemoryKb kMaxDaemonMemoryKb{}; + void set_max_daemon_memory_kb(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_MaxDaemonMemoryKb::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_RemoteDescriptorTimeoutMs = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + PerfEventConfig>; + + static constexpr FieldMetadata_RemoteDescriptorTimeoutMs kRemoteDescriptorTimeoutMs{}; + void set_remote_descriptor_timeout_ms(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_RemoteDescriptorTimeoutMs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_UnwindStateClearPeriodMs = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + PerfEventConfig>; + + static constexpr FieldMetadata_UnwindStateClearPeriodMs kUnwindStateClearPeriodMs{}; + void set_unwind_state_clear_period_ms(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_UnwindStateClearPeriodMs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TargetInstalledBy = + ::protozero::proto_utils::FieldMetadata< + 18, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + PerfEventConfig>; + + static constexpr FieldMetadata_TargetInstalledBy kTargetInstalledBy{}; + void add_target_installed_by(const char* data, size_t size) { + AppendBytes(FieldMetadata_TargetInstalledBy::kFieldId, data, size); + } + void add_target_installed_by(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_TargetInstalledBy::kFieldId, chars.data, chars.size); + } + void add_target_installed_by(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_TargetInstalledBy::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_AllCpus = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + PerfEventConfig>; + + static constexpr FieldMetadata_AllCpus kAllCpus{}; + void set_all_cpus(bool value) { + static constexpr uint32_t field_id = FieldMetadata_AllCpus::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SamplingFrequency = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + PerfEventConfig>; + + static constexpr FieldMetadata_SamplingFrequency kSamplingFrequency{}; + void set_sampling_frequency(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_SamplingFrequency::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_KernelFrames = + ::protozero::proto_utils::FieldMetadata< + 12, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + PerfEventConfig>; + + static constexpr FieldMetadata_KernelFrames kKernelFrames{}; + void set_kernel_frames(bool value) { + static constexpr uint32_t field_id = FieldMetadata_KernelFrames::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TargetPid = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + PerfEventConfig>; + + static constexpr FieldMetadata_TargetPid kTargetPid{}; + void add_target_pid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TargetPid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TargetCmdline = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + PerfEventConfig>; + + static constexpr FieldMetadata_TargetCmdline kTargetCmdline{}; + void add_target_cmdline(const char* data, size_t size) { + AppendBytes(FieldMetadata_TargetCmdline::kFieldId, data, size); + } + void add_target_cmdline(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_TargetCmdline::kFieldId, chars.data, chars.size); + } + void add_target_cmdline(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_TargetCmdline::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ExcludePid = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + PerfEventConfig>; + + static constexpr FieldMetadata_ExcludePid kExcludePid{}; + void add_exclude_pid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ExcludePid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ExcludeCmdline = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + PerfEventConfig>; + + static constexpr FieldMetadata_ExcludeCmdline kExcludeCmdline{}; + void add_exclude_cmdline(const char* data, size_t size) { + AppendBytes(FieldMetadata_ExcludeCmdline::kFieldId, data, size); + } + void add_exclude_cmdline(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_ExcludeCmdline::kFieldId, chars.data, chars.size); + } + void add_exclude_cmdline(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_ExcludeCmdline::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_AdditionalCmdlineCount = + ::protozero::proto_utils::FieldMetadata< + 11, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + PerfEventConfig>; + + static constexpr FieldMetadata_AdditionalCmdlineCount kAdditionalCmdlineCount{}; + void set_additional_cmdline_count(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_AdditionalCmdlineCount::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class PerfEventConfig_Scope_Decoder : public ::protozero::TypedProtoDecoder { + public: + PerfEventConfig_Scope_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit PerfEventConfig_Scope_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit PerfEventConfig_Scope_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_target_pid() const { return at<1>().valid(); } + ::protozero::RepeatedFieldIterator target_pid() const { return GetRepeated(1); } + bool has_target_cmdline() const { return at<2>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstChars> target_cmdline() const { return GetRepeated<::protozero::ConstChars>(2); } + bool has_exclude_pid() const { return at<3>().valid(); } + ::protozero::RepeatedFieldIterator exclude_pid() const { return GetRepeated(3); } + bool has_exclude_cmdline() const { return at<4>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstChars> exclude_cmdline() const { return GetRepeated<::protozero::ConstChars>(4); } + bool has_additional_cmdline_count() const { return at<5>().valid(); } + uint32_t additional_cmdline_count() const { return at<5>().as_uint32(); } + bool has_process_shard_count() const { return at<6>().valid(); } + uint32_t process_shard_count() const { return at<6>().as_uint32(); } +}; + +class PerfEventConfig_Scope : public ::protozero::Message { + public: + using Decoder = PerfEventConfig_Scope_Decoder; + enum : int32_t { + kTargetPidFieldNumber = 1, + kTargetCmdlineFieldNumber = 2, + kExcludePidFieldNumber = 3, + kExcludeCmdlineFieldNumber = 4, + kAdditionalCmdlineCountFieldNumber = 5, + kProcessShardCountFieldNumber = 6, + }; + static constexpr const char* GetName() { return ".perfetto.protos.PerfEventConfig.Scope"; } + + + using FieldMetadata_TargetPid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + PerfEventConfig_Scope>; + + static constexpr FieldMetadata_TargetPid kTargetPid{}; + void add_target_pid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TargetPid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TargetCmdline = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + PerfEventConfig_Scope>; + + static constexpr FieldMetadata_TargetCmdline kTargetCmdline{}; + void add_target_cmdline(const char* data, size_t size) { + AppendBytes(FieldMetadata_TargetCmdline::kFieldId, data, size); + } + void add_target_cmdline(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_TargetCmdline::kFieldId, chars.data, chars.size); + } + void add_target_cmdline(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_TargetCmdline::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ExcludePid = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + PerfEventConfig_Scope>; + + static constexpr FieldMetadata_ExcludePid kExcludePid{}; + void add_exclude_pid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ExcludePid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ExcludeCmdline = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + PerfEventConfig_Scope>; + + static constexpr FieldMetadata_ExcludeCmdline kExcludeCmdline{}; + void add_exclude_cmdline(const char* data, size_t size) { + AppendBytes(FieldMetadata_ExcludeCmdline::kFieldId, data, size); + } + void add_exclude_cmdline(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_ExcludeCmdline::kFieldId, chars.data, chars.size); + } + void add_exclude_cmdline(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_ExcludeCmdline::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_AdditionalCmdlineCount = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + PerfEventConfig_Scope>; + + static constexpr FieldMetadata_AdditionalCmdlineCount kAdditionalCmdlineCount{}; + void set_additional_cmdline_count(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_AdditionalCmdlineCount::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ProcessShardCount = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + PerfEventConfig_Scope>; + + static constexpr FieldMetadata_ProcessShardCount kProcessShardCount{}; + void set_process_shard_count(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ProcessShardCount::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class PerfEventConfig_CallstackSampling_Decoder : public ::protozero::TypedProtoDecoder { + public: + PerfEventConfig_CallstackSampling_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit PerfEventConfig_CallstackSampling_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit PerfEventConfig_CallstackSampling_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_scope() const { return at<1>().valid(); } + ::protozero::ConstBytes scope() const { return at<1>().as_bytes(); } + bool has_kernel_frames() const { return at<2>().valid(); } + bool kernel_frames() const { return at<2>().as_bool(); } + bool has_user_frames() const { return at<3>().valid(); } + int32_t user_frames() const { return at<3>().as_int32(); } +}; + +class PerfEventConfig_CallstackSampling : public ::protozero::Message { + public: + using Decoder = PerfEventConfig_CallstackSampling_Decoder; + enum : int32_t { + kScopeFieldNumber = 1, + kKernelFramesFieldNumber = 2, + kUserFramesFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.PerfEventConfig.CallstackSampling"; } + + + using FieldMetadata_Scope = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + PerfEventConfig_Scope, + PerfEventConfig_CallstackSampling>; + + static constexpr FieldMetadata_Scope kScope{}; + template T* set_scope() { + return BeginNestedMessage(1); + } + + + using FieldMetadata_KernelFrames = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + PerfEventConfig_CallstackSampling>; + + static constexpr FieldMetadata_KernelFrames kKernelFrames{}; + void set_kernel_frames(bool value) { + static constexpr uint32_t field_id = FieldMetadata_KernelFrames::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_UserFrames = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + PerfEventConfig_UnwindMode, + PerfEventConfig_CallstackSampling>; + + static constexpr FieldMetadata_UserFrames kUserFrames{}; + void set_user_frames(PerfEventConfig_UnwindMode value) { + static constexpr uint32_t field_id = FieldMetadata_UserFrames::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } +}; + +class PerfEvents_Decoder : public ::protozero::TypedProtoDecoder { + public: + PerfEvents_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit PerfEvents_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit PerfEvents_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} +}; + +class PerfEvents : public ::protozero::Message { + public: + using Decoder = PerfEvents_Decoder; + static constexpr const char* GetName() { return ".perfetto.protos.PerfEvents"; } + + using Timebase = ::perfetto::protos::pbzero::PerfEvents_Timebase; + using Tracepoint = ::perfetto::protos::pbzero::PerfEvents_Tracepoint; + using RawEvent = ::perfetto::protos::pbzero::PerfEvents_RawEvent; + + using Counter = ::perfetto::protos::pbzero::PerfEvents_Counter; + static inline const char* Counter_Name(Counter value) { + return ::perfetto::protos::pbzero::PerfEvents_Counter_Name(value); + } + + using PerfClock = ::perfetto::protos::pbzero::PerfEvents_PerfClock; + static inline const char* PerfClock_Name(PerfClock value) { + return ::perfetto::protos::pbzero::PerfEvents_PerfClock_Name(value); + } + static inline const Counter UNKNOWN_COUNTER = Counter::UNKNOWN_COUNTER; + static inline const Counter SW_CPU_CLOCK = Counter::SW_CPU_CLOCK; + static inline const Counter SW_PAGE_FAULTS = Counter::SW_PAGE_FAULTS; + static inline const Counter SW_TASK_CLOCK = Counter::SW_TASK_CLOCK; + static inline const Counter SW_CONTEXT_SWITCHES = Counter::SW_CONTEXT_SWITCHES; + static inline const Counter SW_CPU_MIGRATIONS = Counter::SW_CPU_MIGRATIONS; + static inline const Counter SW_PAGE_FAULTS_MIN = Counter::SW_PAGE_FAULTS_MIN; + static inline const Counter SW_PAGE_FAULTS_MAJ = Counter::SW_PAGE_FAULTS_MAJ; + static inline const Counter SW_ALIGNMENT_FAULTS = Counter::SW_ALIGNMENT_FAULTS; + static inline const Counter SW_EMULATION_FAULTS = Counter::SW_EMULATION_FAULTS; + static inline const Counter SW_DUMMY = Counter::SW_DUMMY; + static inline const Counter HW_CPU_CYCLES = Counter::HW_CPU_CYCLES; + static inline const Counter HW_INSTRUCTIONS = Counter::HW_INSTRUCTIONS; + static inline const Counter HW_CACHE_REFERENCES = Counter::HW_CACHE_REFERENCES; + static inline const Counter HW_CACHE_MISSES = Counter::HW_CACHE_MISSES; + static inline const Counter HW_BRANCH_INSTRUCTIONS = Counter::HW_BRANCH_INSTRUCTIONS; + static inline const Counter HW_BRANCH_MISSES = Counter::HW_BRANCH_MISSES; + static inline const Counter HW_BUS_CYCLES = Counter::HW_BUS_CYCLES; + static inline const Counter HW_STALLED_CYCLES_FRONTEND = Counter::HW_STALLED_CYCLES_FRONTEND; + static inline const Counter HW_STALLED_CYCLES_BACKEND = Counter::HW_STALLED_CYCLES_BACKEND; + static inline const Counter HW_REF_CPU_CYCLES = Counter::HW_REF_CPU_CYCLES; + static inline const PerfClock UNKNOWN_PERF_CLOCK = PerfClock::UNKNOWN_PERF_CLOCK; + static inline const PerfClock PERF_CLOCK_REALTIME = PerfClock::PERF_CLOCK_REALTIME; + static inline const PerfClock PERF_CLOCK_MONOTONIC = PerfClock::PERF_CLOCK_MONOTONIC; + static inline const PerfClock PERF_CLOCK_MONOTONIC_RAW = PerfClock::PERF_CLOCK_MONOTONIC_RAW; + static inline const PerfClock PERF_CLOCK_BOOTTIME = PerfClock::PERF_CLOCK_BOOTTIME; +}; + +class PerfEvents_RawEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + PerfEvents_RawEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit PerfEvents_RawEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit PerfEvents_RawEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_type() const { return at<1>().valid(); } + uint32_t type() const { return at<1>().as_uint32(); } + bool has_config() const { return at<2>().valid(); } + uint64_t config() const { return at<2>().as_uint64(); } + bool has_config1() const { return at<3>().valid(); } + uint64_t config1() const { return at<3>().as_uint64(); } + bool has_config2() const { return at<4>().valid(); } + uint64_t config2() const { return at<4>().as_uint64(); } +}; + +class PerfEvents_RawEvent : public ::protozero::Message { + public: + using Decoder = PerfEvents_RawEvent_Decoder; + enum : int32_t { + kTypeFieldNumber = 1, + kConfigFieldNumber = 2, + kConfig1FieldNumber = 3, + kConfig2FieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.PerfEvents.RawEvent"; } + + + using FieldMetadata_Type = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + PerfEvents_RawEvent>; + + static constexpr FieldMetadata_Type kType{}; + void set_type(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Config = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + PerfEvents_RawEvent>; + + static constexpr FieldMetadata_Config kConfig{}; + void set_config(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Config::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Config1 = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + PerfEvents_RawEvent>; + + static constexpr FieldMetadata_Config1 kConfig1{}; + void set_config1(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Config1::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Config2 = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + PerfEvents_RawEvent>; + + static constexpr FieldMetadata_Config2 kConfig2{}; + void set_config2(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Config2::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class PerfEvents_Tracepoint_Decoder : public ::protozero::TypedProtoDecoder { + public: + PerfEvents_Tracepoint_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit PerfEvents_Tracepoint_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit PerfEvents_Tracepoint_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_name() const { return at<1>().valid(); } + ::protozero::ConstChars name() const { return at<1>().as_string(); } + bool has_filter() const { return at<2>().valid(); } + ::protozero::ConstChars filter() const { return at<2>().as_string(); } +}; + +class PerfEvents_Tracepoint : public ::protozero::Message { + public: + using Decoder = PerfEvents_Tracepoint_Decoder; + enum : int32_t { + kNameFieldNumber = 1, + kFilterFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.PerfEvents.Tracepoint"; } + + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + PerfEvents_Tracepoint>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Filter = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + PerfEvents_Tracepoint>; + + static constexpr FieldMetadata_Filter kFilter{}; + void set_filter(const char* data, size_t size) { + AppendBytes(FieldMetadata_Filter::kFieldId, data, size); + } + void set_filter(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Filter::kFieldId, chars.data, chars.size); + } + void set_filter(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Filter::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class PerfEvents_Timebase_Decoder : public ::protozero::TypedProtoDecoder { + public: + PerfEvents_Timebase_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit PerfEvents_Timebase_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit PerfEvents_Timebase_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_frequency() const { return at<2>().valid(); } + uint64_t frequency() const { return at<2>().as_uint64(); } + bool has_period() const { return at<1>().valid(); } + uint64_t period() const { return at<1>().as_uint64(); } + bool has_counter() const { return at<4>().valid(); } + int32_t counter() const { return at<4>().as_int32(); } + bool has_tracepoint() const { return at<3>().valid(); } + ::protozero::ConstBytes tracepoint() const { return at<3>().as_bytes(); } + bool has_raw_event() const { return at<5>().valid(); } + ::protozero::ConstBytes raw_event() const { return at<5>().as_bytes(); } + bool has_timestamp_clock() const { return at<11>().valid(); } + int32_t timestamp_clock() const { return at<11>().as_int32(); } + bool has_name() const { return at<10>().valid(); } + ::protozero::ConstChars name() const { return at<10>().as_string(); } +}; + +class PerfEvents_Timebase : public ::protozero::Message { + public: + using Decoder = PerfEvents_Timebase_Decoder; + enum : int32_t { + kFrequencyFieldNumber = 2, + kPeriodFieldNumber = 1, + kCounterFieldNumber = 4, + kTracepointFieldNumber = 3, + kRawEventFieldNumber = 5, + kTimestampClockFieldNumber = 11, + kNameFieldNumber = 10, + }; + static constexpr const char* GetName() { return ".perfetto.protos.PerfEvents.Timebase"; } + + + using FieldMetadata_Frequency = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + PerfEvents_Timebase>; + + static constexpr FieldMetadata_Frequency kFrequency{}; + void set_frequency(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Frequency::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Period = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + PerfEvents_Timebase>; + + static constexpr FieldMetadata_Period kPeriod{}; + void set_period(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Period::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Counter = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + PerfEvents_Counter, + PerfEvents_Timebase>; + + static constexpr FieldMetadata_Counter kCounter{}; + void set_counter(PerfEvents_Counter value) { + static constexpr uint32_t field_id = FieldMetadata_Counter::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Tracepoint = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + PerfEvents_Tracepoint, + PerfEvents_Timebase>; + + static constexpr FieldMetadata_Tracepoint kTracepoint{}; + template T* set_tracepoint() { + return BeginNestedMessage(3); + } + + + using FieldMetadata_RawEvent = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + PerfEvents_RawEvent, + PerfEvents_Timebase>; + + static constexpr FieldMetadata_RawEvent kRawEvent{}; + template T* set_raw_event() { + return BeginNestedMessage(5); + } + + + using FieldMetadata_TimestampClock = + ::protozero::proto_utils::FieldMetadata< + 11, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + PerfEvents_PerfClock, + PerfEvents_Timebase>; + + static constexpr FieldMetadata_TimestampClock kTimestampClock{}; + void set_timestamp_clock(PerfEvents_PerfClock value) { + static constexpr uint32_t field_id = FieldMetadata_TimestampClock::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + PerfEvents_Timebase>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class JavaHprofConfig_Decoder : public ::protozero::TypedProtoDecoder { + public: + JavaHprofConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit JavaHprofConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit JavaHprofConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_process_cmdline() const { return at<1>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstChars> process_cmdline() const { return GetRepeated<::protozero::ConstChars>(1); } + bool has_pid() const { return at<2>().valid(); } + ::protozero::RepeatedFieldIterator pid() const { return GetRepeated(2); } + bool has_target_installed_by() const { return at<7>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstChars> target_installed_by() const { return GetRepeated<::protozero::ConstChars>(7); } + bool has_continuous_dump_config() const { return at<3>().valid(); } + ::protozero::ConstBytes continuous_dump_config() const { return at<3>().as_bytes(); } + bool has_min_anonymous_memory_kb() const { return at<4>().valid(); } + uint32_t min_anonymous_memory_kb() const { return at<4>().as_uint32(); } + bool has_dump_smaps() const { return at<5>().valid(); } + bool dump_smaps() const { return at<5>().as_bool(); } + bool has_ignored_types() const { return at<6>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstChars> ignored_types() const { return GetRepeated<::protozero::ConstChars>(6); } +}; + +class JavaHprofConfig : public ::protozero::Message { + public: + using Decoder = JavaHprofConfig_Decoder; + enum : int32_t { + kProcessCmdlineFieldNumber = 1, + kPidFieldNumber = 2, + kTargetInstalledByFieldNumber = 7, + kContinuousDumpConfigFieldNumber = 3, + kMinAnonymousMemoryKbFieldNumber = 4, + kDumpSmapsFieldNumber = 5, + kIgnoredTypesFieldNumber = 6, + }; + static constexpr const char* GetName() { return ".perfetto.protos.JavaHprofConfig"; } + + using ContinuousDumpConfig = ::perfetto::protos::pbzero::JavaHprofConfig_ContinuousDumpConfig; + + using FieldMetadata_ProcessCmdline = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + JavaHprofConfig>; + + static constexpr FieldMetadata_ProcessCmdline kProcessCmdline{}; + void add_process_cmdline(const char* data, size_t size) { + AppendBytes(FieldMetadata_ProcessCmdline::kFieldId, data, size); + } + void add_process_cmdline(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_ProcessCmdline::kFieldId, chars.data, chars.size); + } + void add_process_cmdline(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_ProcessCmdline::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pid = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + JavaHprofConfig>; + + static constexpr FieldMetadata_Pid kPid{}; + void add_pid(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TargetInstalledBy = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + JavaHprofConfig>; + + static constexpr FieldMetadata_TargetInstalledBy kTargetInstalledBy{}; + void add_target_installed_by(const char* data, size_t size) { + AppendBytes(FieldMetadata_TargetInstalledBy::kFieldId, data, size); + } + void add_target_installed_by(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_TargetInstalledBy::kFieldId, chars.data, chars.size); + } + void add_target_installed_by(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_TargetInstalledBy::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ContinuousDumpConfig = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + JavaHprofConfig_ContinuousDumpConfig, + JavaHprofConfig>; + + static constexpr FieldMetadata_ContinuousDumpConfig kContinuousDumpConfig{}; + template T* set_continuous_dump_config() { + return BeginNestedMessage(3); + } + + + using FieldMetadata_MinAnonymousMemoryKb = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + JavaHprofConfig>; + + static constexpr FieldMetadata_MinAnonymousMemoryKb kMinAnonymousMemoryKb{}; + void set_min_anonymous_memory_kb(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_MinAnonymousMemoryKb::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DumpSmaps = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + JavaHprofConfig>; + + static constexpr FieldMetadata_DumpSmaps kDumpSmaps{}; + void set_dump_smaps(bool value) { + static constexpr uint32_t field_id = FieldMetadata_DumpSmaps::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_IgnoredTypes = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + JavaHprofConfig>; + + static constexpr FieldMetadata_IgnoredTypes kIgnoredTypes{}; + void add_ignored_types(const char* data, size_t size) { + AppendBytes(FieldMetadata_IgnoredTypes::kFieldId, data, size); + } + void add_ignored_types(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_IgnoredTypes::kFieldId, chars.data, chars.size); + } + void add_ignored_types(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_IgnoredTypes::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class JavaHprofConfig_ContinuousDumpConfig_Decoder : public ::protozero::TypedProtoDecoder { + public: + JavaHprofConfig_ContinuousDumpConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit JavaHprofConfig_ContinuousDumpConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit JavaHprofConfig_ContinuousDumpConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dump_phase_ms() const { return at<1>().valid(); } + uint32_t dump_phase_ms() const { return at<1>().as_uint32(); } + bool has_dump_interval_ms() const { return at<2>().valid(); } + uint32_t dump_interval_ms() const { return at<2>().as_uint32(); } + bool has_scan_pids_only_on_start() const { return at<3>().valid(); } + bool scan_pids_only_on_start() const { return at<3>().as_bool(); } +}; + +class JavaHprofConfig_ContinuousDumpConfig : public ::protozero::Message { + public: + using Decoder = JavaHprofConfig_ContinuousDumpConfig_Decoder; + enum : int32_t { + kDumpPhaseMsFieldNumber = 1, + kDumpIntervalMsFieldNumber = 2, + kScanPidsOnlyOnStartFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.JavaHprofConfig.ContinuousDumpConfig"; } + + + using FieldMetadata_DumpPhaseMs = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + JavaHprofConfig_ContinuousDumpConfig>; + + static constexpr FieldMetadata_DumpPhaseMs kDumpPhaseMs{}; + void set_dump_phase_ms(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_DumpPhaseMs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DumpIntervalMs = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + JavaHprofConfig_ContinuousDumpConfig>; + + static constexpr FieldMetadata_DumpIntervalMs kDumpIntervalMs{}; + void set_dump_interval_ms(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_DumpIntervalMs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ScanPidsOnlyOnStart = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + JavaHprofConfig_ContinuousDumpConfig>; + + static constexpr FieldMetadata_ScanPidsOnlyOnStart kScanPidsOnlyOnStart{}; + void set_scan_pids_only_on_start(bool value) { + static constexpr uint32_t field_id = FieldMetadata_ScanPidsOnlyOnStart::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } +}; + +class HeapprofdConfig_Decoder : public ::protozero::TypedProtoDecoder { + public: + HeapprofdConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit HeapprofdConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit HeapprofdConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_sampling_interval_bytes() const { return at<1>().valid(); } + uint64_t sampling_interval_bytes() const { return at<1>().as_uint64(); } + bool has_adaptive_sampling_shmem_threshold() const { return at<24>().valid(); } + uint64_t adaptive_sampling_shmem_threshold() const { return at<24>().as_uint64(); } + bool has_adaptive_sampling_max_sampling_interval_bytes() const { return at<25>().valid(); } + uint64_t adaptive_sampling_max_sampling_interval_bytes() const { return at<25>().as_uint64(); } + bool has_process_cmdline() const { return at<2>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstChars> process_cmdline() const { return GetRepeated<::protozero::ConstChars>(2); } + bool has_pid() const { return at<4>().valid(); } + ::protozero::RepeatedFieldIterator pid() const { return GetRepeated(4); } + bool has_target_installed_by() const { return at<26>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstChars> target_installed_by() const { return GetRepeated<::protozero::ConstChars>(26); } + bool has_heaps() const { return at<20>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstChars> heaps() const { return GetRepeated<::protozero::ConstChars>(20); } + bool has_exclude_heaps() const { return at<27>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstChars> exclude_heaps() const { return GetRepeated<::protozero::ConstChars>(27); } + bool has_stream_allocations() const { return at<23>().valid(); } + bool stream_allocations() const { return at<23>().as_bool(); } + bool has_heap_sampling_intervals() const { return at<22>().valid(); } + ::protozero::RepeatedFieldIterator heap_sampling_intervals() const { return GetRepeated(22); } + bool has_all_heaps() const { return at<21>().valid(); } + bool all_heaps() const { return at<21>().as_bool(); } + bool has_all() const { return at<5>().valid(); } + bool all() const { return at<5>().as_bool(); } + bool has_min_anonymous_memory_kb() const { return at<15>().valid(); } + uint32_t min_anonymous_memory_kb() const { return at<15>().as_uint32(); } + bool has_max_heapprofd_memory_kb() const { return at<16>().valid(); } + uint32_t max_heapprofd_memory_kb() const { return at<16>().as_uint32(); } + bool has_max_heapprofd_cpu_secs() const { return at<17>().valid(); } + uint64_t max_heapprofd_cpu_secs() const { return at<17>().as_uint64(); } + bool has_skip_symbol_prefix() const { return at<7>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstChars> skip_symbol_prefix() const { return GetRepeated<::protozero::ConstChars>(7); } + bool has_continuous_dump_config() const { return at<6>().valid(); } + ::protozero::ConstBytes continuous_dump_config() const { return at<6>().as_bytes(); } + bool has_shmem_size_bytes() const { return at<8>().valid(); } + uint64_t shmem_size_bytes() const { return at<8>().as_uint64(); } + bool has_block_client() const { return at<9>().valid(); } + bool block_client() const { return at<9>().as_bool(); } + bool has_block_client_timeout_us() const { return at<14>().valid(); } + uint32_t block_client_timeout_us() const { return at<14>().as_uint32(); } + bool has_no_startup() const { return at<10>().valid(); } + bool no_startup() const { return at<10>().as_bool(); } + bool has_no_running() const { return at<11>().valid(); } + bool no_running() const { return at<11>().as_bool(); } + bool has_dump_at_max() const { return at<13>().valid(); } + bool dump_at_max() const { return at<13>().as_bool(); } + bool has_disable_fork_teardown() const { return at<18>().valid(); } + bool disable_fork_teardown() const { return at<18>().as_bool(); } + bool has_disable_vfork_detection() const { return at<19>().valid(); } + bool disable_vfork_detection() const { return at<19>().as_bool(); } +}; + +class HeapprofdConfig : public ::protozero::Message { + public: + using Decoder = HeapprofdConfig_Decoder; + enum : int32_t { + kSamplingIntervalBytesFieldNumber = 1, + kAdaptiveSamplingShmemThresholdFieldNumber = 24, + kAdaptiveSamplingMaxSamplingIntervalBytesFieldNumber = 25, + kProcessCmdlineFieldNumber = 2, + kPidFieldNumber = 4, + kTargetInstalledByFieldNumber = 26, + kHeapsFieldNumber = 20, + kExcludeHeapsFieldNumber = 27, + kStreamAllocationsFieldNumber = 23, + kHeapSamplingIntervalsFieldNumber = 22, + kAllHeapsFieldNumber = 21, + kAllFieldNumber = 5, + kMinAnonymousMemoryKbFieldNumber = 15, + kMaxHeapprofdMemoryKbFieldNumber = 16, + kMaxHeapprofdCpuSecsFieldNumber = 17, + kSkipSymbolPrefixFieldNumber = 7, + kContinuousDumpConfigFieldNumber = 6, + kShmemSizeBytesFieldNumber = 8, + kBlockClientFieldNumber = 9, + kBlockClientTimeoutUsFieldNumber = 14, + kNoStartupFieldNumber = 10, + kNoRunningFieldNumber = 11, + kDumpAtMaxFieldNumber = 13, + kDisableForkTeardownFieldNumber = 18, + kDisableVforkDetectionFieldNumber = 19, + }; + static constexpr const char* GetName() { return ".perfetto.protos.HeapprofdConfig"; } + + using ContinuousDumpConfig = ::perfetto::protos::pbzero::HeapprofdConfig_ContinuousDumpConfig; + + using FieldMetadata_SamplingIntervalBytes = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + HeapprofdConfig>; + + static constexpr FieldMetadata_SamplingIntervalBytes kSamplingIntervalBytes{}; + void set_sampling_interval_bytes(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_SamplingIntervalBytes::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_AdaptiveSamplingShmemThreshold = + ::protozero::proto_utils::FieldMetadata< + 24, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + HeapprofdConfig>; + + static constexpr FieldMetadata_AdaptiveSamplingShmemThreshold kAdaptiveSamplingShmemThreshold{}; + void set_adaptive_sampling_shmem_threshold(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_AdaptiveSamplingShmemThreshold::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_AdaptiveSamplingMaxSamplingIntervalBytes = + ::protozero::proto_utils::FieldMetadata< + 25, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + HeapprofdConfig>; + + static constexpr FieldMetadata_AdaptiveSamplingMaxSamplingIntervalBytes kAdaptiveSamplingMaxSamplingIntervalBytes{}; + void set_adaptive_sampling_max_sampling_interval_bytes(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_AdaptiveSamplingMaxSamplingIntervalBytes::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ProcessCmdline = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + HeapprofdConfig>; + + static constexpr FieldMetadata_ProcessCmdline kProcessCmdline{}; + void add_process_cmdline(const char* data, size_t size) { + AppendBytes(FieldMetadata_ProcessCmdline::kFieldId, data, size); + } + void add_process_cmdline(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_ProcessCmdline::kFieldId, chars.data, chars.size); + } + void add_process_cmdline(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_ProcessCmdline::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pid = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + HeapprofdConfig>; + + static constexpr FieldMetadata_Pid kPid{}; + void add_pid(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TargetInstalledBy = + ::protozero::proto_utils::FieldMetadata< + 26, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + HeapprofdConfig>; + + static constexpr FieldMetadata_TargetInstalledBy kTargetInstalledBy{}; + void add_target_installed_by(const char* data, size_t size) { + AppendBytes(FieldMetadata_TargetInstalledBy::kFieldId, data, size); + } + void add_target_installed_by(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_TargetInstalledBy::kFieldId, chars.data, chars.size); + } + void add_target_installed_by(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_TargetInstalledBy::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Heaps = + ::protozero::proto_utils::FieldMetadata< + 20, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + HeapprofdConfig>; + + static constexpr FieldMetadata_Heaps kHeaps{}; + void add_heaps(const char* data, size_t size) { + AppendBytes(FieldMetadata_Heaps::kFieldId, data, size); + } + void add_heaps(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Heaps::kFieldId, chars.data, chars.size); + } + void add_heaps(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Heaps::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ExcludeHeaps = + ::protozero::proto_utils::FieldMetadata< + 27, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + HeapprofdConfig>; + + static constexpr FieldMetadata_ExcludeHeaps kExcludeHeaps{}; + void add_exclude_heaps(const char* data, size_t size) { + AppendBytes(FieldMetadata_ExcludeHeaps::kFieldId, data, size); + } + void add_exclude_heaps(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_ExcludeHeaps::kFieldId, chars.data, chars.size); + } + void add_exclude_heaps(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_ExcludeHeaps::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_StreamAllocations = + ::protozero::proto_utils::FieldMetadata< + 23, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + HeapprofdConfig>; + + static constexpr FieldMetadata_StreamAllocations kStreamAllocations{}; + void set_stream_allocations(bool value) { + static constexpr uint32_t field_id = FieldMetadata_StreamAllocations::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_HeapSamplingIntervals = + ::protozero::proto_utils::FieldMetadata< + 22, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + HeapprofdConfig>; + + static constexpr FieldMetadata_HeapSamplingIntervals kHeapSamplingIntervals{}; + void add_heap_sampling_intervals(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_HeapSamplingIntervals::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_AllHeaps = + ::protozero::proto_utils::FieldMetadata< + 21, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + HeapprofdConfig>; + + static constexpr FieldMetadata_AllHeaps kAllHeaps{}; + void set_all_heaps(bool value) { + static constexpr uint32_t field_id = FieldMetadata_AllHeaps::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_All = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + HeapprofdConfig>; + + static constexpr FieldMetadata_All kAll{}; + void set_all(bool value) { + static constexpr uint32_t field_id = FieldMetadata_All::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_MinAnonymousMemoryKb = + ::protozero::proto_utils::FieldMetadata< + 15, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + HeapprofdConfig>; + + static constexpr FieldMetadata_MinAnonymousMemoryKb kMinAnonymousMemoryKb{}; + void set_min_anonymous_memory_kb(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_MinAnonymousMemoryKb::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_MaxHeapprofdMemoryKb = + ::protozero::proto_utils::FieldMetadata< + 16, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + HeapprofdConfig>; + + static constexpr FieldMetadata_MaxHeapprofdMemoryKb kMaxHeapprofdMemoryKb{}; + void set_max_heapprofd_memory_kb(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_MaxHeapprofdMemoryKb::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_MaxHeapprofdCpuSecs = + ::protozero::proto_utils::FieldMetadata< + 17, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + HeapprofdConfig>; + + static constexpr FieldMetadata_MaxHeapprofdCpuSecs kMaxHeapprofdCpuSecs{}; + void set_max_heapprofd_cpu_secs(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_MaxHeapprofdCpuSecs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SkipSymbolPrefix = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + HeapprofdConfig>; + + static constexpr FieldMetadata_SkipSymbolPrefix kSkipSymbolPrefix{}; + void add_skip_symbol_prefix(const char* data, size_t size) { + AppendBytes(FieldMetadata_SkipSymbolPrefix::kFieldId, data, size); + } + void add_skip_symbol_prefix(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_SkipSymbolPrefix::kFieldId, chars.data, chars.size); + } + void add_skip_symbol_prefix(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_SkipSymbolPrefix::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ContinuousDumpConfig = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + HeapprofdConfig_ContinuousDumpConfig, + HeapprofdConfig>; + + static constexpr FieldMetadata_ContinuousDumpConfig kContinuousDumpConfig{}; + template T* set_continuous_dump_config() { + return BeginNestedMessage(6); + } + + + using FieldMetadata_ShmemSizeBytes = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + HeapprofdConfig>; + + static constexpr FieldMetadata_ShmemSizeBytes kShmemSizeBytes{}; + void set_shmem_size_bytes(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_ShmemSizeBytes::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_BlockClient = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + HeapprofdConfig>; + + static constexpr FieldMetadata_BlockClient kBlockClient{}; + void set_block_client(bool value) { + static constexpr uint32_t field_id = FieldMetadata_BlockClient::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_BlockClientTimeoutUs = + ::protozero::proto_utils::FieldMetadata< + 14, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + HeapprofdConfig>; + + static constexpr FieldMetadata_BlockClientTimeoutUs kBlockClientTimeoutUs{}; + void set_block_client_timeout_us(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_BlockClientTimeoutUs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NoStartup = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + HeapprofdConfig>; + + static constexpr FieldMetadata_NoStartup kNoStartup{}; + void set_no_startup(bool value) { + static constexpr uint32_t field_id = FieldMetadata_NoStartup::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NoRunning = + ::protozero::proto_utils::FieldMetadata< + 11, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + HeapprofdConfig>; + + static constexpr FieldMetadata_NoRunning kNoRunning{}; + void set_no_running(bool value) { + static constexpr uint32_t field_id = FieldMetadata_NoRunning::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DumpAtMax = + ::protozero::proto_utils::FieldMetadata< + 13, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + HeapprofdConfig>; + + static constexpr FieldMetadata_DumpAtMax kDumpAtMax{}; + void set_dump_at_max(bool value) { + static constexpr uint32_t field_id = FieldMetadata_DumpAtMax::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DisableForkTeardown = + ::protozero::proto_utils::FieldMetadata< + 18, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + HeapprofdConfig>; + + static constexpr FieldMetadata_DisableForkTeardown kDisableForkTeardown{}; + void set_disable_fork_teardown(bool value) { + static constexpr uint32_t field_id = FieldMetadata_DisableForkTeardown::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DisableVforkDetection = + ::protozero::proto_utils::FieldMetadata< + 19, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + HeapprofdConfig>; + + static constexpr FieldMetadata_DisableVforkDetection kDisableVforkDetection{}; + void set_disable_vfork_detection(bool value) { + static constexpr uint32_t field_id = FieldMetadata_DisableVforkDetection::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } +}; + +class HeapprofdConfig_ContinuousDumpConfig_Decoder : public ::protozero::TypedProtoDecoder { + public: + HeapprofdConfig_ContinuousDumpConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit HeapprofdConfig_ContinuousDumpConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit HeapprofdConfig_ContinuousDumpConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dump_phase_ms() const { return at<5>().valid(); } + uint32_t dump_phase_ms() const { return at<5>().as_uint32(); } + bool has_dump_interval_ms() const { return at<6>().valid(); } + uint32_t dump_interval_ms() const { return at<6>().as_uint32(); } +}; + +class HeapprofdConfig_ContinuousDumpConfig : public ::protozero::Message { + public: + using Decoder = HeapprofdConfig_ContinuousDumpConfig_Decoder; + enum : int32_t { + kDumpPhaseMsFieldNumber = 5, + kDumpIntervalMsFieldNumber = 6, + }; + static constexpr const char* GetName() { return ".perfetto.protos.HeapprofdConfig.ContinuousDumpConfig"; } + + + using FieldMetadata_DumpPhaseMs = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + HeapprofdConfig_ContinuousDumpConfig>; + + static constexpr FieldMetadata_DumpPhaseMs kDumpPhaseMs{}; + void set_dump_phase_ms(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_DumpPhaseMs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DumpIntervalMs = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + HeapprofdConfig_ContinuousDumpConfig>; + + static constexpr FieldMetadata_DumpIntervalMs kDumpIntervalMs{}; + void set_dump_interval_ms(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_DumpIntervalMs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class ProcessStatsConfig_Decoder : public ::protozero::TypedProtoDecoder { + public: + ProcessStatsConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ProcessStatsConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ProcessStatsConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_quirks() const { return at<1>().valid(); } + ::protozero::RepeatedFieldIterator quirks() const { return GetRepeated(1); } + bool has_scan_all_processes_on_start() const { return at<2>().valid(); } + bool scan_all_processes_on_start() const { return at<2>().as_bool(); } + bool has_record_thread_names() const { return at<3>().valid(); } + bool record_thread_names() const { return at<3>().as_bool(); } + bool has_proc_stats_poll_ms() const { return at<4>().valid(); } + uint32_t proc_stats_poll_ms() const { return at<4>().as_uint32(); } + bool has_proc_stats_cache_ttl_ms() const { return at<6>().valid(); } + uint32_t proc_stats_cache_ttl_ms() const { return at<6>().as_uint32(); } + bool has_resolve_process_fds() const { return at<9>().valid(); } + bool resolve_process_fds() const { return at<9>().as_bool(); } + bool has_scan_smaps_rollup() const { return at<10>().valid(); } + bool scan_smaps_rollup() const { return at<10>().as_bool(); } + bool has_record_process_age() const { return at<11>().valid(); } + bool record_process_age() const { return at<11>().as_bool(); } + bool has_record_process_runtime() const { return at<12>().valid(); } + bool record_process_runtime() const { return at<12>().as_bool(); } +}; + +class ProcessStatsConfig : public ::protozero::Message { + public: + using Decoder = ProcessStatsConfig_Decoder; + enum : int32_t { + kQuirksFieldNumber = 1, + kScanAllProcessesOnStartFieldNumber = 2, + kRecordThreadNamesFieldNumber = 3, + kProcStatsPollMsFieldNumber = 4, + kProcStatsCacheTtlMsFieldNumber = 6, + kResolveProcessFdsFieldNumber = 9, + kScanSmapsRollupFieldNumber = 10, + kRecordProcessAgeFieldNumber = 11, + kRecordProcessRuntimeFieldNumber = 12, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ProcessStatsConfig"; } + + + using Quirks = ::perfetto::protos::pbzero::ProcessStatsConfig_Quirks; + static inline const char* Quirks_Name(Quirks value) { + return ::perfetto::protos::pbzero::ProcessStatsConfig_Quirks_Name(value); + } + static inline const Quirks QUIRKS_UNSPECIFIED = Quirks::QUIRKS_UNSPECIFIED; + static inline const Quirks DISABLE_INITIAL_DUMP = Quirks::DISABLE_INITIAL_DUMP; + static inline const Quirks DISABLE_ON_DEMAND = Quirks::DISABLE_ON_DEMAND; + + using FieldMetadata_Quirks = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + ProcessStatsConfig_Quirks, + ProcessStatsConfig>; + + static constexpr FieldMetadata_Quirks kQuirks{}; + void add_quirks(ProcessStatsConfig_Quirks value) { + static constexpr uint32_t field_id = FieldMetadata_Quirks::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ScanAllProcessesOnStart = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + ProcessStatsConfig>; + + static constexpr FieldMetadata_ScanAllProcessesOnStart kScanAllProcessesOnStart{}; + void set_scan_all_processes_on_start(bool value) { + static constexpr uint32_t field_id = FieldMetadata_ScanAllProcessesOnStart::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_RecordThreadNames = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + ProcessStatsConfig>; + + static constexpr FieldMetadata_RecordThreadNames kRecordThreadNames{}; + void set_record_thread_names(bool value) { + static constexpr uint32_t field_id = FieldMetadata_RecordThreadNames::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ProcStatsPollMs = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + ProcessStatsConfig>; + + static constexpr FieldMetadata_ProcStatsPollMs kProcStatsPollMs{}; + void set_proc_stats_poll_ms(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ProcStatsPollMs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ProcStatsCacheTtlMs = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + ProcessStatsConfig>; + + static constexpr FieldMetadata_ProcStatsCacheTtlMs kProcStatsCacheTtlMs{}; + void set_proc_stats_cache_ttl_ms(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ProcStatsCacheTtlMs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ResolveProcessFds = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + ProcessStatsConfig>; + + static constexpr FieldMetadata_ResolveProcessFds kResolveProcessFds{}; + void set_resolve_process_fds(bool value) { + static constexpr uint32_t field_id = FieldMetadata_ResolveProcessFds::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ScanSmapsRollup = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + ProcessStatsConfig>; + + static constexpr FieldMetadata_ScanSmapsRollup kScanSmapsRollup{}; + void set_scan_smaps_rollup(bool value) { + static constexpr uint32_t field_id = FieldMetadata_ScanSmapsRollup::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_RecordProcessAge = + ::protozero::proto_utils::FieldMetadata< + 11, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + ProcessStatsConfig>; + + static constexpr FieldMetadata_RecordProcessAge kRecordProcessAge{}; + void set_record_process_age(bool value) { + static constexpr uint32_t field_id = FieldMetadata_RecordProcessAge::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_RecordProcessRuntime = + ::protozero::proto_utils::FieldMetadata< + 12, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + ProcessStatsConfig>; + + static constexpr FieldMetadata_RecordProcessRuntime kRecordProcessRuntime{}; + void set_record_process_runtime(bool value) { + static constexpr uint32_t field_id = FieldMetadata_RecordProcessRuntime::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } +}; + +class AndroidPowerConfig_Decoder : public ::protozero::TypedProtoDecoder { + public: + AndroidPowerConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit AndroidPowerConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit AndroidPowerConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_battery_poll_ms() const { return at<1>().valid(); } + uint32_t battery_poll_ms() const { return at<1>().as_uint32(); } + bool has_battery_counters() const { return at<2>().valid(); } + ::protozero::RepeatedFieldIterator battery_counters() const { return GetRepeated(2); } + bool has_collect_power_rails() const { return at<3>().valid(); } + bool collect_power_rails() const { return at<3>().as_bool(); } + bool has_collect_energy_estimation_breakdown() const { return at<4>().valid(); } + bool collect_energy_estimation_breakdown() const { return at<4>().as_bool(); } + bool has_collect_entity_state_residency() const { return at<5>().valid(); } + bool collect_entity_state_residency() const { return at<5>().as_bool(); } +}; + +class AndroidPowerConfig : public ::protozero::Message { + public: + using Decoder = AndroidPowerConfig_Decoder; + enum : int32_t { + kBatteryPollMsFieldNumber = 1, + kBatteryCountersFieldNumber = 2, + kCollectPowerRailsFieldNumber = 3, + kCollectEnergyEstimationBreakdownFieldNumber = 4, + kCollectEntityStateResidencyFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.AndroidPowerConfig"; } + + + using BatteryCounters = ::perfetto::protos::pbzero::AndroidPowerConfig_BatteryCounters; + static inline const char* BatteryCounters_Name(BatteryCounters value) { + return ::perfetto::protos::pbzero::AndroidPowerConfig_BatteryCounters_Name(value); + } + static inline const BatteryCounters BATTERY_COUNTER_UNSPECIFIED = BatteryCounters::BATTERY_COUNTER_UNSPECIFIED; + static inline const BatteryCounters BATTERY_COUNTER_CHARGE = BatteryCounters::BATTERY_COUNTER_CHARGE; + static inline const BatteryCounters BATTERY_COUNTER_CAPACITY_PERCENT = BatteryCounters::BATTERY_COUNTER_CAPACITY_PERCENT; + static inline const BatteryCounters BATTERY_COUNTER_CURRENT = BatteryCounters::BATTERY_COUNTER_CURRENT; + static inline const BatteryCounters BATTERY_COUNTER_CURRENT_AVG = BatteryCounters::BATTERY_COUNTER_CURRENT_AVG; + static inline const BatteryCounters BATTERY_COUNTER_VOLTAGE = BatteryCounters::BATTERY_COUNTER_VOLTAGE; + + using FieldMetadata_BatteryPollMs = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + AndroidPowerConfig>; + + static constexpr FieldMetadata_BatteryPollMs kBatteryPollMs{}; + void set_battery_poll_ms(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_BatteryPollMs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_BatteryCounters = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + AndroidPowerConfig_BatteryCounters, + AndroidPowerConfig>; + + static constexpr FieldMetadata_BatteryCounters kBatteryCounters{}; + void add_battery_counters(AndroidPowerConfig_BatteryCounters value) { + static constexpr uint32_t field_id = FieldMetadata_BatteryCounters::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CollectPowerRails = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + AndroidPowerConfig>; + + static constexpr FieldMetadata_CollectPowerRails kCollectPowerRails{}; + void set_collect_power_rails(bool value) { + static constexpr uint32_t field_id = FieldMetadata_CollectPowerRails::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CollectEnergyEstimationBreakdown = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + AndroidPowerConfig>; + + static constexpr FieldMetadata_CollectEnergyEstimationBreakdown kCollectEnergyEstimationBreakdown{}; + void set_collect_energy_estimation_breakdown(bool value) { + static constexpr uint32_t field_id = FieldMetadata_CollectEnergyEstimationBreakdown::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CollectEntityStateResidency = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + AndroidPowerConfig>; + + static constexpr FieldMetadata_CollectEntityStateResidency kCollectEntityStateResidency{}; + void set_collect_entity_state_residency(bool value) { + static constexpr uint32_t field_id = FieldMetadata_CollectEntityStateResidency::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } +}; + +class InterceptorConfig_Decoder : public ::protozero::TypedProtoDecoder { + public: + InterceptorConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit InterceptorConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit InterceptorConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_name() const { return at<1>().valid(); } + ::protozero::ConstChars name() const { return at<1>().as_string(); } + bool has_console_config() const { return at<100>().valid(); } + ::protozero::ConstBytes console_config() const { return at<100>().as_bytes(); } +}; + +class InterceptorConfig : public ::protozero::Message { + public: + using Decoder = InterceptorConfig_Decoder; + enum : int32_t { + kNameFieldNumber = 1, + kConsoleConfigFieldNumber = 100, + }; + static constexpr const char* GetName() { return ".perfetto.protos.InterceptorConfig"; } + + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + InterceptorConfig>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ConsoleConfig = + ::protozero::proto_utils::FieldMetadata< + 100, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ConsoleConfig, + InterceptorConfig>; + + static constexpr FieldMetadata_ConsoleConfig kConsoleConfig{}; + template T* set_console_config() { + return BeginNestedMessage(100); + } + +}; + +class ConsoleConfig_Decoder : public ::protozero::TypedProtoDecoder { + public: + ConsoleConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ConsoleConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ConsoleConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_output() const { return at<1>().valid(); } + int32_t output() const { return at<1>().as_int32(); } + bool has_enable_colors() const { return at<2>().valid(); } + bool enable_colors() const { return at<2>().as_bool(); } +}; + +class ConsoleConfig : public ::protozero::Message { + public: + using Decoder = ConsoleConfig_Decoder; + enum : int32_t { + kOutputFieldNumber = 1, + kEnableColorsFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ConsoleConfig"; } + + + using Output = ::perfetto::protos::pbzero::ConsoleConfig_Output; + static inline const char* Output_Name(Output value) { + return ::perfetto::protos::pbzero::ConsoleConfig_Output_Name(value); + } + static inline const Output OUTPUT_UNSPECIFIED = Output::OUTPUT_UNSPECIFIED; + static inline const Output OUTPUT_STDOUT = Output::OUTPUT_STDOUT; + static inline const Output OUTPUT_STDERR = Output::OUTPUT_STDERR; + + using FieldMetadata_Output = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + ConsoleConfig_Output, + ConsoleConfig>; + + static constexpr FieldMetadata_Output kOutput{}; + void set_output(ConsoleConfig_Output value) { + static constexpr uint32_t field_id = FieldMetadata_Output::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_EnableColors = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + ConsoleConfig>; + + static constexpr FieldMetadata_EnableColors kEnableColors{}; + void set_enable_colors(bool value) { + static constexpr uint32_t field_id = FieldMetadata_EnableColors::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } +}; + +class InodeFileConfig_Decoder : public ::protozero::TypedProtoDecoder { + public: + InodeFileConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit InodeFileConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit InodeFileConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_scan_interval_ms() const { return at<1>().valid(); } + uint32_t scan_interval_ms() const { return at<1>().as_uint32(); } + bool has_scan_delay_ms() const { return at<2>().valid(); } + uint32_t scan_delay_ms() const { return at<2>().as_uint32(); } + bool has_scan_batch_size() const { return at<3>().valid(); } + uint32_t scan_batch_size() const { return at<3>().as_uint32(); } + bool has_do_not_scan() const { return at<4>().valid(); } + bool do_not_scan() const { return at<4>().as_bool(); } + bool has_scan_mount_points() const { return at<5>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstChars> scan_mount_points() const { return GetRepeated<::protozero::ConstChars>(5); } + bool has_mount_point_mapping() const { return at<6>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> mount_point_mapping() const { return GetRepeated<::protozero::ConstBytes>(6); } +}; + +class InodeFileConfig : public ::protozero::Message { + public: + using Decoder = InodeFileConfig_Decoder; + enum : int32_t { + kScanIntervalMsFieldNumber = 1, + kScanDelayMsFieldNumber = 2, + kScanBatchSizeFieldNumber = 3, + kDoNotScanFieldNumber = 4, + kScanMountPointsFieldNumber = 5, + kMountPointMappingFieldNumber = 6, + }; + static constexpr const char* GetName() { return ".perfetto.protos.InodeFileConfig"; } + + using MountPointMappingEntry = ::perfetto::protos::pbzero::InodeFileConfig_MountPointMappingEntry; + + using FieldMetadata_ScanIntervalMs = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + InodeFileConfig>; + + static constexpr FieldMetadata_ScanIntervalMs kScanIntervalMs{}; + void set_scan_interval_ms(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ScanIntervalMs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ScanDelayMs = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + InodeFileConfig>; + + static constexpr FieldMetadata_ScanDelayMs kScanDelayMs{}; + void set_scan_delay_ms(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ScanDelayMs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ScanBatchSize = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + InodeFileConfig>; + + static constexpr FieldMetadata_ScanBatchSize kScanBatchSize{}; + void set_scan_batch_size(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ScanBatchSize::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DoNotScan = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + InodeFileConfig>; + + static constexpr FieldMetadata_DoNotScan kDoNotScan{}; + void set_do_not_scan(bool value) { + static constexpr uint32_t field_id = FieldMetadata_DoNotScan::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ScanMountPoints = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + InodeFileConfig>; + + static constexpr FieldMetadata_ScanMountPoints kScanMountPoints{}; + void add_scan_mount_points(const char* data, size_t size) { + AppendBytes(FieldMetadata_ScanMountPoints::kFieldId, data, size); + } + void add_scan_mount_points(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_ScanMountPoints::kFieldId, chars.data, chars.size); + } + void add_scan_mount_points(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_ScanMountPoints::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_MountPointMapping = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + InodeFileConfig_MountPointMappingEntry, + InodeFileConfig>; + + static constexpr FieldMetadata_MountPointMapping kMountPointMapping{}; + template T* add_mount_point_mapping() { + return BeginNestedMessage(6); + } + +}; + +class InodeFileConfig_MountPointMappingEntry_Decoder : public ::protozero::TypedProtoDecoder { + public: + InodeFileConfig_MountPointMappingEntry_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit InodeFileConfig_MountPointMappingEntry_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit InodeFileConfig_MountPointMappingEntry_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_mountpoint() const { return at<1>().valid(); } + ::protozero::ConstChars mountpoint() const { return at<1>().as_string(); } + bool has_scan_roots() const { return at<2>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstChars> scan_roots() const { return GetRepeated<::protozero::ConstChars>(2); } +}; + +class InodeFileConfig_MountPointMappingEntry : public ::protozero::Message { + public: + using Decoder = InodeFileConfig_MountPointMappingEntry_Decoder; + enum : int32_t { + kMountpointFieldNumber = 1, + kScanRootsFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.InodeFileConfig.MountPointMappingEntry"; } + + + using FieldMetadata_Mountpoint = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + InodeFileConfig_MountPointMappingEntry>; + + static constexpr FieldMetadata_Mountpoint kMountpoint{}; + void set_mountpoint(const char* data, size_t size) { + AppendBytes(FieldMetadata_Mountpoint::kFieldId, data, size); + } + void set_mountpoint(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Mountpoint::kFieldId, chars.data, chars.size); + } + void set_mountpoint(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Mountpoint::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ScanRoots = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + InodeFileConfig_MountPointMappingEntry>; + + static constexpr FieldMetadata_ScanRoots kScanRoots{}; + void add_scan_roots(const char* data, size_t size) { + AppendBytes(FieldMetadata_ScanRoots::kFieldId, data, size); + } + void add_scan_roots(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_ScanRoots::kFieldId, chars.data, chars.size); + } + void add_scan_roots(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_ScanRoots::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class VulkanMemoryConfig_Decoder : public ::protozero::TypedProtoDecoder { + public: + VulkanMemoryConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit VulkanMemoryConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit VulkanMemoryConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_track_driver_memory_usage() const { return at<1>().valid(); } + bool track_driver_memory_usage() const { return at<1>().as_bool(); } + bool has_track_device_memory_usage() const { return at<2>().valid(); } + bool track_device_memory_usage() const { return at<2>().as_bool(); } +}; + +class VulkanMemoryConfig : public ::protozero::Message { + public: + using Decoder = VulkanMemoryConfig_Decoder; + enum : int32_t { + kTrackDriverMemoryUsageFieldNumber = 1, + kTrackDeviceMemoryUsageFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.VulkanMemoryConfig"; } + + + using FieldMetadata_TrackDriverMemoryUsage = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + VulkanMemoryConfig>; + + static constexpr FieldMetadata_TrackDriverMemoryUsage kTrackDriverMemoryUsage{}; + void set_track_driver_memory_usage(bool value) { + static constexpr uint32_t field_id = FieldMetadata_TrackDriverMemoryUsage::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TrackDeviceMemoryUsage = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + VulkanMemoryConfig>; + + static constexpr FieldMetadata_TrackDeviceMemoryUsage kTrackDeviceMemoryUsage{}; + void set_track_device_memory_usage(bool value) { + static constexpr uint32_t field_id = FieldMetadata_TrackDeviceMemoryUsage::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } +}; + +class GpuCounterConfig_Decoder : public ::protozero::TypedProtoDecoder { + public: + GpuCounterConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit GpuCounterConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit GpuCounterConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_counter_period_ns() const { return at<1>().valid(); } + uint64_t counter_period_ns() const { return at<1>().as_uint64(); } + bool has_counter_ids() const { return at<2>().valid(); } + ::protozero::RepeatedFieldIterator counter_ids() const { return GetRepeated(2); } + bool has_instrumented_sampling() const { return at<3>().valid(); } + bool instrumented_sampling() const { return at<3>().as_bool(); } + bool has_fix_gpu_clock() const { return at<4>().valid(); } + bool fix_gpu_clock() const { return at<4>().as_bool(); } +}; + +class GpuCounterConfig : public ::protozero::Message { + public: + using Decoder = GpuCounterConfig_Decoder; + enum : int32_t { + kCounterPeriodNsFieldNumber = 1, + kCounterIdsFieldNumber = 2, + kInstrumentedSamplingFieldNumber = 3, + kFixGpuClockFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.GpuCounterConfig"; } + + + using FieldMetadata_CounterPeriodNs = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + GpuCounterConfig>; + + static constexpr FieldMetadata_CounterPeriodNs kCounterPeriodNs{}; + void set_counter_period_ns(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_CounterPeriodNs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CounterIds = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + GpuCounterConfig>; + + static constexpr FieldMetadata_CounterIds kCounterIds{}; + void add_counter_ids(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_CounterIds::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_InstrumentedSampling = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + GpuCounterConfig>; + + static constexpr FieldMetadata_InstrumentedSampling kInstrumentedSampling{}; + void set_instrumented_sampling(bool value) { + static constexpr uint32_t field_id = FieldMetadata_InstrumentedSampling::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FixGpuClock = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + GpuCounterConfig>; + + static constexpr FieldMetadata_FixGpuClock kFixGpuClock{}; + void set_fix_gpu_clock(bool value) { + static constexpr uint32_t field_id = FieldMetadata_FixGpuClock::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } +}; + +class FtraceConfig_Decoder : public ::protozero::TypedProtoDecoder { + public: + FtraceConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit FtraceConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit FtraceConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_ftrace_events() const { return at<1>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstChars> ftrace_events() const { return GetRepeated<::protozero::ConstChars>(1); } + bool has_atrace_categories() const { return at<2>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstChars> atrace_categories() const { return GetRepeated<::protozero::ConstChars>(2); } + bool has_atrace_apps() const { return at<3>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstChars> atrace_apps() const { return GetRepeated<::protozero::ConstChars>(3); } + bool has_buffer_size_kb() const { return at<10>().valid(); } + uint32_t buffer_size_kb() const { return at<10>().as_uint32(); } + bool has_drain_period_ms() const { return at<11>().valid(); } + uint32_t drain_period_ms() const { return at<11>().as_uint32(); } + bool has_drain_buffer_percent() const { return at<26>().valid(); } + uint32_t drain_buffer_percent() const { return at<26>().as_uint32(); } + bool has_compact_sched() const { return at<12>().valid(); } + ::protozero::ConstBytes compact_sched() const { return at<12>().as_bytes(); } + bool has_print_filter() const { return at<22>().valid(); } + ::protozero::ConstBytes print_filter() const { return at<22>().as_bytes(); } + bool has_symbolize_ksyms() const { return at<13>().valid(); } + bool symbolize_ksyms() const { return at<13>().as_bool(); } + bool has_ksyms_mem_policy() const { return at<17>().valid(); } + int32_t ksyms_mem_policy() const { return at<17>().as_int32(); } + bool has_initialize_ksyms_synchronously_for_testing() const { return at<14>().valid(); } + bool initialize_ksyms_synchronously_for_testing() const { return at<14>().as_bool(); } + bool has_throttle_rss_stat() const { return at<15>().valid(); } + bool throttle_rss_stat() const { return at<15>().as_bool(); } + bool has_disable_generic_events() const { return at<16>().valid(); } + bool disable_generic_events() const { return at<16>().as_bool(); } + bool has_syscall_events() const { return at<18>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstChars> syscall_events() const { return GetRepeated<::protozero::ConstChars>(18); } + bool has_enable_function_graph() const { return at<19>().valid(); } + bool enable_function_graph() const { return at<19>().as_bool(); } + bool has_function_filters() const { return at<20>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstChars> function_filters() const { return GetRepeated<::protozero::ConstChars>(20); } + bool has_function_graph_roots() const { return at<21>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstChars> function_graph_roots() const { return GetRepeated<::protozero::ConstChars>(21); } + bool has_preserve_ftrace_buffer() const { return at<23>().valid(); } + bool preserve_ftrace_buffer() const { return at<23>().as_bool(); } + bool has_use_monotonic_raw_clock() const { return at<24>().valid(); } + bool use_monotonic_raw_clock() const { return at<24>().as_bool(); } + bool has_instance_name() const { return at<25>().valid(); } + ::protozero::ConstChars instance_name() const { return at<25>().as_string(); } + bool has_buffer_size_lower_bound() const { return at<27>().valid(); } + bool buffer_size_lower_bound() const { return at<27>().as_bool(); } +}; + +class FtraceConfig : public ::protozero::Message { + public: + using Decoder = FtraceConfig_Decoder; + enum : int32_t { + kFtraceEventsFieldNumber = 1, + kAtraceCategoriesFieldNumber = 2, + kAtraceAppsFieldNumber = 3, + kBufferSizeKbFieldNumber = 10, + kDrainPeriodMsFieldNumber = 11, + kDrainBufferPercentFieldNumber = 26, + kCompactSchedFieldNumber = 12, + kPrintFilterFieldNumber = 22, + kSymbolizeKsymsFieldNumber = 13, + kKsymsMemPolicyFieldNumber = 17, + kInitializeKsymsSynchronouslyForTestingFieldNumber = 14, + kThrottleRssStatFieldNumber = 15, + kDisableGenericEventsFieldNumber = 16, + kSyscallEventsFieldNumber = 18, + kEnableFunctionGraphFieldNumber = 19, + kFunctionFiltersFieldNumber = 20, + kFunctionGraphRootsFieldNumber = 21, + kPreserveFtraceBufferFieldNumber = 23, + kUseMonotonicRawClockFieldNumber = 24, + kInstanceNameFieldNumber = 25, + kBufferSizeLowerBoundFieldNumber = 27, + }; + static constexpr const char* GetName() { return ".perfetto.protos.FtraceConfig"; } + + using CompactSchedConfig = ::perfetto::protos::pbzero::FtraceConfig_CompactSchedConfig; + using PrintFilter = ::perfetto::protos::pbzero::FtraceConfig_PrintFilter; + + using KsymsMemPolicy = ::perfetto::protos::pbzero::FtraceConfig_KsymsMemPolicy; + static inline const char* KsymsMemPolicy_Name(KsymsMemPolicy value) { + return ::perfetto::protos::pbzero::FtraceConfig_KsymsMemPolicy_Name(value); + } + static inline const KsymsMemPolicy KSYMS_UNSPECIFIED = KsymsMemPolicy::KSYMS_UNSPECIFIED; + static inline const KsymsMemPolicy KSYMS_CLEANUP_ON_STOP = KsymsMemPolicy::KSYMS_CLEANUP_ON_STOP; + static inline const KsymsMemPolicy KSYMS_RETAIN = KsymsMemPolicy::KSYMS_RETAIN; + + using FieldMetadata_FtraceEvents = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + FtraceConfig>; + + static constexpr FieldMetadata_FtraceEvents kFtraceEvents{}; + void add_ftrace_events(const char* data, size_t size) { + AppendBytes(FieldMetadata_FtraceEvents::kFieldId, data, size); + } + void add_ftrace_events(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_FtraceEvents::kFieldId, chars.data, chars.size); + } + void add_ftrace_events(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_FtraceEvents::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_AtraceCategories = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + FtraceConfig>; + + static constexpr FieldMetadata_AtraceCategories kAtraceCategories{}; + void add_atrace_categories(const char* data, size_t size) { + AppendBytes(FieldMetadata_AtraceCategories::kFieldId, data, size); + } + void add_atrace_categories(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_AtraceCategories::kFieldId, chars.data, chars.size); + } + void add_atrace_categories(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_AtraceCategories::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_AtraceApps = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + FtraceConfig>; + + static constexpr FieldMetadata_AtraceApps kAtraceApps{}; + void add_atrace_apps(const char* data, size_t size) { + AppendBytes(FieldMetadata_AtraceApps::kFieldId, data, size); + } + void add_atrace_apps(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_AtraceApps::kFieldId, chars.data, chars.size); + } + void add_atrace_apps(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_AtraceApps::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_BufferSizeKb = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + FtraceConfig>; + + static constexpr FieldMetadata_BufferSizeKb kBufferSizeKb{}; + void set_buffer_size_kb(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_BufferSizeKb::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DrainPeriodMs = + ::protozero::proto_utils::FieldMetadata< + 11, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + FtraceConfig>; + + static constexpr FieldMetadata_DrainPeriodMs kDrainPeriodMs{}; + void set_drain_period_ms(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_DrainPeriodMs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DrainBufferPercent = + ::protozero::proto_utils::FieldMetadata< + 26, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + FtraceConfig>; + + static constexpr FieldMetadata_DrainBufferPercent kDrainBufferPercent{}; + void set_drain_buffer_percent(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_DrainBufferPercent::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CompactSched = + ::protozero::proto_utils::FieldMetadata< + 12, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + FtraceConfig_CompactSchedConfig, + FtraceConfig>; + + static constexpr FieldMetadata_CompactSched kCompactSched{}; + template T* set_compact_sched() { + return BeginNestedMessage(12); + } + + + using FieldMetadata_PrintFilter = + ::protozero::proto_utils::FieldMetadata< + 22, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + FtraceConfig_PrintFilter, + FtraceConfig>; + + static constexpr FieldMetadata_PrintFilter kPrintFilter{}; + template T* set_print_filter() { + return BeginNestedMessage(22); + } + + + using FieldMetadata_SymbolizeKsyms = + ::protozero::proto_utils::FieldMetadata< + 13, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + FtraceConfig>; + + static constexpr FieldMetadata_SymbolizeKsyms kSymbolizeKsyms{}; + void set_symbolize_ksyms(bool value) { + static constexpr uint32_t field_id = FieldMetadata_SymbolizeKsyms::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_KsymsMemPolicy = + ::protozero::proto_utils::FieldMetadata< + 17, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + FtraceConfig_KsymsMemPolicy, + FtraceConfig>; + + static constexpr FieldMetadata_KsymsMemPolicy kKsymsMemPolicy{}; + void set_ksyms_mem_policy(FtraceConfig_KsymsMemPolicy value) { + static constexpr uint32_t field_id = FieldMetadata_KsymsMemPolicy::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_InitializeKsymsSynchronouslyForTesting = + ::protozero::proto_utils::FieldMetadata< + 14, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + FtraceConfig>; + + static constexpr FieldMetadata_InitializeKsymsSynchronouslyForTesting kInitializeKsymsSynchronouslyForTesting{}; + void set_initialize_ksyms_synchronously_for_testing(bool value) { + static constexpr uint32_t field_id = FieldMetadata_InitializeKsymsSynchronouslyForTesting::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ThrottleRssStat = + ::protozero::proto_utils::FieldMetadata< + 15, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + FtraceConfig>; + + static constexpr FieldMetadata_ThrottleRssStat kThrottleRssStat{}; + void set_throttle_rss_stat(bool value) { + static constexpr uint32_t field_id = FieldMetadata_ThrottleRssStat::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DisableGenericEvents = + ::protozero::proto_utils::FieldMetadata< + 16, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + FtraceConfig>; + + static constexpr FieldMetadata_DisableGenericEvents kDisableGenericEvents{}; + void set_disable_generic_events(bool value) { + static constexpr uint32_t field_id = FieldMetadata_DisableGenericEvents::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SyscallEvents = + ::protozero::proto_utils::FieldMetadata< + 18, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + FtraceConfig>; + + static constexpr FieldMetadata_SyscallEvents kSyscallEvents{}; + void add_syscall_events(const char* data, size_t size) { + AppendBytes(FieldMetadata_SyscallEvents::kFieldId, data, size); + } + void add_syscall_events(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_SyscallEvents::kFieldId, chars.data, chars.size); + } + void add_syscall_events(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_SyscallEvents::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_EnableFunctionGraph = + ::protozero::proto_utils::FieldMetadata< + 19, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + FtraceConfig>; + + static constexpr FieldMetadata_EnableFunctionGraph kEnableFunctionGraph{}; + void set_enable_function_graph(bool value) { + static constexpr uint32_t field_id = FieldMetadata_EnableFunctionGraph::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FunctionFilters = + ::protozero::proto_utils::FieldMetadata< + 20, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + FtraceConfig>; + + static constexpr FieldMetadata_FunctionFilters kFunctionFilters{}; + void add_function_filters(const char* data, size_t size) { + AppendBytes(FieldMetadata_FunctionFilters::kFieldId, data, size); + } + void add_function_filters(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_FunctionFilters::kFieldId, chars.data, chars.size); + } + void add_function_filters(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_FunctionFilters::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FunctionGraphRoots = + ::protozero::proto_utils::FieldMetadata< + 21, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + FtraceConfig>; + + static constexpr FieldMetadata_FunctionGraphRoots kFunctionGraphRoots{}; + void add_function_graph_roots(const char* data, size_t size) { + AppendBytes(FieldMetadata_FunctionGraphRoots::kFieldId, data, size); + } + void add_function_graph_roots(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_FunctionGraphRoots::kFieldId, chars.data, chars.size); + } + void add_function_graph_roots(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_FunctionGraphRoots::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PreserveFtraceBuffer = + ::protozero::proto_utils::FieldMetadata< + 23, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + FtraceConfig>; + + static constexpr FieldMetadata_PreserveFtraceBuffer kPreserveFtraceBuffer{}; + void set_preserve_ftrace_buffer(bool value) { + static constexpr uint32_t field_id = FieldMetadata_PreserveFtraceBuffer::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_UseMonotonicRawClock = + ::protozero::proto_utils::FieldMetadata< + 24, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + FtraceConfig>; + + static constexpr FieldMetadata_UseMonotonicRawClock kUseMonotonicRawClock{}; + void set_use_monotonic_raw_clock(bool value) { + static constexpr uint32_t field_id = FieldMetadata_UseMonotonicRawClock::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_InstanceName = + ::protozero::proto_utils::FieldMetadata< + 25, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + FtraceConfig>; + + static constexpr FieldMetadata_InstanceName kInstanceName{}; + void set_instance_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_InstanceName::kFieldId, data, size); + } + void set_instance_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_InstanceName::kFieldId, chars.data, chars.size); + } + void set_instance_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_InstanceName::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_BufferSizeLowerBound = + ::protozero::proto_utils::FieldMetadata< + 27, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + FtraceConfig>; + + static constexpr FieldMetadata_BufferSizeLowerBound kBufferSizeLowerBound{}; + void set_buffer_size_lower_bound(bool value) { + static constexpr uint32_t field_id = FieldMetadata_BufferSizeLowerBound::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } +}; + +class FtraceConfig_PrintFilter_Decoder : public ::protozero::TypedProtoDecoder { + public: + FtraceConfig_PrintFilter_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit FtraceConfig_PrintFilter_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit FtraceConfig_PrintFilter_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_rules() const { return at<1>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> rules() const { return GetRepeated<::protozero::ConstBytes>(1); } +}; + +class FtraceConfig_PrintFilter : public ::protozero::Message { + public: + using Decoder = FtraceConfig_PrintFilter_Decoder; + enum : int32_t { + kRulesFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.FtraceConfig.PrintFilter"; } + + using Rule = ::perfetto::protos::pbzero::FtraceConfig_PrintFilter_Rule; + + using FieldMetadata_Rules = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + FtraceConfig_PrintFilter_Rule, + FtraceConfig_PrintFilter>; + + static constexpr FieldMetadata_Rules kRules{}; + template T* add_rules() { + return BeginNestedMessage(1); + } + +}; + +class FtraceConfig_PrintFilter_Rule_Decoder : public ::protozero::TypedProtoDecoder { + public: + FtraceConfig_PrintFilter_Rule_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit FtraceConfig_PrintFilter_Rule_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit FtraceConfig_PrintFilter_Rule_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_prefix() const { return at<1>().valid(); } + ::protozero::ConstChars prefix() const { return at<1>().as_string(); } + bool has_atrace_msg() const { return at<3>().valid(); } + ::protozero::ConstBytes atrace_msg() const { return at<3>().as_bytes(); } + bool has_allow() const { return at<2>().valid(); } + bool allow() const { return at<2>().as_bool(); } +}; + +class FtraceConfig_PrintFilter_Rule : public ::protozero::Message { + public: + using Decoder = FtraceConfig_PrintFilter_Rule_Decoder; + enum : int32_t { + kPrefixFieldNumber = 1, + kAtraceMsgFieldNumber = 3, + kAllowFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.FtraceConfig.PrintFilter.Rule"; } + + using AtraceMessage = ::perfetto::protos::pbzero::FtraceConfig_PrintFilter_Rule_AtraceMessage; + + using FieldMetadata_Prefix = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + FtraceConfig_PrintFilter_Rule>; + + static constexpr FieldMetadata_Prefix kPrefix{}; + void set_prefix(const char* data, size_t size) { + AppendBytes(FieldMetadata_Prefix::kFieldId, data, size); + } + void set_prefix(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Prefix::kFieldId, chars.data, chars.size); + } + void set_prefix(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Prefix::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_AtraceMsg = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + FtraceConfig_PrintFilter_Rule_AtraceMessage, + FtraceConfig_PrintFilter_Rule>; + + static constexpr FieldMetadata_AtraceMsg kAtraceMsg{}; + template T* set_atrace_msg() { + return BeginNestedMessage(3); + } + + + using FieldMetadata_Allow = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + FtraceConfig_PrintFilter_Rule>; + + static constexpr FieldMetadata_Allow kAllow{}; + void set_allow(bool value) { + static constexpr uint32_t field_id = FieldMetadata_Allow::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } +}; + +class FtraceConfig_PrintFilter_Rule_AtraceMessage_Decoder : public ::protozero::TypedProtoDecoder { + public: + FtraceConfig_PrintFilter_Rule_AtraceMessage_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit FtraceConfig_PrintFilter_Rule_AtraceMessage_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit FtraceConfig_PrintFilter_Rule_AtraceMessage_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_type() const { return at<1>().valid(); } + ::protozero::ConstChars type() const { return at<1>().as_string(); } + bool has_prefix() const { return at<2>().valid(); } + ::protozero::ConstChars prefix() const { return at<2>().as_string(); } +}; + +class FtraceConfig_PrintFilter_Rule_AtraceMessage : public ::protozero::Message { + public: + using Decoder = FtraceConfig_PrintFilter_Rule_AtraceMessage_Decoder; + enum : int32_t { + kTypeFieldNumber = 1, + kPrefixFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.FtraceConfig.PrintFilter.Rule.AtraceMessage"; } + + + using FieldMetadata_Type = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + FtraceConfig_PrintFilter_Rule_AtraceMessage>; + + static constexpr FieldMetadata_Type kType{}; + void set_type(const char* data, size_t size) { + AppendBytes(FieldMetadata_Type::kFieldId, data, size); + } + void set_type(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Type::kFieldId, chars.data, chars.size); + } + void set_type(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Prefix = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + FtraceConfig_PrintFilter_Rule_AtraceMessage>; + + static constexpr FieldMetadata_Prefix kPrefix{}; + void set_prefix(const char* data, size_t size) { + AppendBytes(FieldMetadata_Prefix::kFieldId, data, size); + } + void set_prefix(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Prefix::kFieldId, chars.data, chars.size); + } + void set_prefix(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Prefix::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class FtraceConfig_CompactSchedConfig_Decoder : public ::protozero::TypedProtoDecoder { + public: + FtraceConfig_CompactSchedConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit FtraceConfig_CompactSchedConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit FtraceConfig_CompactSchedConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_enabled() const { return at<1>().valid(); } + bool enabled() const { return at<1>().as_bool(); } +}; + +class FtraceConfig_CompactSchedConfig : public ::protozero::Message { + public: + using Decoder = FtraceConfig_CompactSchedConfig_Decoder; + enum : int32_t { + kEnabledFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.FtraceConfig.CompactSchedConfig"; } + + + using FieldMetadata_Enabled = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + FtraceConfig_CompactSchedConfig>; + + static constexpr FieldMetadata_Enabled kEnabled{}; + void set_enabled(bool value) { + static constexpr uint32_t field_id = FieldMetadata_Enabled::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } +}; + +class EtwConfig_Decoder : public ::protozero::TypedProtoDecoder { + public: + EtwConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit EtwConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit EtwConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_kernel_flags() const { return at<1>().valid(); } + ::protozero::RepeatedFieldIterator kernel_flags() const { return GetRepeated(1); } +}; + +class EtwConfig : public ::protozero::Message { + public: + using Decoder = EtwConfig_Decoder; + enum : int32_t { + kKernelFlagsFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.EtwConfig"; } + + + using KernelFlag = ::perfetto::protos::pbzero::EtwConfig_KernelFlag; + static inline const char* KernelFlag_Name(KernelFlag value) { + return ::perfetto::protos::pbzero::EtwConfig_KernelFlag_Name(value); + } + static inline const KernelFlag CSWITCH = KernelFlag::CSWITCH; + static inline const KernelFlag DISPATCHER = KernelFlag::DISPATCHER; + + using FieldMetadata_KernelFlags = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + EtwConfig_KernelFlag, + EtwConfig>; + + static constexpr FieldMetadata_KernelFlags kKernelFlags{}; + void add_kernel_flags(EtwConfig_KernelFlag value) { + static constexpr uint32_t field_id = FieldMetadata_KernelFlags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } +}; + +class V8Config_Decoder : public ::protozero::TypedProtoDecoder { + public: + V8Config_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit V8Config_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit V8Config_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_log_script_sources() const { return at<1>().valid(); } + bool log_script_sources() const { return at<1>().as_bool(); } + bool has_log_instructions() const { return at<2>().valid(); } + bool log_instructions() const { return at<2>().as_bool(); } +}; + +class V8Config : public ::protozero::Message { + public: + using Decoder = V8Config_Decoder; + enum : int32_t { + kLogScriptSourcesFieldNumber = 1, + kLogInstructionsFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.V8Config"; } + + + using FieldMetadata_LogScriptSources = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + V8Config>; + + static constexpr FieldMetadata_LogScriptSources kLogScriptSources{}; + void set_log_script_sources(bool value) { + static constexpr uint32_t field_id = FieldMetadata_LogScriptSources::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_LogInstructions = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + V8Config>; + + static constexpr FieldMetadata_LogInstructions kLogInstructions{}; + void set_log_instructions(bool value) { + static constexpr uint32_t field_id = FieldMetadata_LogInstructions::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } +}; + +class ChromeConfig_Decoder : public ::protozero::TypedProtoDecoder { + public: + ChromeConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ChromeConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ChromeConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_trace_config() const { return at<1>().valid(); } + ::protozero::ConstChars trace_config() const { return at<1>().as_string(); } + bool has_privacy_filtering_enabled() const { return at<2>().valid(); } + bool privacy_filtering_enabled() const { return at<2>().as_bool(); } + bool has_convert_to_legacy_json() const { return at<3>().valid(); } + bool convert_to_legacy_json() const { return at<3>().as_bool(); } + bool has_client_priority() const { return at<4>().valid(); } + int32_t client_priority() const { return at<4>().as_int32(); } + bool has_json_agent_label_filter() const { return at<5>().valid(); } + ::protozero::ConstChars json_agent_label_filter() const { return at<5>().as_string(); } +}; + +class ChromeConfig : public ::protozero::Message { + public: + using Decoder = ChromeConfig_Decoder; + enum : int32_t { + kTraceConfigFieldNumber = 1, + kPrivacyFilteringEnabledFieldNumber = 2, + kConvertToLegacyJsonFieldNumber = 3, + kClientPriorityFieldNumber = 4, + kJsonAgentLabelFilterFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ChromeConfig"; } + + + using ClientPriority = ::perfetto::protos::pbzero::ChromeConfig_ClientPriority; + static inline const char* ClientPriority_Name(ClientPriority value) { + return ::perfetto::protos::pbzero::ChromeConfig_ClientPriority_Name(value); + } + static inline const ClientPriority UNKNOWN = ClientPriority::UNKNOWN; + static inline const ClientPriority BACKGROUND = ClientPriority::BACKGROUND; + static inline const ClientPriority USER_INITIATED = ClientPriority::USER_INITIATED; + + using FieldMetadata_TraceConfig = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + ChromeConfig>; + + static constexpr FieldMetadata_TraceConfig kTraceConfig{}; + void set_trace_config(const char* data, size_t size) { + AppendBytes(FieldMetadata_TraceConfig::kFieldId, data, size); + } + void set_trace_config(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_TraceConfig::kFieldId, chars.data, chars.size); + } + void set_trace_config(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_TraceConfig::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PrivacyFilteringEnabled = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + ChromeConfig>; + + static constexpr FieldMetadata_PrivacyFilteringEnabled kPrivacyFilteringEnabled{}; + void set_privacy_filtering_enabled(bool value) { + static constexpr uint32_t field_id = FieldMetadata_PrivacyFilteringEnabled::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ConvertToLegacyJson = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + ChromeConfig>; + + static constexpr FieldMetadata_ConvertToLegacyJson kConvertToLegacyJson{}; + void set_convert_to_legacy_json(bool value) { + static constexpr uint32_t field_id = FieldMetadata_ConvertToLegacyJson::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ClientPriority = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + ChromeConfig_ClientPriority, + ChromeConfig>; + + static constexpr FieldMetadata_ClientPriority kClientPriority{}; + void set_client_priority(ChromeConfig_ClientPriority value) { + static constexpr uint32_t field_id = FieldMetadata_ClientPriority::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_JsonAgentLabelFilter = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + ChromeConfig>; + + static constexpr FieldMetadata_JsonAgentLabelFilter kJsonAgentLabelFilter{}; + void set_json_agent_label_filter(const char* data, size_t size) { + AppendBytes(FieldMetadata_JsonAgentLabelFilter::kFieldId, data, size); + } + void set_json_agent_label_filter(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_JsonAgentLabelFilter::kFieldId, chars.data, chars.size); + } + void set_json_agent_label_filter(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_JsonAgentLabelFilter::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class SurfaceFlingerTransactionsConfig_Decoder : public ::protozero::TypedProtoDecoder { + public: + SurfaceFlingerTransactionsConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit SurfaceFlingerTransactionsConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit SurfaceFlingerTransactionsConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_mode() const { return at<1>().valid(); } + int32_t mode() const { return at<1>().as_int32(); } +}; + +class SurfaceFlingerTransactionsConfig : public ::protozero::Message { + public: + using Decoder = SurfaceFlingerTransactionsConfig_Decoder; + enum : int32_t { + kModeFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.SurfaceFlingerTransactionsConfig"; } + + + using Mode = ::perfetto::protos::pbzero::SurfaceFlingerTransactionsConfig_Mode; + static inline const char* Mode_Name(Mode value) { + return ::perfetto::protos::pbzero::SurfaceFlingerTransactionsConfig_Mode_Name(value); + } + static inline const Mode MODE_UNSPECIFIED = Mode::MODE_UNSPECIFIED; + static inline const Mode MODE_CONTINUOUS = Mode::MODE_CONTINUOUS; + static inline const Mode MODE_ACTIVE = Mode::MODE_ACTIVE; + + using FieldMetadata_Mode = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + SurfaceFlingerTransactionsConfig_Mode, + SurfaceFlingerTransactionsConfig>; + + static constexpr FieldMetadata_Mode kMode{}; + void set_mode(SurfaceFlingerTransactionsConfig_Mode value) { + static constexpr uint32_t field_id = FieldMetadata_Mode::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } +}; + +class SurfaceFlingerLayersConfig_Decoder : public ::protozero::TypedProtoDecoder { + public: + SurfaceFlingerLayersConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit SurfaceFlingerLayersConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit SurfaceFlingerLayersConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_mode() const { return at<1>().valid(); } + int32_t mode() const { return at<1>().as_int32(); } + bool has_trace_flags() const { return at<2>().valid(); } + ::protozero::RepeatedFieldIterator trace_flags() const { return GetRepeated(2); } +}; + +class SurfaceFlingerLayersConfig : public ::protozero::Message { + public: + using Decoder = SurfaceFlingerLayersConfig_Decoder; + enum : int32_t { + kModeFieldNumber = 1, + kTraceFlagsFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.SurfaceFlingerLayersConfig"; } + + + using Mode = ::perfetto::protos::pbzero::SurfaceFlingerLayersConfig_Mode; + static inline const char* Mode_Name(Mode value) { + return ::perfetto::protos::pbzero::SurfaceFlingerLayersConfig_Mode_Name(value); + } + + using TraceFlag = ::perfetto::protos::pbzero::SurfaceFlingerLayersConfig_TraceFlag; + static inline const char* TraceFlag_Name(TraceFlag value) { + return ::perfetto::protos::pbzero::SurfaceFlingerLayersConfig_TraceFlag_Name(value); + } + static inline const Mode MODE_UNSPECIFIED = Mode::MODE_UNSPECIFIED; + static inline const Mode MODE_ACTIVE = Mode::MODE_ACTIVE; + static inline const Mode MODE_GENERATED = Mode::MODE_GENERATED; + static inline const Mode MODE_DUMP = Mode::MODE_DUMP; + static inline const Mode MODE_GENERATED_BUGREPORT_ONLY = Mode::MODE_GENERATED_BUGREPORT_ONLY; + static inline const TraceFlag TRACE_FLAG_UNSPECIFIED = TraceFlag::TRACE_FLAG_UNSPECIFIED; + static inline const TraceFlag TRACE_FLAG_INPUT = TraceFlag::TRACE_FLAG_INPUT; + static inline const TraceFlag TRACE_FLAG_COMPOSITION = TraceFlag::TRACE_FLAG_COMPOSITION; + static inline const TraceFlag TRACE_FLAG_EXTRA = TraceFlag::TRACE_FLAG_EXTRA; + static inline const TraceFlag TRACE_FLAG_HWC = TraceFlag::TRACE_FLAG_HWC; + static inline const TraceFlag TRACE_FLAG_BUFFERS = TraceFlag::TRACE_FLAG_BUFFERS; + static inline const TraceFlag TRACE_FLAG_VIRTUAL_DISPLAYS = TraceFlag::TRACE_FLAG_VIRTUAL_DISPLAYS; + static inline const TraceFlag TRACE_FLAG_ALL = TraceFlag::TRACE_FLAG_ALL; + + using FieldMetadata_Mode = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + SurfaceFlingerLayersConfig_Mode, + SurfaceFlingerLayersConfig>; + + static constexpr FieldMetadata_Mode kMode{}; + void set_mode(SurfaceFlingerLayersConfig_Mode value) { + static constexpr uint32_t field_id = FieldMetadata_Mode::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TraceFlags = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + SurfaceFlingerLayersConfig_TraceFlag, + SurfaceFlingerLayersConfig>; + + static constexpr FieldMetadata_TraceFlags kTraceFlags{}; + void add_trace_flags(SurfaceFlingerLayersConfig_TraceFlag value) { + static constexpr uint32_t field_id = FieldMetadata_TraceFlags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } +}; + +class ProtoLogGroup_Decoder : public ::protozero::TypedProtoDecoder { + public: + ProtoLogGroup_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ProtoLogGroup_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ProtoLogGroup_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_group_name() const { return at<1>().valid(); } + ::protozero::ConstChars group_name() const { return at<1>().as_string(); } + bool has_log_from() const { return at<2>().valid(); } + int32_t log_from() const { return at<2>().as_int32(); } + bool has_collect_stacktrace() const { return at<3>().valid(); } + bool collect_stacktrace() const { return at<3>().as_bool(); } +}; + +class ProtoLogGroup : public ::protozero::Message { + public: + using Decoder = ProtoLogGroup_Decoder; + enum : int32_t { + kGroupNameFieldNumber = 1, + kLogFromFieldNumber = 2, + kCollectStacktraceFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ProtoLogGroup"; } + + + using FieldMetadata_GroupName = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + ProtoLogGroup>; + + static constexpr FieldMetadata_GroupName kGroupName{}; + void set_group_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_GroupName::kFieldId, data, size); + } + void set_group_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_GroupName::kFieldId, chars.data, chars.size); + } + void set_group_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_GroupName::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_LogFrom = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + ProtoLogLevel, + ProtoLogGroup>; + + static constexpr FieldMetadata_LogFrom kLogFrom{}; + void set_log_from(ProtoLogLevel value) { + static constexpr uint32_t field_id = FieldMetadata_LogFrom::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CollectStacktrace = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + ProtoLogGroup>; + + static constexpr FieldMetadata_CollectStacktrace kCollectStacktrace{}; + void set_collect_stacktrace(bool value) { + static constexpr uint32_t field_id = FieldMetadata_CollectStacktrace::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } +}; + +class ProtoLogConfig_Decoder : public ::protozero::TypedProtoDecoder { + public: + ProtoLogConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ProtoLogConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ProtoLogConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_group_overrides() const { return at<1>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> group_overrides() const { return GetRepeated<::protozero::ConstBytes>(1); } + bool has_tracing_mode() const { return at<2>().valid(); } + int32_t tracing_mode() const { return at<2>().as_int32(); } +}; + +class ProtoLogConfig : public ::protozero::Message { + public: + using Decoder = ProtoLogConfig_Decoder; + enum : int32_t { + kGroupOverridesFieldNumber = 1, + kTracingModeFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ProtoLogConfig"; } + + + using TracingMode = ::perfetto::protos::pbzero::ProtoLogConfig_TracingMode; + static inline const char* TracingMode_Name(TracingMode value) { + return ::perfetto::protos::pbzero::ProtoLogConfig_TracingMode_Name(value); + } + static inline const TracingMode DEFAULT = TracingMode::DEFAULT; + static inline const TracingMode ENABLE_ALL = TracingMode::ENABLE_ALL; + + using FieldMetadata_GroupOverrides = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ProtoLogGroup, + ProtoLogConfig>; + + static constexpr FieldMetadata_GroupOverrides kGroupOverrides{}; + template T* add_group_overrides() { + return BeginNestedMessage(1); + } + + + using FieldMetadata_TracingMode = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + ProtoLogConfig_TracingMode, + ProtoLogConfig>; + + static constexpr FieldMetadata_TracingMode kTracingMode{}; + void set_tracing_mode(ProtoLogConfig_TracingMode value) { + static constexpr uint32_t field_id = FieldMetadata_TracingMode::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } +}; + +class PackagesListConfig_Decoder : public ::protozero::TypedProtoDecoder { + public: + PackagesListConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit PackagesListConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit PackagesListConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_package_name_filter() const { return at<1>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstChars> package_name_filter() const { return GetRepeated<::protozero::ConstChars>(1); } +}; + +class PackagesListConfig : public ::protozero::Message { + public: + using Decoder = PackagesListConfig_Decoder; + enum : int32_t { + kPackageNameFilterFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.PackagesListConfig"; } + + + using FieldMetadata_PackageNameFilter = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + PackagesListConfig>; + + static constexpr FieldMetadata_PackageNameFilter kPackageNameFilter{}; + void add_package_name_filter(const char* data, size_t size) { + AppendBytes(FieldMetadata_PackageNameFilter::kFieldId, data, size); + } + void add_package_name_filter(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_PackageNameFilter::kFieldId, chars.data, chars.size); + } + void add_package_name_filter(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_PackageNameFilter::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class NetworkPacketTraceConfig_Decoder : public ::protozero::TypedProtoDecoder { + public: + NetworkPacketTraceConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit NetworkPacketTraceConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit NetworkPacketTraceConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_poll_ms() const { return at<1>().valid(); } + uint32_t poll_ms() const { return at<1>().as_uint32(); } + bool has_aggregation_threshold() const { return at<2>().valid(); } + uint32_t aggregation_threshold() const { return at<2>().as_uint32(); } + bool has_intern_limit() const { return at<3>().valid(); } + uint32_t intern_limit() const { return at<3>().as_uint32(); } + bool has_drop_local_port() const { return at<4>().valid(); } + bool drop_local_port() const { return at<4>().as_bool(); } + bool has_drop_remote_port() const { return at<5>().valid(); } + bool drop_remote_port() const { return at<5>().as_bool(); } + bool has_drop_tcp_flags() const { return at<6>().valid(); } + bool drop_tcp_flags() const { return at<6>().as_bool(); } +}; + +class NetworkPacketTraceConfig : public ::protozero::Message { + public: + using Decoder = NetworkPacketTraceConfig_Decoder; + enum : int32_t { + kPollMsFieldNumber = 1, + kAggregationThresholdFieldNumber = 2, + kInternLimitFieldNumber = 3, + kDropLocalPortFieldNumber = 4, + kDropRemotePortFieldNumber = 5, + kDropTcpFlagsFieldNumber = 6, + }; + static constexpr const char* GetName() { return ".perfetto.protos.NetworkPacketTraceConfig"; } + + + using FieldMetadata_PollMs = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + NetworkPacketTraceConfig>; + + static constexpr FieldMetadata_PollMs kPollMs{}; + void set_poll_ms(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_PollMs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_AggregationThreshold = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + NetworkPacketTraceConfig>; + + static constexpr FieldMetadata_AggregationThreshold kAggregationThreshold{}; + void set_aggregation_threshold(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_AggregationThreshold::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_InternLimit = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + NetworkPacketTraceConfig>; + + static constexpr FieldMetadata_InternLimit kInternLimit{}; + void set_intern_limit(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_InternLimit::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DropLocalPort = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + NetworkPacketTraceConfig>; + + static constexpr FieldMetadata_DropLocalPort kDropLocalPort{}; + void set_drop_local_port(bool value) { + static constexpr uint32_t field_id = FieldMetadata_DropLocalPort::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DropRemotePort = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + NetworkPacketTraceConfig>; + + static constexpr FieldMetadata_DropRemotePort kDropRemotePort{}; + void set_drop_remote_port(bool value) { + static constexpr uint32_t field_id = FieldMetadata_DropRemotePort::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DropTcpFlags = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + NetworkPacketTraceConfig>; + + static constexpr FieldMetadata_DropTcpFlags kDropTcpFlags{}; + void set_drop_tcp_flags(bool value) { + static constexpr uint32_t field_id = FieldMetadata_DropTcpFlags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } +}; + +class AndroidSystemPropertyConfig_Decoder : public ::protozero::TypedProtoDecoder { + public: + AndroidSystemPropertyConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit AndroidSystemPropertyConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit AndroidSystemPropertyConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_poll_ms() const { return at<1>().valid(); } + uint32_t poll_ms() const { return at<1>().as_uint32(); } + bool has_property_name() const { return at<2>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstChars> property_name() const { return GetRepeated<::protozero::ConstChars>(2); } +}; + +class AndroidSystemPropertyConfig : public ::protozero::Message { + public: + using Decoder = AndroidSystemPropertyConfig_Decoder; + enum : int32_t { + kPollMsFieldNumber = 1, + kPropertyNameFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.AndroidSystemPropertyConfig"; } + + + using FieldMetadata_PollMs = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + AndroidSystemPropertyConfig>; + + static constexpr FieldMetadata_PollMs kPollMs{}; + void set_poll_ms(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_PollMs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PropertyName = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + AndroidSystemPropertyConfig>; + + static constexpr FieldMetadata_PropertyName kPropertyName{}; + void add_property_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_PropertyName::kFieldId, data, size); + } + void add_property_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_PropertyName::kFieldId, chars.data, chars.size); + } + void add_property_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_PropertyName::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class AndroidSdkSyspropGuardConfig_Decoder : public ::protozero::TypedProtoDecoder { + public: + AndroidSdkSyspropGuardConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit AndroidSdkSyspropGuardConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit AndroidSdkSyspropGuardConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_surfaceflinger_skia_track_events() const { return at<1>().valid(); } + bool surfaceflinger_skia_track_events() const { return at<1>().as_bool(); } + bool has_hwui_skia_track_events() const { return at<2>().valid(); } + bool hwui_skia_track_events() const { return at<2>().as_bool(); } + bool has_hwui_package_name_filter() const { return at<3>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstChars> hwui_package_name_filter() const { return GetRepeated<::protozero::ConstChars>(3); } +}; + +class AndroidSdkSyspropGuardConfig : public ::protozero::Message { + public: + using Decoder = AndroidSdkSyspropGuardConfig_Decoder; + enum : int32_t { + kSurfaceflingerSkiaTrackEventsFieldNumber = 1, + kHwuiSkiaTrackEventsFieldNumber = 2, + kHwuiPackageNameFilterFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.AndroidSdkSyspropGuardConfig"; } + + + using FieldMetadata_SurfaceflingerSkiaTrackEvents = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + AndroidSdkSyspropGuardConfig>; + + static constexpr FieldMetadata_SurfaceflingerSkiaTrackEvents kSurfaceflingerSkiaTrackEvents{}; + void set_surfaceflinger_skia_track_events(bool value) { + static constexpr uint32_t field_id = FieldMetadata_SurfaceflingerSkiaTrackEvents::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_HwuiSkiaTrackEvents = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + AndroidSdkSyspropGuardConfig>; + + static constexpr FieldMetadata_HwuiSkiaTrackEvents kHwuiSkiaTrackEvents{}; + void set_hwui_skia_track_events(bool value) { + static constexpr uint32_t field_id = FieldMetadata_HwuiSkiaTrackEvents::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_HwuiPackageNameFilter = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + AndroidSdkSyspropGuardConfig>; + + static constexpr FieldMetadata_HwuiPackageNameFilter kHwuiPackageNameFilter{}; + void add_hwui_package_name_filter(const char* data, size_t size) { + AppendBytes(FieldMetadata_HwuiPackageNameFilter::kFieldId, data, size); + } + void add_hwui_package_name_filter(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_HwuiPackageNameFilter::kFieldId, chars.data, chars.size); + } + void add_hwui_package_name_filter(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_HwuiPackageNameFilter::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class AndroidPolledStateConfig_Decoder : public ::protozero::TypedProtoDecoder { + public: + AndroidPolledStateConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit AndroidPolledStateConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit AndroidPolledStateConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_poll_ms() const { return at<1>().valid(); } + uint32_t poll_ms() const { return at<1>().as_uint32(); } +}; + +class AndroidPolledStateConfig : public ::protozero::Message { + public: + using Decoder = AndroidPolledStateConfig_Decoder; + enum : int32_t { + kPollMsFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.AndroidPolledStateConfig"; } + + + using FieldMetadata_PollMs = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + AndroidPolledStateConfig>; + + static constexpr FieldMetadata_PollMs kPollMs{}; + void set_poll_ms(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_PollMs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class AndroidLogConfig_Decoder : public ::protozero::TypedProtoDecoder { + public: + AndroidLogConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit AndroidLogConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit AndroidLogConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_log_ids() const { return at<1>().valid(); } + ::protozero::RepeatedFieldIterator log_ids() const { return GetRepeated(1); } + bool has_min_prio() const { return at<3>().valid(); } + int32_t min_prio() const { return at<3>().as_int32(); } + bool has_filter_tags() const { return at<4>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstChars> filter_tags() const { return GetRepeated<::protozero::ConstChars>(4); } +}; + +class AndroidLogConfig : public ::protozero::Message { + public: + using Decoder = AndroidLogConfig_Decoder; + enum : int32_t { + kLogIdsFieldNumber = 1, + kMinPrioFieldNumber = 3, + kFilterTagsFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.AndroidLogConfig"; } + + + using FieldMetadata_LogIds = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + AndroidLogId, + AndroidLogConfig>; + + static constexpr FieldMetadata_LogIds kLogIds{}; + void add_log_ids(AndroidLogId value) { + static constexpr uint32_t field_id = FieldMetadata_LogIds::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_MinPrio = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + AndroidLogPriority, + AndroidLogConfig>; + + static constexpr FieldMetadata_MinPrio kMinPrio{}; + void set_min_prio(AndroidLogPriority value) { + static constexpr uint32_t field_id = FieldMetadata_MinPrio::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FilterTags = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + AndroidLogConfig>; + + static constexpr FieldMetadata_FilterTags kFilterTags{}; + void add_filter_tags(const char* data, size_t size) { + AppendBytes(FieldMetadata_FilterTags::kFieldId, data, size); + } + void add_filter_tags(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_FilterTags::kFieldId, chars.data, chars.size); + } + void add_filter_tags(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_FilterTags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class AndroidInputEventConfig_Decoder : public ::protozero::TypedProtoDecoder { + public: + AndroidInputEventConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit AndroidInputEventConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit AndroidInputEventConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_mode() const { return at<1>().valid(); } + int32_t mode() const { return at<1>().as_int32(); } + bool has_rules() const { return at<2>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> rules() const { return GetRepeated<::protozero::ConstBytes>(2); } + bool has_trace_dispatcher_input_events() const { return at<3>().valid(); } + bool trace_dispatcher_input_events() const { return at<3>().as_bool(); } + bool has_trace_dispatcher_window_dispatch() const { return at<4>().valid(); } + bool trace_dispatcher_window_dispatch() const { return at<4>().as_bool(); } +}; + +class AndroidInputEventConfig : public ::protozero::Message { + public: + using Decoder = AndroidInputEventConfig_Decoder; + enum : int32_t { + kModeFieldNumber = 1, + kRulesFieldNumber = 2, + kTraceDispatcherInputEventsFieldNumber = 3, + kTraceDispatcherWindowDispatchFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.AndroidInputEventConfig"; } + + using TraceRule = ::perfetto::protos::pbzero::AndroidInputEventConfig_TraceRule; + + using TraceMode = ::perfetto::protos::pbzero::AndroidInputEventConfig_TraceMode; + static inline const char* TraceMode_Name(TraceMode value) { + return ::perfetto::protos::pbzero::AndroidInputEventConfig_TraceMode_Name(value); + } + + using TraceLevel = ::perfetto::protos::pbzero::AndroidInputEventConfig_TraceLevel; + static inline const char* TraceLevel_Name(TraceLevel value) { + return ::perfetto::protos::pbzero::AndroidInputEventConfig_TraceLevel_Name(value); + } + static inline const TraceMode TRACE_MODE_TRACE_ALL = TraceMode::TRACE_MODE_TRACE_ALL; + static inline const TraceMode TRACE_MODE_USE_RULES = TraceMode::TRACE_MODE_USE_RULES; + static inline const TraceLevel TRACE_LEVEL_NONE = TraceLevel::TRACE_LEVEL_NONE; + static inline const TraceLevel TRACE_LEVEL_REDACTED = TraceLevel::TRACE_LEVEL_REDACTED; + static inline const TraceLevel TRACE_LEVEL_COMPLETE = TraceLevel::TRACE_LEVEL_COMPLETE; + + using FieldMetadata_Mode = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + AndroidInputEventConfig_TraceMode, + AndroidInputEventConfig>; + + static constexpr FieldMetadata_Mode kMode{}; + void set_mode(AndroidInputEventConfig_TraceMode value) { + static constexpr uint32_t field_id = FieldMetadata_Mode::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Rules = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + AndroidInputEventConfig_TraceRule, + AndroidInputEventConfig>; + + static constexpr FieldMetadata_Rules kRules{}; + template T* add_rules() { + return BeginNestedMessage(2); + } + + + using FieldMetadata_TraceDispatcherInputEvents = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + AndroidInputEventConfig>; + + static constexpr FieldMetadata_TraceDispatcherInputEvents kTraceDispatcherInputEvents{}; + void set_trace_dispatcher_input_events(bool value) { + static constexpr uint32_t field_id = FieldMetadata_TraceDispatcherInputEvents::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TraceDispatcherWindowDispatch = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + AndroidInputEventConfig>; + + static constexpr FieldMetadata_TraceDispatcherWindowDispatch kTraceDispatcherWindowDispatch{}; + void set_trace_dispatcher_window_dispatch(bool value) { + static constexpr uint32_t field_id = FieldMetadata_TraceDispatcherWindowDispatch::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } +}; + +class AndroidInputEventConfig_TraceRule_Decoder : public ::protozero::TypedProtoDecoder { + public: + AndroidInputEventConfig_TraceRule_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit AndroidInputEventConfig_TraceRule_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit AndroidInputEventConfig_TraceRule_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_trace_level() const { return at<1>().valid(); } + int32_t trace_level() const { return at<1>().as_int32(); } + bool has_match_all_packages() const { return at<2>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstChars> match_all_packages() const { return GetRepeated<::protozero::ConstChars>(2); } + bool has_match_any_packages() const { return at<3>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstChars> match_any_packages() const { return GetRepeated<::protozero::ConstChars>(3); } + bool has_match_secure() const { return at<4>().valid(); } + bool match_secure() const { return at<4>().as_bool(); } + bool has_match_ime_connection_active() const { return at<5>().valid(); } + bool match_ime_connection_active() const { return at<5>().as_bool(); } +}; + +class AndroidInputEventConfig_TraceRule : public ::protozero::Message { + public: + using Decoder = AndroidInputEventConfig_TraceRule_Decoder; + enum : int32_t { + kTraceLevelFieldNumber = 1, + kMatchAllPackagesFieldNumber = 2, + kMatchAnyPackagesFieldNumber = 3, + kMatchSecureFieldNumber = 4, + kMatchImeConnectionActiveFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.AndroidInputEventConfig.TraceRule"; } + + + using FieldMetadata_TraceLevel = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + AndroidInputEventConfig_TraceLevel, + AndroidInputEventConfig_TraceRule>; + + static constexpr FieldMetadata_TraceLevel kTraceLevel{}; + void set_trace_level(AndroidInputEventConfig_TraceLevel value) { + static constexpr uint32_t field_id = FieldMetadata_TraceLevel::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_MatchAllPackages = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + AndroidInputEventConfig_TraceRule>; + + static constexpr FieldMetadata_MatchAllPackages kMatchAllPackages{}; + void add_match_all_packages(const char* data, size_t size) { + AppendBytes(FieldMetadata_MatchAllPackages::kFieldId, data, size); + } + void add_match_all_packages(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_MatchAllPackages::kFieldId, chars.data, chars.size); + } + void add_match_all_packages(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_MatchAllPackages::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_MatchAnyPackages = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + AndroidInputEventConfig_TraceRule>; + + static constexpr FieldMetadata_MatchAnyPackages kMatchAnyPackages{}; + void add_match_any_packages(const char* data, size_t size) { + AppendBytes(FieldMetadata_MatchAnyPackages::kFieldId, data, size); + } + void add_match_any_packages(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_MatchAnyPackages::kFieldId, chars.data, chars.size); + } + void add_match_any_packages(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_MatchAnyPackages::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_MatchSecure = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + AndroidInputEventConfig_TraceRule>; + + static constexpr FieldMetadata_MatchSecure kMatchSecure{}; + void set_match_secure(bool value) { + static constexpr uint32_t field_id = FieldMetadata_MatchSecure::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_MatchImeConnectionActive = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + AndroidInputEventConfig_TraceRule>; + + static constexpr FieldMetadata_MatchImeConnectionActive kMatchImeConnectionActive{}; + void set_match_ime_connection_active(bool value) { + static constexpr uint32_t field_id = FieldMetadata_MatchImeConnectionActive::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } +}; + +class AndroidGameInterventionListConfig_Decoder : public ::protozero::TypedProtoDecoder { + public: + AndroidGameInterventionListConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit AndroidGameInterventionListConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit AndroidGameInterventionListConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_package_name_filter() const { return at<1>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstChars> package_name_filter() const { return GetRepeated<::protozero::ConstChars>(1); } +}; + +class AndroidGameInterventionListConfig : public ::protozero::Message { + public: + using Decoder = AndroidGameInterventionListConfig_Decoder; + enum : int32_t { + kPackageNameFilterFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.AndroidGameInterventionListConfig"; } + + + using FieldMetadata_PackageNameFilter = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + AndroidGameInterventionListConfig>; + + static constexpr FieldMetadata_PackageNameFilter kPackageNameFilter{}; + void add_package_name_filter(const char* data, size_t size) { + AppendBytes(FieldMetadata_PackageNameFilter::kFieldId, data, size); + } + void add_package_name_filter(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_PackageNameFilter::kFieldId, chars.data, chars.size); + } + void add_package_name_filter(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_PackageNameFilter::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class TracingServiceState_Decoder : public ::protozero::TypedProtoDecoder { + public: + TracingServiceState_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TracingServiceState_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TracingServiceState_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_producers() const { return at<1>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> producers() const { return GetRepeated<::protozero::ConstBytes>(1); } + bool has_data_sources() const { return at<2>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> data_sources() const { return GetRepeated<::protozero::ConstBytes>(2); } + bool has_tracing_sessions() const { return at<6>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> tracing_sessions() const { return GetRepeated<::protozero::ConstBytes>(6); } + bool has_supports_tracing_sessions() const { return at<7>().valid(); } + bool supports_tracing_sessions() const { return at<7>().as_bool(); } + bool has_num_sessions() const { return at<3>().valid(); } + int32_t num_sessions() const { return at<3>().as_int32(); } + bool has_num_sessions_started() const { return at<4>().valid(); } + int32_t num_sessions_started() const { return at<4>().as_int32(); } + bool has_tracing_service_version() const { return at<5>().valid(); } + ::protozero::ConstChars tracing_service_version() const { return at<5>().as_string(); } +}; + +class TracingServiceState : public ::protozero::Message { + public: + using Decoder = TracingServiceState_Decoder; + enum : int32_t { + kProducersFieldNumber = 1, + kDataSourcesFieldNumber = 2, + kTracingSessionsFieldNumber = 6, + kSupportsTracingSessionsFieldNumber = 7, + kNumSessionsFieldNumber = 3, + kNumSessionsStartedFieldNumber = 4, + kTracingServiceVersionFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.TracingServiceState"; } + + using Producer = ::perfetto::protos::pbzero::TracingServiceState_Producer; + using DataSource = ::perfetto::protos::pbzero::TracingServiceState_DataSource; + using TracingSession = ::perfetto::protos::pbzero::TracingServiceState_TracingSession; + + using FieldMetadata_Producers = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TracingServiceState_Producer, + TracingServiceState>; + + static constexpr FieldMetadata_Producers kProducers{}; + template T* add_producers() { + return BeginNestedMessage(1); + } + + + using FieldMetadata_DataSources = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TracingServiceState_DataSource, + TracingServiceState>; + + static constexpr FieldMetadata_DataSources kDataSources{}; + template T* add_data_sources() { + return BeginNestedMessage(2); + } + + + using FieldMetadata_TracingSessions = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TracingServiceState_TracingSession, + TracingServiceState>; + + static constexpr FieldMetadata_TracingSessions kTracingSessions{}; + template T* add_tracing_sessions() { + return BeginNestedMessage(6); + } + + + using FieldMetadata_SupportsTracingSessions = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + TracingServiceState>; + + static constexpr FieldMetadata_SupportsTracingSessions kSupportsTracingSessions{}; + void set_supports_tracing_sessions(bool value) { + static constexpr uint32_t field_id = FieldMetadata_SupportsTracingSessions::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NumSessions = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + TracingServiceState>; + + static constexpr FieldMetadata_NumSessions kNumSessions{}; + void set_num_sessions(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_NumSessions::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NumSessionsStarted = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + TracingServiceState>; + + static constexpr FieldMetadata_NumSessionsStarted kNumSessionsStarted{}; + void set_num_sessions_started(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_NumSessionsStarted::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TracingServiceVersion = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + TracingServiceState>; + + static constexpr FieldMetadata_TracingServiceVersion kTracingServiceVersion{}; + void set_tracing_service_version(const char* data, size_t size) { + AppendBytes(FieldMetadata_TracingServiceVersion::kFieldId, data, size); + } + void set_tracing_service_version(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_TracingServiceVersion::kFieldId, chars.data, chars.size); + } + void set_tracing_service_version(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_TracingServiceVersion::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class TracingServiceState_TracingSession_Decoder : public ::protozero::TypedProtoDecoder { + public: + TracingServiceState_TracingSession_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TracingServiceState_TracingSession_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TracingServiceState_TracingSession_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_id() const { return at<1>().valid(); } + uint64_t id() const { return at<1>().as_uint64(); } + bool has_consumer_uid() const { return at<2>().valid(); } + int32_t consumer_uid() const { return at<2>().as_int32(); } + bool has_state() const { return at<3>().valid(); } + ::protozero::ConstChars state() const { return at<3>().as_string(); } + bool has_unique_session_name() const { return at<4>().valid(); } + ::protozero::ConstChars unique_session_name() const { return at<4>().as_string(); } + bool has_buffer_size_kb() const { return at<5>().valid(); } + ::protozero::RepeatedFieldIterator buffer_size_kb() const { return GetRepeated(5); } + bool has_duration_ms() const { return at<6>().valid(); } + uint32_t duration_ms() const { return at<6>().as_uint32(); } + bool has_num_data_sources() const { return at<7>().valid(); } + uint32_t num_data_sources() const { return at<7>().as_uint32(); } + bool has_start_realtime_ns() const { return at<8>().valid(); } + int64_t start_realtime_ns() const { return at<8>().as_int64(); } + bool has_bugreport_score() const { return at<9>().valid(); } + int32_t bugreport_score() const { return at<9>().as_int32(); } + bool has_bugreport_filename() const { return at<10>().valid(); } + ::protozero::ConstChars bugreport_filename() const { return at<10>().as_string(); } + bool has_is_started() const { return at<11>().valid(); } + bool is_started() const { return at<11>().as_bool(); } +}; + +class TracingServiceState_TracingSession : public ::protozero::Message { + public: + using Decoder = TracingServiceState_TracingSession_Decoder; + enum : int32_t { + kIdFieldNumber = 1, + kConsumerUidFieldNumber = 2, + kStateFieldNumber = 3, + kUniqueSessionNameFieldNumber = 4, + kBufferSizeKbFieldNumber = 5, + kDurationMsFieldNumber = 6, + kNumDataSourcesFieldNumber = 7, + kStartRealtimeNsFieldNumber = 8, + kBugreportScoreFieldNumber = 9, + kBugreportFilenameFieldNumber = 10, + kIsStartedFieldNumber = 11, + }; + static constexpr const char* GetName() { return ".perfetto.protos.TracingServiceState.TracingSession"; } + + + using FieldMetadata_Id = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TracingServiceState_TracingSession>; + + static constexpr FieldMetadata_Id kId{}; + void set_id(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ConsumerUid = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + TracingServiceState_TracingSession>; + + static constexpr FieldMetadata_ConsumerUid kConsumerUid{}; + void set_consumer_uid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ConsumerUid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_State = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + TracingServiceState_TracingSession>; + + static constexpr FieldMetadata_State kState{}; + void set_state(const char* data, size_t size) { + AppendBytes(FieldMetadata_State::kFieldId, data, size); + } + void set_state(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_State::kFieldId, chars.data, chars.size); + } + void set_state(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_State::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_UniqueSessionName = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + TracingServiceState_TracingSession>; + + static constexpr FieldMetadata_UniqueSessionName kUniqueSessionName{}; + void set_unique_session_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_UniqueSessionName::kFieldId, data, size); + } + void set_unique_session_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_UniqueSessionName::kFieldId, chars.data, chars.size); + } + void set_unique_session_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_UniqueSessionName::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_BufferSizeKb = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + TracingServiceState_TracingSession>; + + static constexpr FieldMetadata_BufferSizeKb kBufferSizeKb{}; + void add_buffer_size_kb(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_BufferSizeKb::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DurationMs = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + TracingServiceState_TracingSession>; + + static constexpr FieldMetadata_DurationMs kDurationMs{}; + void set_duration_ms(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_DurationMs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NumDataSources = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + TracingServiceState_TracingSession>; + + static constexpr FieldMetadata_NumDataSources kNumDataSources{}; + void set_num_data_sources(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_NumDataSources::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_StartRealtimeNs = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + TracingServiceState_TracingSession>; + + static constexpr FieldMetadata_StartRealtimeNs kStartRealtimeNs{}; + void set_start_realtime_ns(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_StartRealtimeNs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_BugreportScore = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + TracingServiceState_TracingSession>; + + static constexpr FieldMetadata_BugreportScore kBugreportScore{}; + void set_bugreport_score(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_BugreportScore::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_BugreportFilename = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + TracingServiceState_TracingSession>; + + static constexpr FieldMetadata_BugreportFilename kBugreportFilename{}; + void set_bugreport_filename(const char* data, size_t size) { + AppendBytes(FieldMetadata_BugreportFilename::kFieldId, data, size); + } + void set_bugreport_filename(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_BugreportFilename::kFieldId, chars.data, chars.size); + } + void set_bugreport_filename(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_BugreportFilename::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_IsStarted = + ::protozero::proto_utils::FieldMetadata< + 11, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + TracingServiceState_TracingSession>; + + static constexpr FieldMetadata_IsStarted kIsStarted{}; + void set_is_started(bool value) { + static constexpr uint32_t field_id = FieldMetadata_IsStarted::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } +}; + +class TracingServiceState_DataSource_Decoder : public ::protozero::TypedProtoDecoder { + public: + TracingServiceState_DataSource_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TracingServiceState_DataSource_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TracingServiceState_DataSource_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_ds_descriptor() const { return at<1>().valid(); } + ::protozero::ConstBytes ds_descriptor() const { return at<1>().as_bytes(); } + bool has_producer_id() const { return at<2>().valid(); } + int32_t producer_id() const { return at<2>().as_int32(); } +}; + +class TracingServiceState_DataSource : public ::protozero::Message { + public: + using Decoder = TracingServiceState_DataSource_Decoder; + enum : int32_t { + kDsDescriptorFieldNumber = 1, + kProducerIdFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.TracingServiceState.DataSource"; } + + + using FieldMetadata_DsDescriptor = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + DataSourceDescriptor, + TracingServiceState_DataSource>; + + static constexpr FieldMetadata_DsDescriptor kDsDescriptor{}; + template T* set_ds_descriptor() { + return BeginNestedMessage(1); + } + + + using FieldMetadata_ProducerId = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + TracingServiceState_DataSource>; + + static constexpr FieldMetadata_ProducerId kProducerId{}; + void set_producer_id(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ProducerId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class TracingServiceState_Producer_Decoder : public ::protozero::TypedProtoDecoder { + public: + TracingServiceState_Producer_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TracingServiceState_Producer_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TracingServiceState_Producer_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_id() const { return at<1>().valid(); } + int32_t id() const { return at<1>().as_int32(); } + bool has_name() const { return at<2>().valid(); } + ::protozero::ConstChars name() const { return at<2>().as_string(); } + bool has_pid() const { return at<5>().valid(); } + int32_t pid() const { return at<5>().as_int32(); } + bool has_uid() const { return at<3>().valid(); } + int32_t uid() const { return at<3>().as_int32(); } + bool has_sdk_version() const { return at<4>().valid(); } + ::protozero::ConstChars sdk_version() const { return at<4>().as_string(); } +}; + +class TracingServiceState_Producer : public ::protozero::Message { + public: + using Decoder = TracingServiceState_Producer_Decoder; + enum : int32_t { + kIdFieldNumber = 1, + kNameFieldNumber = 2, + kPidFieldNumber = 5, + kUidFieldNumber = 3, + kSdkVersionFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.TracingServiceState.Producer"; } + + + using FieldMetadata_Id = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + TracingServiceState_Producer>; + + static constexpr FieldMetadata_Id kId{}; + void set_id(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + TracingServiceState_Producer>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Pid = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + TracingServiceState_Producer>; + + static constexpr FieldMetadata_Pid kPid{}; + void set_pid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Uid = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + TracingServiceState_Producer>; + + static constexpr FieldMetadata_Uid kUid{}; + void set_uid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Uid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SdkVersion = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + TracingServiceState_Producer>; + + static constexpr FieldMetadata_SdkVersion kSdkVersion{}; + void set_sdk_version(const char* data, size_t size) { + AppendBytes(FieldMetadata_SdkVersion::kFieldId, data, size); + } + void set_sdk_version(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_SdkVersion::kFieldId, chars.data, chars.size); + } + void set_sdk_version(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_SdkVersion::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class DataSourceDescriptor_Decoder : public ::protozero::TypedProtoDecoder { + public: + DataSourceDescriptor_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit DataSourceDescriptor_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit DataSourceDescriptor_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_name() const { return at<1>().valid(); } + ::protozero::ConstChars name() const { return at<1>().as_string(); } + bool has_id() const { return at<7>().valid(); } + uint64_t id() const { return at<7>().as_uint64(); } + bool has_will_notify_on_stop() const { return at<2>().valid(); } + bool will_notify_on_stop() const { return at<2>().as_bool(); } + bool has_will_notify_on_start() const { return at<3>().valid(); } + bool will_notify_on_start() const { return at<3>().as_bool(); } + bool has_handles_incremental_state_clear() const { return at<4>().valid(); } + bool handles_incremental_state_clear() const { return at<4>().as_bool(); } + bool has_no_flush() const { return at<9>().valid(); } + bool no_flush() const { return at<9>().as_bool(); } + bool has_track_event_descriptor() const { return at<6>().valid(); } + ::protozero::ConstBytes track_event_descriptor() const { return at<6>().as_bytes(); } + bool has_ftrace_descriptor() const { return at<8>().valid(); } + ::protozero::ConstBytes ftrace_descriptor() const { return at<8>().as_bytes(); } +}; + +class DataSourceDescriptor : public ::protozero::Message { + public: + using Decoder = DataSourceDescriptor_Decoder; + enum : int32_t { + kNameFieldNumber = 1, + kIdFieldNumber = 7, + kWillNotifyOnStopFieldNumber = 2, + kWillNotifyOnStartFieldNumber = 3, + kHandlesIncrementalStateClearFieldNumber = 4, + kNoFlushFieldNumber = 9, + kTrackEventDescriptorFieldNumber = 6, + kFtraceDescriptorFieldNumber = 8, + }; + static constexpr const char* GetName() { return ".perfetto.protos.DataSourceDescriptor"; } + + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + DataSourceDescriptor>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Id = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + DataSourceDescriptor>; + + static constexpr FieldMetadata_Id kId{}; + void set_id(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_WillNotifyOnStop = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + DataSourceDescriptor>; + + static constexpr FieldMetadata_WillNotifyOnStop kWillNotifyOnStop{}; + void set_will_notify_on_stop(bool value) { + static constexpr uint32_t field_id = FieldMetadata_WillNotifyOnStop::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_WillNotifyOnStart = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + DataSourceDescriptor>; + + static constexpr FieldMetadata_WillNotifyOnStart kWillNotifyOnStart{}; + void set_will_notify_on_start(bool value) { + static constexpr uint32_t field_id = FieldMetadata_WillNotifyOnStart::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_HandlesIncrementalStateClear = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + DataSourceDescriptor>; + + static constexpr FieldMetadata_HandlesIncrementalStateClear kHandlesIncrementalStateClear{}; + void set_handles_incremental_state_clear(bool value) { + static constexpr uint32_t field_id = FieldMetadata_HandlesIncrementalStateClear::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_NoFlush = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + DataSourceDescriptor>; + + static constexpr FieldMetadata_NoFlush kNoFlush{}; + void set_no_flush(bool value) { + static constexpr uint32_t field_id = FieldMetadata_NoFlush::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TrackEventDescriptor = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TrackEventDescriptor, + DataSourceDescriptor>; + + static constexpr FieldMetadata_TrackEventDescriptor kTrackEventDescriptor{}; + template T* set_track_event_descriptor() { + return BeginNestedMessage(6); + } + + void set_track_event_descriptor_raw(const std::string& raw) { + return AppendBytes(6, raw.data(), raw.size()); + } + + + using FieldMetadata_FtraceDescriptor = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + FtraceDescriptor, + DataSourceDescriptor>; + + static constexpr FieldMetadata_FtraceDescriptor kFtraceDescriptor{}; + template T* set_ftrace_descriptor() { + return BeginNestedMessage(8); + } + + void set_ftrace_descriptor_raw(const std::string& raw) { + return AppendBytes(8, raw.data(), raw.size()); + } + +}; + +class TrackEventDescriptor_Decoder : public ::protozero::TypedProtoDecoder { + public: + TrackEventDescriptor_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TrackEventDescriptor_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TrackEventDescriptor_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_available_categories() const { return at<1>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> available_categories() const { return GetRepeated<::protozero::ConstBytes>(1); } +}; + +class TrackEventDescriptor : public ::protozero::Message { + public: + using Decoder = TrackEventDescriptor_Decoder; + enum : int32_t { + kAvailableCategoriesFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.TrackEventDescriptor"; } + + + using FieldMetadata_AvailableCategories = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TrackEventCategory, + TrackEventDescriptor>; + + static constexpr FieldMetadata_AvailableCategories kAvailableCategories{}; + template T* add_available_categories() { + return BeginNestedMessage(1); + } + +}; + +class TrackEventCategory_Decoder : public ::protozero::TypedProtoDecoder { + public: + TrackEventCategory_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TrackEventCategory_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TrackEventCategory_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_name() const { return at<1>().valid(); } + ::protozero::ConstChars name() const { return at<1>().as_string(); } + bool has_description() const { return at<2>().valid(); } + ::protozero::ConstChars description() const { return at<2>().as_string(); } + bool has_tags() const { return at<3>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstChars> tags() const { return GetRepeated<::protozero::ConstChars>(3); } +}; + +class TrackEventCategory : public ::protozero::Message { + public: + using Decoder = TrackEventCategory_Decoder; + enum : int32_t { + kNameFieldNumber = 1, + kDescriptionFieldNumber = 2, + kTagsFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.TrackEventCategory"; } + + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + TrackEventCategory>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Description = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + TrackEventCategory>; + + static constexpr FieldMetadata_Description kDescription{}; + void set_description(const char* data, size_t size) { + AppendBytes(FieldMetadata_Description::kFieldId, data, size); + } + void set_description(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Description::kFieldId, chars.data, chars.size); + } + void set_description(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Description::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Tags = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + TrackEventCategory>; + + static constexpr FieldMetadata_Tags kTags{}; + void add_tags(const char* data, size_t size) { + AppendBytes(FieldMetadata_Tags::kFieldId, data, size); + } + void add_tags(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Tags::kFieldId, chars.data, chars.size); + } + void add_tags(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Tags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class FtraceDescriptor_Decoder : public ::protozero::TypedProtoDecoder { + public: + FtraceDescriptor_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit FtraceDescriptor_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit FtraceDescriptor_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_atrace_categories() const { return at<1>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> atrace_categories() const { return GetRepeated<::protozero::ConstBytes>(1); } +}; + +class FtraceDescriptor : public ::protozero::Message { + public: + using Decoder = FtraceDescriptor_Decoder; + enum : int32_t { + kAtraceCategoriesFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.FtraceDescriptor"; } + + using AtraceCategory = ::perfetto::protos::pbzero::FtraceDescriptor_AtraceCategory; + + using FieldMetadata_AtraceCategories = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + FtraceDescriptor_AtraceCategory, + FtraceDescriptor>; + + static constexpr FieldMetadata_AtraceCategories kAtraceCategories{}; + template T* add_atrace_categories() { + return BeginNestedMessage(1); + } + +}; + +class FtraceDescriptor_AtraceCategory_Decoder : public ::protozero::TypedProtoDecoder { + public: + FtraceDescriptor_AtraceCategory_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit FtraceDescriptor_AtraceCategory_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit FtraceDescriptor_AtraceCategory_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_name() const { return at<1>().valid(); } + ::protozero::ConstChars name() const { return at<1>().as_string(); } + bool has_description() const { return at<2>().valid(); } + ::protozero::ConstChars description() const { return at<2>().as_string(); } +}; + +class FtraceDescriptor_AtraceCategory : public ::protozero::Message { + public: + using Decoder = FtraceDescriptor_AtraceCategory_Decoder; + enum : int32_t { + kNameFieldNumber = 1, + kDescriptionFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.FtraceDescriptor.AtraceCategory"; } + + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + FtraceDescriptor_AtraceCategory>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Description = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + FtraceDescriptor_AtraceCategory>; + + static constexpr FieldMetadata_Description kDescription{}; + void set_description(const char* data, size_t size) { + AppendBytes(FieldMetadata_Description::kFieldId, data, size); + } + void set_description(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Description::kFieldId, chars.data, chars.size); + } + void set_description(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Description::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +} // Namespace. +} // Namespace. +} // Namespace. +#endif // Include guard. diff --git a/src/libtracing/meson.build b/src/libtracing/meson.build new file mode 100644 index 000000000..946c504c9 --- /dev/null +++ b/src/libtracing/meson.build @@ -0,0 +1,47 @@ +libtracing_sources = files( + 'trace-writer.cc', + + 'protozero_src/field.cc', + 'protozero_src/gen_field_helpers.cc', + 'protozero_src/message_arena.cc', + 'protozero_src/message.cc', + 'protozero_src/packed_repeated_fields.cc', + 'protozero_src/proto_decoder.cc', + 'protozero_src/scattered_heap_buffer.cc', + 'protozero_src/scattered_stream_null_delegate.cc', + 'protozero_src/scattered_stream_writer.cc', + 'protozero_src/static_buffer.cc', + 'protozero_src/virtual_destructors.cc', +) + +subdir('perfetto/protozero') + +libtracing_headers = [ + protozero_headers, + files( + 'trace-writer.hh', + ), +] + +libtracing = library( + 'lixtracing', + libtracing_sources, + dependencies : [ ], + install : true, + # FIXME(Qyriad): is this right? + install_rpath : libdir, + cpp_args : [ '-DPERFETTO_DISABLE_LOG' ], + include_directories : include_directories('./perfetto/base/build_configs/bazel'), +) + +liblixtracing = declare_dependency( + include_directories : include_directories('.'), + link_with : libtracing, +) + +tracing_test = executable( + 'lixtracingtest', + files('main.cc'), + dependencies : [ liblixtracing ], + install : false, +) diff --git a/src/libtracing/trace-writer.cc b/src/libtracing/trace-writer.cc new file mode 100644 index 000000000..aefda13ae --- /dev/null +++ b/src/libtracing/trace-writer.cc @@ -0,0 +1,190 @@ +#include "meow/protos/perfetto/trace/perfetto_trace.pbzero.h" +#include "perfetto/protozero/message.h" +#include "perfetto/protozero/message_handle.h" +#include "perfetto/protozero/scattered_heap_buffer.h" +#include "perfetto/protozero/scattered_stream_writer.h" +#include "trace-writer.hh" +#include +#include +#include + +template<> +struct std::hash +{ + size_t operator()(const nix::tracing::InternedPos p) const + { + return std::hash()(p.key); + } +}; + +template<> +struct std::hash +{ + size_t operator()(const nix::tracing::InternedName p) const + { + return std::hash()(p.key); + } +}; + +namespace nix::tracing { + +using namespace perfetto::protos::pbzero; + +struct ProtoInternedPos +{ + uint32_t key; + + explicit ProtoInternedPos(uint32_t key) : key(key) {} + ProtoInternedPos() = delete; +}; + +struct ProtoInternedName +{ + uint32_t key; + + explicit ProtoInternedName(uint32_t key) : key(key) {} + ProtoInternedName() = delete; +}; + +struct TraceWriter::Impl +{ + std::unique_ptr retriever_; + protozero::ScatteredHeapBuffer buf_; + protozero::ScatteredStreamWriter writer_; + protozero::MessageArena arena_; + + Trace trace_; + protozero::MessageHandle traceHandle_; + + std::unordered_map posMap_; + uint64_t posIid_ = 1; + + std::unordered_map nameMap_; + uint64_t nameIid_ = 1; + + auto getName(InternedName name, std::optional &outName) -> ProtoInternedName; + + auto getPos(InternedPos pos, InternedName funcName, std::optional &outPos) -> ProtoInternedPos; + + Impl(std::unique_ptr retriever) + : retriever_(std::move(retriever)) + , writer_(&this->buf_) + , traceHandle_(&this->trace_) + { + buf_.set_writer(&this->writer_); + trace_.Reset(&this->writer_, &this->arena_); + + auto p = protozero::MessageHandle(trace_.add_packet()); + auto td = protozero::MessageHandle(p->set_track_descriptor()); + td->set_name("track"); + td->set_uuid(1); + + p->set_trusted_packet_sequence_id(1337); + p->set_sequence_flags(perfetto_pbzero_enum_TracePacket::SEQ_INCREMENTAL_STATE_CLEARED); + p->set_previous_packet_dropped(true); + p->set_first_packet_on_sequence(true); + } +}; + +auto TraceWriter::Impl::getName(InternedName name, std::optional &outName) -> ProtoInternedName +{ + if (auto it = nameMap_.find(name); it != nameMap_.end()) { + // one already there, return it + return it->second; + } else { + auto nameStr = retriever_->getName(name); + outName = nameStr; + + auto newIid = ++nameIid_; + nameMap_.insert(std::make_pair(name, newIid)); + return ProtoInternedName(newIid); + } +} + +auto TraceWriter::Impl::getPos(InternedPos pos, InternedName funcName, std::optional &outPos) -> ProtoInternedPos +{ + if (auto it = posMap_.find(pos); it != posMap_.end()) { + // one already there, return it + return it->second; + } else { + auto nameRetrieved = retriever_->getName(funcName); + auto posResolved = retriever_->getPos(pos, nameRetrieved); + outPos = posResolved; + + auto newIid = ++posIid_; + posMap_.insert(std::make_pair(pos, newIid)); + return ProtoInternedPos(newIid); + } +} + +TraceWriter::TraceWriter(std::unique_ptr retriever) + : impl_(std::make_unique(std::move(retriever))) +{ +} + +TraceWriter::~TraceWriter() = default; + +void TraceWriter::begin(InternedPos pos, InternedName name, Timestamp ts) +{ + + std::optional nameToIntern; + std::optional posToIntern; + + auto nameIid = impl_->getName(name, nameToIntern); + auto posIid = impl_->getPos(pos, name, posToIntern); + + auto packet = protozero::MessageHandle(impl_->trace_.add_packet()); + + packet->set_sequence_flags(perfetto_pbzero_enum_TracePacket::SEQ_NEEDS_INCREMENTAL_STATE); + + if (nameToIntern.has_value() || posToIntern.has_value()) { + auto internedData = protozero::MessageHandle(packet->set_interned_data()); + + if (nameToIntern.has_value()) { + auto evName = protozero::MessageHandle(internedData->add_event_names()); + evName->set_name(*nameToIntern); + evName->set_iid(nameIid.key); + } + + if (posToIntern.has_value()) { + auto sourceLoc = protozero::MessageHandle(internedData->add_source_locations()); + sourceLoc->set_iid(posIid.key); + sourceLoc->set_file_name(posToIntern->fileName); + sourceLoc->set_function_name(posToIntern->functionName); + sourceLoc->set_line_number(posToIntern->lineNumber); + } + } + + packet->set_timestamp(ts.monotonic_nanos); + packet->set_trusted_packet_sequence_id(1337); + auto te = protozero::MessageHandle(packet->set_track_event()); + te->set_type(perfetto_pbzero_enum_TrackEvent::TYPE_SLICE_BEGIN); + te->set_name_iid(nameIid.key); + te->set_source_location_iid(posIid.key); + + // TODO: make a real value + te->set_track_uuid(1); + + // te->set_name_iid(nameIid.key); + // te->set_name("meow"); + // TODO: te->set_source_location_iid(); +} + +void TraceWriter::end(Timestamp ts) +{ + protozero::MessageHandle tp(impl_->trace_.add_packet()); + tp->set_timestamp(ts.monotonic_nanos); + tp->set_trusted_packet_sequence_id(1337); + + protozero::MessageHandle te(tp->set_track_event()); + te->set_type(perfetto_pbzero_enum_TrackEvent::TYPE_SLICE_END); + te->set_track_uuid(1); +} + +auto TraceWriter::splat() const -> std::vector +{ + impl_->traceHandle_->Finalize(); + return impl_->buf_.StitchSlices(); +} + +} diff --git a/src/libtracing/trace-writer.hh b/src/libtracing/trace-writer.hh new file mode 100644 index 000000000..e864d0052 --- /dev/null +++ b/src/libtracing/trace-writer.hh @@ -0,0 +1,67 @@ +#pragma once +///@file + +#include +#include +#include +#include +#include +#include + +namespace nix::tracing { + +struct InternedPos +{ + uint32_t key; + + auto operator<=>(InternedPos const & other) const = default; + explicit InternedPos(uint32_t key) : key(key) {} +}; + +struct InternedName +{ + uint32_t key; + + auto operator<=>(InternedName const & other) const = default; + explicit InternedName(uint32_t key) : key(key) {} +}; + +struct Timestamp +{ + uint64_t monotonic_nanos; +}; + +struct TracePos +{ + std::string fileName; + std::string functionName; + uint32_t lineNumber; +}; + +/** Abstract class that retrieves information about things if they are not + * memoized already */ +struct InternedRetriever +{ + virtual auto getName(InternedName idx) const -> std::string = 0; + virtual auto getPos(InternedPos idx, std::string funcName) const -> TracePos = 0; + + virtual ~InternedRetriever() = default; +}; + +class TraceWriter +{ + struct Impl; + std::unique_ptr impl_; +public: + TraceWriter(std::unique_ptr retriever); + + void begin(InternedPos pos, InternedName name, Timestamp ts); + void end(Timestamp ts); + + /** Splats the trace out into a buffer */ + auto splat() const -> std::vector; + + ~TraceWriter(); +}; + +} diff --git a/src/meson.build b/src/meson.build index 3fc5595b8..bc5ad44dd 100644 --- a/src/meson.build +++ b/src/meson.build @@ -5,6 +5,8 @@ subdir('libutil') subdir('libstore') # libfetchers depends on libstore subdir('libfetchers') +# libtracing is self-contained +subdir('libtracing') # libexpr depends on all of the above subdir('libexpr') # libmain depends on libutil and libstore -- 2.44.1 From dace8fa1a4f83cd6e959173f0ec03b1b636accbc Mon Sep 17 00:00:00 2001 From: Jade Lovelace Date: Wed, 8 May 2024 14:56:43 -0700 Subject: [PATCH 2/4] horrid vendoring Change-Id: Idf7891fe0fdbfed4e9ad660aa7613a67cb55e304 --- src/libtracing/perfetto/base/BUILD.gn | 33 + src/libtracing/perfetto/base/build_config.h | 160 + .../android_tree/perfetto_build_flags.h | 51 + .../bazel/perfetto_build_flags.h | 51 + src/libtracing/perfetto/base/compiler.h | 157 + src/libtracing/perfetto/base/export.h | 41 + src/libtracing/perfetto/base/flat_set.h | 100 + src/libtracing/perfetto/base/logging.h | 248 + .../perfetto/base/platform_handle.h | 71 + src/libtracing/perfetto/base/proc_utils.h | 59 + src/libtracing/perfetto/base/status.h | 117 + src/libtracing/perfetto/base/task_runner.h | 78 + src/libtracing/perfetto/base/template_util.h | 75 + src/libtracing/perfetto/base/thread_utils.h | 85 + src/libtracing/perfetto/base/time.h | 294 + src/libtracing/perfetto/ext/base/BUILD.gn | 73 + .../perfetto/ext/base/android_utils.h | 39 + src/libtracing/perfetto/ext/base/base64.h | 68 + .../perfetto/ext/base/circular_queue.h | 337 + .../perfetto/ext/base/container_annotations.h | 59 + src/libtracing/perfetto/ext/base/crash_keys.h | 162 + .../perfetto/ext/base/ctrl_c_handler.h | 32 + src/libtracing/perfetto/ext/base/endian.h | 58 + src/libtracing/perfetto/ext/base/event_fd.h | 64 + src/libtracing/perfetto/ext/base/file_utils.h | 114 + .../perfetto/ext/base/flat_hash_map.h | 395 + src/libtracing/perfetto/ext/base/getopt.h | 51 + .../perfetto/ext/base/getopt_compat.h | 71 + src/libtracing/perfetto/ext/base/hash.h | 137 + .../perfetto/ext/base/http/BUILD.gn | 21 + .../perfetto/ext/base/http/http_server.h | 189 + src/libtracing/perfetto/ext/base/http/sha1.h | 39 + src/libtracing/perfetto/ext/base/metatrace.h | 318 + .../perfetto/ext/base/metatrace_events.h | 117 + .../perfetto/ext/base/no_destructor.h | 78 + .../perfetto/ext/base/paged_memory.h | 105 + .../perfetto/ext/base/periodic_task.h | 90 + src/libtracing/perfetto/ext/base/pipe.h | 50 + src/libtracing/perfetto/ext/base/platform.h | 40 + .../perfetto/ext/base/scoped_file.h | 122 + .../perfetto/ext/base/scoped_mmap.h | 92 + src/libtracing/perfetto/ext/base/small_set.h | 62 + .../perfetto/ext/base/small_vector.h | 197 + src/libtracing/perfetto/ext/base/status_or.h | 83 + .../perfetto/ext/base/string_splitter.h | 90 + .../perfetto/ext/base/string_utils.h | 233 + .../perfetto/ext/base/string_view.h | 201 + .../perfetto/ext/base/string_writer.h | 183 + src/libtracing/perfetto/ext/base/subprocess.h | 281 + src/libtracing/perfetto/ext/base/sys_types.h | 63 + src/libtracing/perfetto/ext/base/temp_file.h | 80 + .../perfetto/ext/base/thread_annotations.h | 38 + .../perfetto/ext/base/thread_checker.h | 68 + .../perfetto/ext/base/thread_task_runner.h | 85 + .../perfetto/ext/base/thread_utils.h | 90 + .../perfetto/ext/base/threading/BUILD.gn | 33 + .../perfetto/ext/base/threading/channel.h | 180 + .../perfetto/ext/base/threading/future.h | 149 + .../ext/base/threading/future_combinators.h | 76 + .../perfetto/ext/base/threading/poll.h | 245 + .../perfetto/ext/base/threading/spawn.h | 149 + .../perfetto/ext/base/threading/stream.h | 190 + .../ext/base/threading/stream_combinators.h | 315 + .../perfetto/ext/base/threading/thread_pool.h | 80 + .../perfetto/ext/base/threading/util.h | 210 + .../perfetto/ext/base/unix_socket.h | 464 + .../perfetto/ext/base/unix_task_runner.h | 133 + src/libtracing/perfetto/ext/base/utils.h | 196 + src/libtracing/perfetto/ext/base/uuid.h | 75 + src/libtracing/perfetto/ext/base/version.h | 47 + .../perfetto/ext/base/waitable_event.h | 50 + src/libtracing/perfetto/ext/base/watchdog.h | 79 + .../perfetto/ext/base/watchdog_noop.h | 51 + .../perfetto/ext/base/watchdog_posix.h | 202 + src/libtracing/perfetto/ext/base/weak_ptr.h | 120 + src/libtracing/perfetto/ext/ipc/BUILD.gn | 32 + .../perfetto/ext/ipc/async_result.h | 74 + src/libtracing/perfetto/ext/ipc/basic_types.h | 55 + src/libtracing/perfetto/ext/ipc/client.h | 89 + src/libtracing/perfetto/ext/ipc/client_info.h | 77 + .../perfetto/ext/ipc/codegen_helpers.h | 54 + src/libtracing/perfetto/ext/ipc/deferred.h | 136 + src/libtracing/perfetto/ext/ipc/host.h | 83 + src/libtracing/perfetto/ext/ipc/service.h | 80 + .../perfetto/ext/ipc/service_descriptor.h | 72 + .../perfetto/ext/ipc/service_proxy.h | 102 + .../perfetto/ext/protozero/BUILD.gn | 21 + .../ext/protozero/proto_ring_buffer.h | 153 + .../perfetto/ext/trace_processor/BUILD.gn | 27 + .../perfetto/ext/trace_processor/demangle.h | 34 + .../ext/trace_processor/export_json.h | 63 + .../importers/memory_tracker/BUILD.gn | 31 + .../importers/memory_tracker/graph.h | 316 + .../memory_tracker/graph_processor.h | 250 + .../memory_tracker/memory_allocator_node_id.h | 62 + .../memory_tracker/memory_graph_edge.h | 55 + .../memory_tracker/raw_memory_graph_node.h | 147 + .../memory_tracker/raw_process_memory_node.h | 86 + .../perfetto/ext/trace_processor/rpc/BUILD.gn | 19 + .../rpc/query_result_serializer.h | 102 + src/libtracing/perfetto/ext/traced/BUILD.gn | 29 + .../perfetto/ext/traced/data_source_types.h | 62 + .../perfetto/ext/traced/sys_stats_counters.h | 384 + src/libtracing/perfetto/ext/traced/traced.h | 29 + .../perfetto/ext/tracing/core/BUILD.gn | 41 + .../perfetto/ext/tracing/core/basic_types.h | 107 + .../ext/tracing/core/client_identity.h | 51 + .../ext/tracing/core/commit_data_request.h | 28 + .../perfetto/ext/tracing/core/consumer.h | 95 + .../core/null_consumer_endpoint_for_testing.h | 56 + .../ext/tracing/core/observable_events.h | 28 + .../perfetto/ext/tracing/core/producer.h | 134 + .../perfetto/ext/tracing/core/shared_memory.h | 54 + .../ext/tracing/core/shared_memory_abi.h | 627 + .../ext/tracing/core/shared_memory_arbiter.h | 215 + .../perfetto/ext/tracing/core/slice.h | 77 + .../perfetto/ext/tracing/core/trace_packet.h | 106 + .../perfetto/ext/tracing/core/trace_stats.h | 28 + .../perfetto/ext/tracing/core/trace_writer.h | 53 + .../ext/tracing/core/tracing_service.h | 442 + .../perfetto/ext/tracing/ipc/BUILD.gn | 25 + .../ext/tracing/ipc/consumer_ipc_client.h | 54 + .../ext/tracing/ipc/producer_ipc_client.h | 102 + .../ext/tracing/ipc/service_ipc_host.h | 84 + .../protozero/contiguous_memory_range.h | 38 + .../perfetto/protozero/copyable_ptr.h | 87 + .../perfetto/protozero/cpp_message_obj.h | 46 + src/libtracing/perfetto/protozero/field.h | 214 + .../perfetto/protozero/field_writer.h | 188 + .../perfetto/protozero/gen_field_helpers.h | 163 + src/libtracing/perfetto/protozero/meson.build | 19 + src/libtracing/perfetto/protozero/message.h | 260 + .../perfetto/protozero/message_arena.h | 95 + .../perfetto/protozero/message_handle.h | 179 + .../protozero/packed_repeated_fields.h | 115 + .../perfetto/protozero/proto_decoder.h | 470 + .../perfetto/protozero/proto_utils.h | 296 + .../perfetto/protozero/root_message.h | 53 + .../protozero/scattered_heap_buffer.h | 185 + .../scattered_stream_null_delegate.h | 46 + .../protozero/scattered_stream_writer.h | 179 + .../perfetto/protozero/static_buffer.h | 102 + src/libtracing/perfetto/public/BUILD.gn | 45 + src/libtracing/perfetto/public/abi/BUILD.gn | 37 + src/libtracing/perfetto/public/abi/atomic.h | 67 + .../perfetto/public/abi/backend_type.h | 34 + .../perfetto/public/abi/data_source_abi.h | 372 + src/libtracing/perfetto/public/abi/export.h | 48 + .../perfetto/public/abi/heap_buffer.h | 54 + .../perfetto/public/abi/pb_decoder_abi.h | 93 + .../perfetto/public/abi/producer_abi.h | 51 + .../perfetto/public/abi/stream_writer_abi.h | 111 + .../perfetto/public/abi/thread_utils_abi.h | 55 + .../perfetto/public/abi/tracing_session_abi.h | 123 + .../perfetto/public/abi/track_event_abi.h | 152 + .../perfetto/public/abi/track_event_hl_abi.h | 196 + .../perfetto/public/abi/track_event_ll_abi.h | 117 + src/libtracing/perfetto/public/compiler.h | 54 + src/libtracing/perfetto/public/data_source.h | 272 + src/libtracing/perfetto/public/fnv1a.h | 38 + src/libtracing/perfetto/public/pb_decoder.h | 170 + src/libtracing/perfetto/public/pb_macros.h | 280 + src/libtracing/perfetto/public/pb_msg.h | 251 + src/libtracing/perfetto/public/pb_packed.h | 168 + src/libtracing/perfetto/public/pb_utils.h | 164 + src/libtracing/perfetto/public/producer.h | 61 + .../perfetto/public/protos/BUILD.gn | 32 + .../public/protos/common/builtin_clock.pzc.h | 39 + .../common/data_source_descriptor.pzc.h | 79 + .../protos/config/data_source_config.pzc.h | 257 + .../public/protos/config/trace_config.pzc.h | 570 + .../track_event/track_event_config.pzc.h | 75 + .../trace/interned_data/interned_data.pzc.h | 197 + .../public/protos/trace/test_event.pzc.h | 79 + .../perfetto/public/protos/trace/trace.pzc.h | 37 + .../public/protos/trace/trace_packet.pzc.h | 548 + .../track_event/counter_descriptor.pzc.h | 80 + .../trace/track_event/debug_annotation.pzc.h | 185 + .../trace/track_event/track_descriptor.pzc.h | 77 + .../trace/track_event/track_event.pzc.h | 391 + .../public/protos/trace/trigger.pzc.h | 42 + .../perfetto/public/stream_writer.h | 103 + .../perfetto/public/te_category_macros.h | 168 + src/libtracing/perfetto/public/te_macros.h | 320 + src/libtracing/perfetto/public/thread_utils.h | 49 + .../perfetto/public/tracing_session.h | 34 + src/libtracing/perfetto/public/track_event.h | 508 + src/libtracing/protos/README.md | 20 + .../android_energy_consumer_descriptor.proto | 43 + .../common/android_log_constants.proto | 47 + .../perfetto/common/builtin_clock.proto | 33 + .../perfetto/common/commit_data_request.proto | 84 + .../common/data_source_descriptor.proto | 69 + .../protos/perfetto/common/descriptor.proto | 238 + .../perfetto/common/ftrace_descriptor.proto | 31 + .../common/gpu_counter_descriptor.proto | 139 + .../common/interceptor_descriptor.proto | 25 + .../perfetto/common/observable_events.proto | 71 + .../protos/perfetto/common/perf_events.proto | 153 + .../perfetto/common/protolog_common.proto | 29 + .../perfetto/common/sys_stats_counters.proto | 253 + .../protos/perfetto/common/trace_stats.proto | 227 + .../common/tracing_service_capabilities.proto | 41 + .../common/tracing_service_state.proto | 129 + .../common/track_event_descriptor.proto | 29 + ...ndroid_game_intervention_list_config.proto | 27 + .../android/android_input_event_config.proto | 120 + .../config/android/android_log_config.proto | 34 + .../android/android_polled_state_config.proto | 28 + .../android_sdk_sysprop_guard_config.proto | 82 + .../android_system_property_config.proto | 30 + .../config/android/network_trace_config.proto | 54 + .../config/android/packages_list_config.proto | 27 + .../config/android/protolog_config.proto | 53 + .../surfaceflinger_layers_config.proto | 58 + .../surfaceflinger_transactions_config.proto | 38 + .../config/chrome/chrome_config.proto | 48 + .../config/chrome/scenario_config.proto | 127 + .../perfetto/config/chrome/v8_config.proto | 31 + .../perfetto/config/data_source_config.proto | 214 + .../perfetto/config/etw/etw_config.proto | 36 + .../config/ftrace/ftrace_config.proto | 236 + .../config/gpu/gpu_counter_config.proto | 34 + .../config/gpu/vulkan_memory_config.proto | 27 + .../config/inode_file/inode_file_config.proto | 46 + .../perfetto/config/interceptor_config.proto | 31 + .../config/interceptors/console_config.proto | 28 + .../perfetto/config/perfetto_config.proto | 4075 +++++ .../config/power/android_power_config.proto | 53 + .../process_stats/process_stats_config.proto | 79 + .../config/profiling/heapprofd_config.proto | 202 + .../config/profiling/java_hprof_config.proto | 90 + .../config/profiling/perf_event_config.proto | 218 + .../perfetto/config/statsd/atom_ids.proto | 907 + .../config/statsd/statsd_tracing_config.proto | 44 + .../perfetto/config/stress_test_config.proto | 77 + .../config/sys_stats/sys_stats_config.proto | 82 + .../config/system_info/system_info.proto | 27 + .../protos/perfetto/config/test_config.proto | 63 + .../protos/perfetto/config/trace_config.proto | 695 + .../track_event/track_event_config.proto | 102 + src/libtracing/protos/perfetto/ipc/OWNERS | 9 + .../protos/perfetto/ipc/consumer_port.proto | 312 + .../protos/perfetto/ipc/producer_port.proto | 352 + .../protos/perfetto/ipc/relay_port.proto | 58 + .../protos/perfetto/ipc/wire_protocol.proto | 104 + .../protos/perfetto/metrics/android/OWNERS | 1 + .../metrics/android/ad_services_metric.proto | 56 + .../android/android_blocking_call.proto | 39 + .../android_blocking_calls_cuj_metric.proto | 49 + .../android_blocking_calls_unagg.proto | 36 + .../metrics/android/android_boot.proto | 63 + .../metrics/android/android_boot_unagg.proto | 29 + .../android_frame_timeline_metric.proto | 86 + ...roid_garbage_collection_unagg_metric.proto | 63 + ..._notifications_blocking_calls_metric.proto | 26 + .../android/android_trusty_workqueues.proto | 22 + .../perfetto/metrics/android/anr_metric.proto | 41 + .../android/app_process_starts_metric.proto | 41 + .../metrics/android/batt_metric.proto | 60 + .../metrics/android/binder_metric.proto | 92 + .../metrics/android/camera_metric.proto | 42 + .../metrics/android/camera_unagg_metric.proto | 45 + .../metrics/android/codec_metrics.proto | 73 + .../perfetto/metrics/android/cpu_metric.proto | 81 + .../metrics/android/display_metrics.proto | 65 + .../metrics/android/dma_heap_metric.proto | 30 + .../metrics/android/dvfs_metric.proto | 43 + .../metrics/android/fastrpc_metric.proto | 35 + .../perfetto/metrics/android/g2d_metric.proto | 56 + .../perfetto/metrics/android/gpu_metric.proto | 68 + .../perfetto/metrics/android/hwcomposer.proto | 138 + .../metrics/android/hwui_metric.proto | 103 + .../perfetto/metrics/android/io_metric.proto | 48 + .../metrics/android/io_unagg_metric.proto | 36 + .../perfetto/metrics/android/ion_metric.proto | 35 + .../metrics/android/irq_runtime_metric.proto | 53 + .../metrics/android/jank_cuj_metric.proto | 155 + .../metrics/android/java_heap_histogram.proto | 50 + .../metrics/android/java_heap_stats.proto | 61 + .../perfetto/metrics/android/lmk_metric.proto | 35 + .../metrics/android/lmk_reason_metric.proto | 55 + .../perfetto/metrics/android/mem_metric.proto | 56 + .../metrics/android/mem_unagg_metric.proto | 43 + .../monitor_contention_agg_metric.proto | 34 + .../android/monitor_contention_metric.proto | 73 + .../metrics/android/multiuser_metric.proto | 48 + .../metrics/android/network_metric.proto | 176 + .../metrics/android/other_traces.proto | 25 + .../metrics/android/package_list.proto | 28 + .../metrics/android/powrails_metric.proto | 46 + .../metrics/android/process_metadata.proto | 51 + .../metrics/android/profiler_smaps.proto | 36 + .../metrics/android/rt_runtime_metric.proto | 38 + .../perfetto/metrics/android/simpleperf.proto | 60 + .../metrics/android/startup_metric.proto | 315 + .../metrics/android/surfaceflinger.proto | 85 + ...ysui_notif_shade_list_builder_metric.proto | 41 + ...i_slice_performance_statistical_data.proto | 35 + ...date_notif_on_ui_mode_changed_metric.proto | 39 + .../perfetto/metrics/android/task_names.proto | 43 + .../android/thread_time_in_state_metric.proto | 48 + .../metrics/android/trace_quality.proto | 32 + .../metrics/android/unsymbolized_frames.proto | 36 + .../metrics/chrome/all_chrome_metrics.proto | 56 + .../metrics/chrome/args_class_names.proto | 31 + .../metrics/chrome/dropped_frames.proto | 29 + .../perfetto/metrics/chrome/frame_times.proto | 28 + .../metrics/chrome/histogram_hashes.proto | 26 + .../metrics/chrome/long_latency.proto | 40 + .../metrics/chrome/media_metric.proto | 37 + .../chrome/performance_mark_hashes.proto | 27 + .../metrics/chrome/reported_by_page.proto | 31 + .../perfetto/metrics/chrome/scroll_jank.proto | 34 + .../metrics/chrome/scroll_jank_v3.proto | 65 + .../perfetto/metrics/chrome/slice_names.proto | 27 + .../metrics/chrome/test_chrome_metric.proto | 25 + .../perfetto/metrics/chrome/touch_jank.proto | 35 + .../metrics/chrome/unsymbolized_args.proto | 39 + .../metrics/chrome/user_event_hashes.proto | 26 + .../perfetto/metrics/custom_options.proto | 26 + .../protos/perfetto/metrics/metrics.proto | 312 + .../metrics/perfetto_merged_metrics.proto | 2735 +++ .../metrics/webview/all_webview_metrics.proto | 26 + .../webview/webview_jank_approximation.proto | 27 + .../android_game_intervention_list.proto | 42 + .../trace/android/android_input_event.proto | 134 + .../perfetto/trace/android/android_log.proto | 77 + .../android/android_system_property.proto | 27 + .../perfetto/trace/android/camera_event.proto | 160 + .../trace/android/frame_timeline_event.proto | 194 + .../trace/android/gpu_mem_event.proto | 25 + .../trace/android/graphics_frame_event.proto | 52 + .../trace/android/initial_display_state.proto | 24 + .../trace/android/network_trace.proto | 97 + .../trace/android/packages_list.proto | 36 + .../perfetto/trace/android/protolog.proto | 62 + .../trace/android/shell_transition.proto | 113 + .../trace/android/surfaceflinger_common.proto | 93 + .../trace/android/surfaceflinger_layers.proto | 262 + .../android/surfaceflinger_transactions.proto | 317 + .../perfetto/trace/android/winscope.proto | 33 + .../chrome/chrome_benchmark_metadata.proto | 50 + .../trace/chrome/chrome_metadata.proto | 103 + .../trace/chrome/chrome_trace_event.proto | 126 + .../trace/chrome/chrome_trace_packet.proto | 68 + .../trace/chrome/chrome_trigger.proto | 28 + .../protos/perfetto/trace/chrome/v8.proto | 271 + .../perfetto/trace/clock_snapshot.proto | 76 + .../protos/perfetto/trace/etw/all_protos.gni | 19 + .../protos/perfetto/trace/etw/etw.proto | 153 + .../protos/perfetto/trace/etw/etw_event.proto | 30 + .../perfetto/trace/etw/etw_event_bundle.proto | 29 + .../perfetto/trace/extension_descriptor.proto | 29 + .../trace/filesystem/inode_file_map.proto | 47 + .../perfetto/trace/ftrace/all_protos.gni | 86 + .../perfetto/trace/ftrace/android_fs.proto | 47 + .../protos/perfetto/trace/ftrace/binder.proto | 47 + .../protos/perfetto/trace/ftrace/block.proto | 140 + .../protos/perfetto/trace/ftrace/cgroup.proto | 68 + .../protos/perfetto/trace/ftrace/clk.proto | 17 + .../protos/perfetto/trace/ftrace/cma.proto | 24 + .../perfetto/trace/ftrace/compaction.proto | 95 + .../protos/perfetto/trace/ftrace/cpuhp.proto | 37 + .../perfetto/trace/ftrace/cros_ec.proto | 15 + .../perfetto/trace/ftrace/dma_fence.proto | 37 + .../perfetto/trace/ftrace/dmabuf_heap.proto | 12 + .../protos/perfetto/trace/ftrace/dpu.proto | 29 + .../protos/perfetto/trace/ftrace/drm.proto | 18 + .../protos/perfetto/trace/ftrace/ext4.proto | 696 + .../protos/perfetto/trace/ftrace/f2fs.proto | 324 + .../perfetto/trace/ftrace/fastrpc.proto | 38 + .../protos/perfetto/trace/ftrace/fence.proto | 31 + .../perfetto/trace/ftrace/filemap.proto | 21 + .../protos/perfetto/trace/ftrace/ftrace.proto | 22 + .../perfetto/trace/ftrace/ftrace_event.proto | 622 + .../trace/ftrace/ftrace_event_bundle.proto | 135 + .../perfetto/trace/ftrace/ftrace_stats.proto | 140 + .../protos/perfetto/trace/ftrace/g2d.proto | 13 + .../perfetto/trace/ftrace/generic.proto | 35 + .../perfetto/trace/ftrace/gpu_mem.proto | 12 + .../perfetto/trace/ftrace/gpu_scheduler.proto | 26 + .../protos/perfetto/trace/ftrace/hyp.proto | 21 + .../protos/perfetto/trace/ftrace/i2c.proto | 67 + .../protos/perfetto/trace/ftrace/ion.proto | 12 + .../protos/perfetto/trace/ftrace/ipi.proto | 17 + .../protos/perfetto/trace/ftrace/irq.proto | 25 + .../protos/perfetto/trace/ftrace/kfree.proto | 11 + .../perfetto/trace/ftrace/kmalloc.proto | 14 + .../protos/perfetto/trace/ftrace/kmem.proto | 241 + .../protos/perfetto/trace/ftrace/kvm.proto | 170 + .../trace/ftrace/lowmemorykiller.proto | 14 + .../protos/perfetto/trace/ftrace/lwis.proto | 14 + .../protos/perfetto/trace/ftrace/mali.proto | 65 + .../protos/perfetto/trace/ftrace/mdss.proto | 154 + .../perfetto/trace/ftrace/mm_event.proto | 13 + .../protos/perfetto/trace/ftrace/net.proto | 42 + .../protos/perfetto/trace/ftrace/oom.proto | 15 + .../protos/perfetto/trace/ftrace/panel.proto | 28 + .../trace/ftrace/perf_trace_counters.proto | 26 + .../protos/perfetto/trace/ftrace/power.proto | 59 + .../protos/perfetto/trace/ftrace/print.proto | 11 + .../protos/perfetto/trace/ftrace/printk.proto | 10 + .../perfetto/trace/ftrace/raw_syscalls.proto | 15 + .../perfetto/trace/ftrace/regulator.proto | 31 + .../protos/perfetto/trace/ftrace/rpm.proto | 11 + .../perfetto/trace/ftrace/samsung.proto | 14 + .../protos/perfetto/trace/ftrace/sched.proto | 110 + .../protos/perfetto/trace/ftrace/scm.proto | 13 + .../protos/perfetto/trace/ftrace/sde.proto | 57 + .../protos/perfetto/trace/ftrace/signal.proto | 20 + .../protos/perfetto/trace/ftrace/skb.proto | 12 + .../protos/perfetto/trace/ftrace/sock.proto | 18 + .../protos/perfetto/trace/ftrace/sync.proto | 20 + .../perfetto/trace/ftrace/synthetic.proto | 16 + .../perfetto/trace/ftrace/systrace.proto | 13 + .../protos/perfetto/trace/ftrace/task.proto | 19 + .../protos/perfetto/trace/ftrace/tcp.proto | 16 + .../trace/ftrace/test_bundle_wrapper.proto | 26 + .../perfetto/trace/ftrace/thermal.proto | 17 + .../protos/perfetto/trace/ftrace/trusty.proto | 96 + .../protos/perfetto/trace/ftrace/ufs.proto | 23 + .../protos/perfetto/trace/ftrace/v4l2.proto | 115 + .../perfetto/trace/ftrace/virtio_gpu.proto | 29 + .../perfetto/trace/ftrace/virtio_video.proto | 35 + .../protos/perfetto/trace/ftrace/vmscan.proto | 45 + .../perfetto/trace/ftrace/workqueue.proto | 25 + .../trace/gpu/gpu_counter_event.proto | 40 + .../protos/perfetto/trace/gpu/gpu_log.proto | 36 + .../trace/gpu/gpu_render_stage_event.proto | 146 + .../perfetto/trace/gpu/vulkan_api_event.proto | 52 + .../trace/gpu/vulkan_memory_event.proto | 103 + .../trace/interned_data/interned_data.proto | 140 + .../protos/perfetto/trace/memory_graph.proto | 123 + .../trace/perfetto/perfetto_metatrace.proto | 68 + .../perfetto/tracing_service_event.proto | 67 + .../perfetto/trace/perfetto_trace.proto | 14990 ++++++++++++++++ .../android_energy_estimation_breakdown.proto | 49 + .../android_entity_state_residency.proto | 60 + .../trace/power/battery_counters.proto | 46 + .../perfetto/trace/power/power_rails.proto | 51 + .../trace/profiling/deobfuscation.proto | 44 + .../perfetto/trace/profiling/heap_graph.proto | 150 + .../trace/profiling/profile_common.proto | 152 + .../trace/profiling/profile_packet.proto | 363 + .../perfetto/trace/profiling/smaps.proto | 47 + .../perfetto/trace/ps/process_stats.proto | 103 + .../perfetto/trace/ps/process_tree.proto | 89 + .../perfetto/trace/remote_clock_sync.proto | 35 + .../perfetto/trace/statsd/statsd_atom.proto | 35 + .../perfetto/trace/sys_stats/sys_stats.proto | 162 + .../protos/perfetto/trace/system_info.proto | 57 + .../perfetto/trace/system_info/cpu_info.proto | 36 + .../protos/perfetto/trace/test_event.proto | 52 + .../perfetto/trace/test_extensions.proto | 43 + .../protos/perfetto/trace/trace.proto | 31 + .../protos/perfetto/trace/trace_packet.proto | 354 + .../trace/trace_packet_defaults.proto | 44 + .../protos/perfetto/trace/trace_uuid.proto | 30 + .../track_event/chrome_active_processes.proto | 24 + .../chrome_application_state_info.proto | 34 + .../chrome_compositor_scheduler_state.proto | 270 + .../chrome_content_settings_event_info.proto | 27 + .../track_event/chrome_frame_reporter.proto | 114 + .../track_event/chrome_histogram_sample.proto | 35 + .../track_event/chrome_keyed_service.proto | 26 + .../track_event/chrome_latency_info.proto | 88 + .../trace/track_event/chrome_legacy_ipc.proto | 72 + .../track_event/chrome_message_pump.proto | 28 + .../track_event/chrome_mojo_event_info.proto | 55 + .../chrome_process_descriptor.proto | 93 + .../chrome_renderer_scheduler_state.proto | 39 + .../chrome_thread_descriptor.proto | 86 + .../trace/track_event/chrome_user_event.proto | 31 + .../chrome_window_handle_event_info.proto | 26 + .../track_event/counter_descriptor.proto | 95 + .../trace/track_event/debug_annotation.proto | 143 + .../trace/track_event/log_message.proto | 46 + .../trace/track_event/pixel_modem.proto | 25 + .../track_event/process_descriptor.proto | 61 + .../trace/track_event/range_of_interest.proto | 26 + .../trace/track_event/screenshot.proto | 23 + .../trace/track_event/source_location.proto | 40 + .../trace/track_event/task_execution.proto | 26 + .../trace/track_event/thread_descriptor.proto | 75 + .../trace/track_event/track_descriptor.proto | 94 + .../trace/track_event/track_event.proto | 435 + .../trace/translation/translation_table.proto | 51 + .../protos/perfetto/trace/trigger.proto | 31 + .../protos/perfetto/trace/ui_state.proto | 54 + .../metatrace_categories.proto | 38 + .../trace_processor/metrics_impl.proto | 57 + .../perfetto/trace_processor/proto_files.gni | 22 + .../trace_processor/serialization.proto | 118 + .../perfetto/trace_processor/stack.proto | 39 + .../trace_processor/trace_processor.proto | 330 + .../protos/third_party/CHROMIUM_OWNERS | 21 + src/libtracing/protos/third_party/OWNERS | 3 + .../chromium/chrome_track_event.proto | 1974 ++ .../protos/third_party/chromium/sources.gni | 11 + .../protos/third_party/pprof/profile.proto | 230 + .../third_party/statsd/shell_config.proto | 38 + .../third_party/statsd/shell_data.proto | 27 + .../protozero_src/copyable_ptr_unittest.cc | 118 + src/libtracing/protozero_src/field.cc | 81 + .../filtering/filter_bytecode_common.h | 49 + .../filtering/filter_bytecode_generator.cc | 99 + .../filtering/filter_bytecode_generator.h | 79 + .../filter_bytecode_generator_unittest.cc | 143 + .../filtering/filter_bytecode_parser.cc | 244 + .../filtering/filter_bytecode_parser.h | 140 + .../filter_bytecode_parser_fuzzer.cc | 94 + .../filter_bytecode_parser_unittest.cc | 261 + .../protozero_src/filtering/filter_util.cc | 426 + .../protozero_src/filtering/filter_util.h | 136 + .../filtering/filter_util_unittest.cc | 381 + .../protozero_src/filtering/message_filter.cc | 329 + .../protozero_src/filtering/message_filter.h | 241 + .../filtering/message_filter_benchmark.cc | 48 + .../filtering/message_filter_fuzzer.cc | 104 + .../filtering/message_filter_unittest.cc | 934 + .../filtering/message_tokenizer.h | 199 + .../filtering/message_tokenizer_unittest.cc | 179 + .../protozero_src/filtering/string_filter.cc | 161 + .../protozero_src/filtering/string_filter.h | 66 + .../filtering/string_filter_benchmark.cc | 165 + .../filtering/string_filter_unittest.cc | 282 + .../protozero_src/gen_field_helpers.cc | 105 + src/libtracing/protozero_src/message.cc | 220 + src/libtracing/protozero_src/message_arena.cc | 72 + .../protozero_src/message_arena_unittest.cc | 66 + .../protozero_src/message_handle_unittest.cc | 35 + .../protozero_src/message_unittest.cc | 474 + .../protozero_src/packed_repeated_fields.cc | 43 + src/libtracing/protozero_src/proto_decoder.cc | 269 + .../protozero_src/proto_decoder_fuzzer.cc | 44 + .../protozero_src/proto_decoder_unittest.cc | 651 + .../protozero_src/proto_ring_buffer.cc | 192 + .../proto_ring_buffer_unittest.cc | 268 + .../protozero_src/proto_utils_unittest.cc | 232 + .../protoc_plugin/cppgen_plugin.cc | 913 + .../protoc_plugin/protozero_c_plugin.cc | 623 + .../protoc_plugin/protozero_plugin.cc | 1136 ++ .../protozero_src/scattered_heap_buffer.cc | 121 + .../scattered_stream_null_delegate.cc | 37 + .../protozero_src/scattered_stream_writer.cc | 92 + .../scattered_stream_writer_unittest.cc | 133 + src/libtracing/protozero_src/static_buffer.cc | 35 + .../test/cppgen_conformance_unittest.cc | 401 + .../test/example_proto/extensions.proto | 44 + .../test/example_proto/library.proto | 34 + .../library_internals/galaxies.proto | 27 + .../other_package/test_messages.proto | 40 + .../subpackage/test_messages.proto | 40 + .../test/example_proto/test_messages.proto | 195 + .../test/example_proto/upper_import.proto | 21 + .../test/fake_scattered_buffer.cc | 74 + .../test/fake_scattered_buffer.h | 54 + .../test/proto_ring_buffer_benchmark.cc | 75 + .../protozero_src/test/protozero_benchmark.cc | 200 + .../test/protozero_conformance_unittest.cc | 373 + .../protozero_src/virtual_destructors.cc | 25 + 562 files changed, 84479 insertions(+) create mode 100644 src/libtracing/perfetto/base/BUILD.gn create mode 100644 src/libtracing/perfetto/base/build_config.h create mode 100644 src/libtracing/perfetto/base/build_configs/android_tree/perfetto_build_flags.h create mode 100644 src/libtracing/perfetto/base/build_configs/bazel/perfetto_build_flags.h create mode 100644 src/libtracing/perfetto/base/compiler.h create mode 100644 src/libtracing/perfetto/base/export.h create mode 100644 src/libtracing/perfetto/base/flat_set.h create mode 100644 src/libtracing/perfetto/base/logging.h create mode 100644 src/libtracing/perfetto/base/platform_handle.h create mode 100644 src/libtracing/perfetto/base/proc_utils.h create mode 100644 src/libtracing/perfetto/base/status.h create mode 100644 src/libtracing/perfetto/base/task_runner.h create mode 100644 src/libtracing/perfetto/base/template_util.h create mode 100644 src/libtracing/perfetto/base/thread_utils.h create mode 100644 src/libtracing/perfetto/base/time.h create mode 100644 src/libtracing/perfetto/ext/base/BUILD.gn create mode 100644 src/libtracing/perfetto/ext/base/android_utils.h create mode 100644 src/libtracing/perfetto/ext/base/base64.h create mode 100644 src/libtracing/perfetto/ext/base/circular_queue.h create mode 100644 src/libtracing/perfetto/ext/base/container_annotations.h create mode 100644 src/libtracing/perfetto/ext/base/crash_keys.h create mode 100644 src/libtracing/perfetto/ext/base/ctrl_c_handler.h create mode 100644 src/libtracing/perfetto/ext/base/endian.h create mode 100644 src/libtracing/perfetto/ext/base/event_fd.h create mode 100644 src/libtracing/perfetto/ext/base/file_utils.h create mode 100644 src/libtracing/perfetto/ext/base/flat_hash_map.h create mode 100644 src/libtracing/perfetto/ext/base/getopt.h create mode 100644 src/libtracing/perfetto/ext/base/getopt_compat.h create mode 100644 src/libtracing/perfetto/ext/base/hash.h create mode 100644 src/libtracing/perfetto/ext/base/http/BUILD.gn create mode 100644 src/libtracing/perfetto/ext/base/http/http_server.h create mode 100644 src/libtracing/perfetto/ext/base/http/sha1.h create mode 100644 src/libtracing/perfetto/ext/base/metatrace.h create mode 100644 src/libtracing/perfetto/ext/base/metatrace_events.h create mode 100644 src/libtracing/perfetto/ext/base/no_destructor.h create mode 100644 src/libtracing/perfetto/ext/base/paged_memory.h create mode 100644 src/libtracing/perfetto/ext/base/periodic_task.h create mode 100644 src/libtracing/perfetto/ext/base/pipe.h create mode 100644 src/libtracing/perfetto/ext/base/platform.h create mode 100644 src/libtracing/perfetto/ext/base/scoped_file.h create mode 100644 src/libtracing/perfetto/ext/base/scoped_mmap.h create mode 100644 src/libtracing/perfetto/ext/base/small_set.h create mode 100644 src/libtracing/perfetto/ext/base/small_vector.h create mode 100644 src/libtracing/perfetto/ext/base/status_or.h create mode 100644 src/libtracing/perfetto/ext/base/string_splitter.h create mode 100644 src/libtracing/perfetto/ext/base/string_utils.h create mode 100644 src/libtracing/perfetto/ext/base/string_view.h create mode 100644 src/libtracing/perfetto/ext/base/string_writer.h create mode 100644 src/libtracing/perfetto/ext/base/subprocess.h create mode 100644 src/libtracing/perfetto/ext/base/sys_types.h create mode 100644 src/libtracing/perfetto/ext/base/temp_file.h create mode 100644 src/libtracing/perfetto/ext/base/thread_annotations.h create mode 100644 src/libtracing/perfetto/ext/base/thread_checker.h create mode 100644 src/libtracing/perfetto/ext/base/thread_task_runner.h create mode 100644 src/libtracing/perfetto/ext/base/thread_utils.h create mode 100644 src/libtracing/perfetto/ext/base/threading/BUILD.gn create mode 100644 src/libtracing/perfetto/ext/base/threading/channel.h create mode 100644 src/libtracing/perfetto/ext/base/threading/future.h create mode 100644 src/libtracing/perfetto/ext/base/threading/future_combinators.h create mode 100644 src/libtracing/perfetto/ext/base/threading/poll.h create mode 100644 src/libtracing/perfetto/ext/base/threading/spawn.h create mode 100644 src/libtracing/perfetto/ext/base/threading/stream.h create mode 100644 src/libtracing/perfetto/ext/base/threading/stream_combinators.h create mode 100644 src/libtracing/perfetto/ext/base/threading/thread_pool.h create mode 100644 src/libtracing/perfetto/ext/base/threading/util.h create mode 100644 src/libtracing/perfetto/ext/base/unix_socket.h create mode 100644 src/libtracing/perfetto/ext/base/unix_task_runner.h create mode 100644 src/libtracing/perfetto/ext/base/utils.h create mode 100644 src/libtracing/perfetto/ext/base/uuid.h create mode 100644 src/libtracing/perfetto/ext/base/version.h create mode 100644 src/libtracing/perfetto/ext/base/waitable_event.h create mode 100644 src/libtracing/perfetto/ext/base/watchdog.h create mode 100644 src/libtracing/perfetto/ext/base/watchdog_noop.h create mode 100644 src/libtracing/perfetto/ext/base/watchdog_posix.h create mode 100644 src/libtracing/perfetto/ext/base/weak_ptr.h create mode 100644 src/libtracing/perfetto/ext/ipc/BUILD.gn create mode 100644 src/libtracing/perfetto/ext/ipc/async_result.h create mode 100644 src/libtracing/perfetto/ext/ipc/basic_types.h create mode 100644 src/libtracing/perfetto/ext/ipc/client.h create mode 100644 src/libtracing/perfetto/ext/ipc/client_info.h create mode 100644 src/libtracing/perfetto/ext/ipc/codegen_helpers.h create mode 100644 src/libtracing/perfetto/ext/ipc/deferred.h create mode 100644 src/libtracing/perfetto/ext/ipc/host.h create mode 100644 src/libtracing/perfetto/ext/ipc/service.h create mode 100644 src/libtracing/perfetto/ext/ipc/service_descriptor.h create mode 100644 src/libtracing/perfetto/ext/ipc/service_proxy.h create mode 100644 src/libtracing/perfetto/ext/protozero/BUILD.gn create mode 100644 src/libtracing/perfetto/ext/protozero/proto_ring_buffer.h create mode 100644 src/libtracing/perfetto/ext/trace_processor/BUILD.gn create mode 100644 src/libtracing/perfetto/ext/trace_processor/demangle.h create mode 100644 src/libtracing/perfetto/ext/trace_processor/export_json.h create mode 100644 src/libtracing/perfetto/ext/trace_processor/importers/memory_tracker/BUILD.gn create mode 100644 src/libtracing/perfetto/ext/trace_processor/importers/memory_tracker/graph.h create mode 100644 src/libtracing/perfetto/ext/trace_processor/importers/memory_tracker/graph_processor.h create mode 100644 src/libtracing/perfetto/ext/trace_processor/importers/memory_tracker/memory_allocator_node_id.h create mode 100644 src/libtracing/perfetto/ext/trace_processor/importers/memory_tracker/memory_graph_edge.h create mode 100644 src/libtracing/perfetto/ext/trace_processor/importers/memory_tracker/raw_memory_graph_node.h create mode 100644 src/libtracing/perfetto/ext/trace_processor/importers/memory_tracker/raw_process_memory_node.h create mode 100644 src/libtracing/perfetto/ext/trace_processor/rpc/BUILD.gn create mode 100644 src/libtracing/perfetto/ext/trace_processor/rpc/query_result_serializer.h create mode 100644 src/libtracing/perfetto/ext/traced/BUILD.gn create mode 100644 src/libtracing/perfetto/ext/traced/data_source_types.h create mode 100644 src/libtracing/perfetto/ext/traced/sys_stats_counters.h create mode 100644 src/libtracing/perfetto/ext/traced/traced.h create mode 100644 src/libtracing/perfetto/ext/tracing/core/BUILD.gn create mode 100644 src/libtracing/perfetto/ext/tracing/core/basic_types.h create mode 100644 src/libtracing/perfetto/ext/tracing/core/client_identity.h create mode 100644 src/libtracing/perfetto/ext/tracing/core/commit_data_request.h create mode 100644 src/libtracing/perfetto/ext/tracing/core/consumer.h create mode 100644 src/libtracing/perfetto/ext/tracing/core/null_consumer_endpoint_for_testing.h create mode 100644 src/libtracing/perfetto/ext/tracing/core/observable_events.h create mode 100644 src/libtracing/perfetto/ext/tracing/core/producer.h create mode 100644 src/libtracing/perfetto/ext/tracing/core/shared_memory.h create mode 100644 src/libtracing/perfetto/ext/tracing/core/shared_memory_abi.h create mode 100644 src/libtracing/perfetto/ext/tracing/core/shared_memory_arbiter.h create mode 100644 src/libtracing/perfetto/ext/tracing/core/slice.h create mode 100644 src/libtracing/perfetto/ext/tracing/core/trace_packet.h create mode 100644 src/libtracing/perfetto/ext/tracing/core/trace_stats.h create mode 100644 src/libtracing/perfetto/ext/tracing/core/trace_writer.h create mode 100644 src/libtracing/perfetto/ext/tracing/core/tracing_service.h create mode 100644 src/libtracing/perfetto/ext/tracing/ipc/BUILD.gn create mode 100644 src/libtracing/perfetto/ext/tracing/ipc/consumer_ipc_client.h create mode 100644 src/libtracing/perfetto/ext/tracing/ipc/producer_ipc_client.h create mode 100644 src/libtracing/perfetto/ext/tracing/ipc/service_ipc_host.h create mode 100644 src/libtracing/perfetto/protozero/contiguous_memory_range.h create mode 100644 src/libtracing/perfetto/protozero/copyable_ptr.h create mode 100644 src/libtracing/perfetto/protozero/cpp_message_obj.h create mode 100644 src/libtracing/perfetto/protozero/field.h create mode 100644 src/libtracing/perfetto/protozero/field_writer.h create mode 100644 src/libtracing/perfetto/protozero/gen_field_helpers.h create mode 100644 src/libtracing/perfetto/protozero/meson.build create mode 100644 src/libtracing/perfetto/protozero/message.h create mode 100644 src/libtracing/perfetto/protozero/message_arena.h create mode 100644 src/libtracing/perfetto/protozero/message_handle.h create mode 100644 src/libtracing/perfetto/protozero/packed_repeated_fields.h create mode 100644 src/libtracing/perfetto/protozero/proto_decoder.h create mode 100644 src/libtracing/perfetto/protozero/proto_utils.h create mode 100644 src/libtracing/perfetto/protozero/root_message.h create mode 100644 src/libtracing/perfetto/protozero/scattered_heap_buffer.h create mode 100644 src/libtracing/perfetto/protozero/scattered_stream_null_delegate.h create mode 100644 src/libtracing/perfetto/protozero/scattered_stream_writer.h create mode 100644 src/libtracing/perfetto/protozero/static_buffer.h create mode 100644 src/libtracing/perfetto/public/BUILD.gn create mode 100644 src/libtracing/perfetto/public/abi/BUILD.gn create mode 100644 src/libtracing/perfetto/public/abi/atomic.h create mode 100644 src/libtracing/perfetto/public/abi/backend_type.h create mode 100644 src/libtracing/perfetto/public/abi/data_source_abi.h create mode 100644 src/libtracing/perfetto/public/abi/export.h create mode 100644 src/libtracing/perfetto/public/abi/heap_buffer.h create mode 100644 src/libtracing/perfetto/public/abi/pb_decoder_abi.h create mode 100644 src/libtracing/perfetto/public/abi/producer_abi.h create mode 100644 src/libtracing/perfetto/public/abi/stream_writer_abi.h create mode 100644 src/libtracing/perfetto/public/abi/thread_utils_abi.h create mode 100644 src/libtracing/perfetto/public/abi/tracing_session_abi.h create mode 100644 src/libtracing/perfetto/public/abi/track_event_abi.h create mode 100644 src/libtracing/perfetto/public/abi/track_event_hl_abi.h create mode 100644 src/libtracing/perfetto/public/abi/track_event_ll_abi.h create mode 100644 src/libtracing/perfetto/public/compiler.h create mode 100644 src/libtracing/perfetto/public/data_source.h create mode 100644 src/libtracing/perfetto/public/fnv1a.h create mode 100644 src/libtracing/perfetto/public/pb_decoder.h create mode 100644 src/libtracing/perfetto/public/pb_macros.h create mode 100644 src/libtracing/perfetto/public/pb_msg.h create mode 100644 src/libtracing/perfetto/public/pb_packed.h create mode 100644 src/libtracing/perfetto/public/pb_utils.h create mode 100644 src/libtracing/perfetto/public/producer.h create mode 100644 src/libtracing/perfetto/public/protos/BUILD.gn create mode 100644 src/libtracing/perfetto/public/protos/common/builtin_clock.pzc.h create mode 100644 src/libtracing/perfetto/public/protos/common/data_source_descriptor.pzc.h create mode 100644 src/libtracing/perfetto/public/protos/config/data_source_config.pzc.h create mode 100644 src/libtracing/perfetto/public/protos/config/trace_config.pzc.h create mode 100644 src/libtracing/perfetto/public/protos/config/track_event/track_event_config.pzc.h create mode 100644 src/libtracing/perfetto/public/protos/trace/interned_data/interned_data.pzc.h create mode 100644 src/libtracing/perfetto/public/protos/trace/test_event.pzc.h create mode 100644 src/libtracing/perfetto/public/protos/trace/trace.pzc.h create mode 100644 src/libtracing/perfetto/public/protos/trace/trace_packet.pzc.h create mode 100644 src/libtracing/perfetto/public/protos/trace/track_event/counter_descriptor.pzc.h create mode 100644 src/libtracing/perfetto/public/protos/trace/track_event/debug_annotation.pzc.h create mode 100644 src/libtracing/perfetto/public/protos/trace/track_event/track_descriptor.pzc.h create mode 100644 src/libtracing/perfetto/public/protos/trace/track_event/track_event.pzc.h create mode 100644 src/libtracing/perfetto/public/protos/trace/trigger.pzc.h create mode 100644 src/libtracing/perfetto/public/stream_writer.h create mode 100644 src/libtracing/perfetto/public/te_category_macros.h create mode 100644 src/libtracing/perfetto/public/te_macros.h create mode 100644 src/libtracing/perfetto/public/thread_utils.h create mode 100644 src/libtracing/perfetto/public/tracing_session.h create mode 100644 src/libtracing/perfetto/public/track_event.h create mode 100644 src/libtracing/protos/README.md create mode 100644 src/libtracing/protos/perfetto/common/android_energy_consumer_descriptor.proto create mode 100644 src/libtracing/protos/perfetto/common/android_log_constants.proto create mode 100644 src/libtracing/protos/perfetto/common/builtin_clock.proto create mode 100644 src/libtracing/protos/perfetto/common/commit_data_request.proto create mode 100644 src/libtracing/protos/perfetto/common/data_source_descriptor.proto create mode 100644 src/libtracing/protos/perfetto/common/descriptor.proto create mode 100644 src/libtracing/protos/perfetto/common/ftrace_descriptor.proto create mode 100644 src/libtracing/protos/perfetto/common/gpu_counter_descriptor.proto create mode 100644 src/libtracing/protos/perfetto/common/interceptor_descriptor.proto create mode 100644 src/libtracing/protos/perfetto/common/observable_events.proto create mode 100644 src/libtracing/protos/perfetto/common/perf_events.proto create mode 100644 src/libtracing/protos/perfetto/common/protolog_common.proto create mode 100644 src/libtracing/protos/perfetto/common/sys_stats_counters.proto create mode 100644 src/libtracing/protos/perfetto/common/trace_stats.proto create mode 100644 src/libtracing/protos/perfetto/common/tracing_service_capabilities.proto create mode 100644 src/libtracing/protos/perfetto/common/tracing_service_state.proto create mode 100644 src/libtracing/protos/perfetto/common/track_event_descriptor.proto create mode 100644 src/libtracing/protos/perfetto/config/android/android_game_intervention_list_config.proto create mode 100644 src/libtracing/protos/perfetto/config/android/android_input_event_config.proto create mode 100644 src/libtracing/protos/perfetto/config/android/android_log_config.proto create mode 100644 src/libtracing/protos/perfetto/config/android/android_polled_state_config.proto create mode 100644 src/libtracing/protos/perfetto/config/android/android_sdk_sysprop_guard_config.proto create mode 100644 src/libtracing/protos/perfetto/config/android/android_system_property_config.proto create mode 100644 src/libtracing/protos/perfetto/config/android/network_trace_config.proto create mode 100644 src/libtracing/protos/perfetto/config/android/packages_list_config.proto create mode 100644 src/libtracing/protos/perfetto/config/android/protolog_config.proto create mode 100644 src/libtracing/protos/perfetto/config/android/surfaceflinger_layers_config.proto create mode 100644 src/libtracing/protos/perfetto/config/android/surfaceflinger_transactions_config.proto create mode 100644 src/libtracing/protos/perfetto/config/chrome/chrome_config.proto create mode 100644 src/libtracing/protos/perfetto/config/chrome/scenario_config.proto create mode 100644 src/libtracing/protos/perfetto/config/chrome/v8_config.proto create mode 100644 src/libtracing/protos/perfetto/config/data_source_config.proto create mode 100644 src/libtracing/protos/perfetto/config/etw/etw_config.proto create mode 100644 src/libtracing/protos/perfetto/config/ftrace/ftrace_config.proto create mode 100644 src/libtracing/protos/perfetto/config/gpu/gpu_counter_config.proto create mode 100644 src/libtracing/protos/perfetto/config/gpu/vulkan_memory_config.proto create mode 100644 src/libtracing/protos/perfetto/config/inode_file/inode_file_config.proto create mode 100644 src/libtracing/protos/perfetto/config/interceptor_config.proto create mode 100644 src/libtracing/protos/perfetto/config/interceptors/console_config.proto create mode 100644 src/libtracing/protos/perfetto/config/perfetto_config.proto create mode 100644 src/libtracing/protos/perfetto/config/power/android_power_config.proto create mode 100644 src/libtracing/protos/perfetto/config/process_stats/process_stats_config.proto create mode 100644 src/libtracing/protos/perfetto/config/profiling/heapprofd_config.proto create mode 100644 src/libtracing/protos/perfetto/config/profiling/java_hprof_config.proto create mode 100644 src/libtracing/protos/perfetto/config/profiling/perf_event_config.proto create mode 100644 src/libtracing/protos/perfetto/config/statsd/atom_ids.proto create mode 100644 src/libtracing/protos/perfetto/config/statsd/statsd_tracing_config.proto create mode 100644 src/libtracing/protos/perfetto/config/stress_test_config.proto create mode 100644 src/libtracing/protos/perfetto/config/sys_stats/sys_stats_config.proto create mode 100644 src/libtracing/protos/perfetto/config/system_info/system_info.proto create mode 100644 src/libtracing/protos/perfetto/config/test_config.proto create mode 100644 src/libtracing/protos/perfetto/config/trace_config.proto create mode 100644 src/libtracing/protos/perfetto/config/track_event/track_event_config.proto create mode 100644 src/libtracing/protos/perfetto/ipc/OWNERS create mode 100644 src/libtracing/protos/perfetto/ipc/consumer_port.proto create mode 100644 src/libtracing/protos/perfetto/ipc/producer_port.proto create mode 100644 src/libtracing/protos/perfetto/ipc/relay_port.proto create mode 100644 src/libtracing/protos/perfetto/ipc/wire_protocol.proto create mode 100644 src/libtracing/protos/perfetto/metrics/android/OWNERS create mode 100644 src/libtracing/protos/perfetto/metrics/android/ad_services_metric.proto create mode 100644 src/libtracing/protos/perfetto/metrics/android/android_blocking_call.proto create mode 100644 src/libtracing/protos/perfetto/metrics/android/android_blocking_calls_cuj_metric.proto create mode 100644 src/libtracing/protos/perfetto/metrics/android/android_blocking_calls_unagg.proto create mode 100644 src/libtracing/protos/perfetto/metrics/android/android_boot.proto create mode 100644 src/libtracing/protos/perfetto/metrics/android/android_boot_unagg.proto create mode 100644 src/libtracing/protos/perfetto/metrics/android/android_frame_timeline_metric.proto create mode 100644 src/libtracing/protos/perfetto/metrics/android/android_garbage_collection_unagg_metric.proto create mode 100644 src/libtracing/protos/perfetto/metrics/android/android_sysui_notifications_blocking_calls_metric.proto create mode 100644 src/libtracing/protos/perfetto/metrics/android/android_trusty_workqueues.proto create mode 100644 src/libtracing/protos/perfetto/metrics/android/anr_metric.proto create mode 100644 src/libtracing/protos/perfetto/metrics/android/app_process_starts_metric.proto create mode 100644 src/libtracing/protos/perfetto/metrics/android/batt_metric.proto create mode 100644 src/libtracing/protos/perfetto/metrics/android/binder_metric.proto create mode 100644 src/libtracing/protos/perfetto/metrics/android/camera_metric.proto create mode 100644 src/libtracing/protos/perfetto/metrics/android/camera_unagg_metric.proto create mode 100644 src/libtracing/protos/perfetto/metrics/android/codec_metrics.proto create mode 100644 src/libtracing/protos/perfetto/metrics/android/cpu_metric.proto create mode 100644 src/libtracing/protos/perfetto/metrics/android/display_metrics.proto create mode 100644 src/libtracing/protos/perfetto/metrics/android/dma_heap_metric.proto create mode 100644 src/libtracing/protos/perfetto/metrics/android/dvfs_metric.proto create mode 100644 src/libtracing/protos/perfetto/metrics/android/fastrpc_metric.proto create mode 100644 src/libtracing/protos/perfetto/metrics/android/g2d_metric.proto create mode 100644 src/libtracing/protos/perfetto/metrics/android/gpu_metric.proto create mode 100644 src/libtracing/protos/perfetto/metrics/android/hwcomposer.proto create mode 100644 src/libtracing/protos/perfetto/metrics/android/hwui_metric.proto create mode 100644 src/libtracing/protos/perfetto/metrics/android/io_metric.proto create mode 100644 src/libtracing/protos/perfetto/metrics/android/io_unagg_metric.proto create mode 100644 src/libtracing/protos/perfetto/metrics/android/ion_metric.proto create mode 100644 src/libtracing/protos/perfetto/metrics/android/irq_runtime_metric.proto create mode 100644 src/libtracing/protos/perfetto/metrics/android/jank_cuj_metric.proto create mode 100644 src/libtracing/protos/perfetto/metrics/android/java_heap_histogram.proto create mode 100644 src/libtracing/protos/perfetto/metrics/android/java_heap_stats.proto create mode 100644 src/libtracing/protos/perfetto/metrics/android/lmk_metric.proto create mode 100644 src/libtracing/protos/perfetto/metrics/android/lmk_reason_metric.proto create mode 100644 src/libtracing/protos/perfetto/metrics/android/mem_metric.proto create mode 100644 src/libtracing/protos/perfetto/metrics/android/mem_unagg_metric.proto create mode 100644 src/libtracing/protos/perfetto/metrics/android/monitor_contention_agg_metric.proto create mode 100644 src/libtracing/protos/perfetto/metrics/android/monitor_contention_metric.proto create mode 100644 src/libtracing/protos/perfetto/metrics/android/multiuser_metric.proto create mode 100644 src/libtracing/protos/perfetto/metrics/android/network_metric.proto create mode 100644 src/libtracing/protos/perfetto/metrics/android/other_traces.proto create mode 100644 src/libtracing/protos/perfetto/metrics/android/package_list.proto create mode 100644 src/libtracing/protos/perfetto/metrics/android/powrails_metric.proto create mode 100644 src/libtracing/protos/perfetto/metrics/android/process_metadata.proto create mode 100644 src/libtracing/protos/perfetto/metrics/android/profiler_smaps.proto create mode 100644 src/libtracing/protos/perfetto/metrics/android/rt_runtime_metric.proto create mode 100644 src/libtracing/protos/perfetto/metrics/android/simpleperf.proto create mode 100644 src/libtracing/protos/perfetto/metrics/android/startup_metric.proto create mode 100644 src/libtracing/protos/perfetto/metrics/android/surfaceflinger.proto create mode 100644 src/libtracing/protos/perfetto/metrics/android/sysui_notif_shade_list_builder_metric.proto create mode 100644 src/libtracing/protos/perfetto/metrics/android/sysui_slice_performance_statistical_data.proto create mode 100644 src/libtracing/protos/perfetto/metrics/android/sysui_update_notif_on_ui_mode_changed_metric.proto create mode 100644 src/libtracing/protos/perfetto/metrics/android/task_names.proto create mode 100644 src/libtracing/protos/perfetto/metrics/android/thread_time_in_state_metric.proto create mode 100644 src/libtracing/protos/perfetto/metrics/android/trace_quality.proto create mode 100644 src/libtracing/protos/perfetto/metrics/android/unsymbolized_frames.proto create mode 100644 src/libtracing/protos/perfetto/metrics/chrome/all_chrome_metrics.proto create mode 100644 src/libtracing/protos/perfetto/metrics/chrome/args_class_names.proto create mode 100644 src/libtracing/protos/perfetto/metrics/chrome/dropped_frames.proto create mode 100644 src/libtracing/protos/perfetto/metrics/chrome/frame_times.proto create mode 100644 src/libtracing/protos/perfetto/metrics/chrome/histogram_hashes.proto create mode 100644 src/libtracing/protos/perfetto/metrics/chrome/long_latency.proto create mode 100644 src/libtracing/protos/perfetto/metrics/chrome/media_metric.proto create mode 100644 src/libtracing/protos/perfetto/metrics/chrome/performance_mark_hashes.proto create mode 100644 src/libtracing/protos/perfetto/metrics/chrome/reported_by_page.proto create mode 100644 src/libtracing/protos/perfetto/metrics/chrome/scroll_jank.proto create mode 100644 src/libtracing/protos/perfetto/metrics/chrome/scroll_jank_v3.proto create mode 100644 src/libtracing/protos/perfetto/metrics/chrome/slice_names.proto create mode 100644 src/libtracing/protos/perfetto/metrics/chrome/test_chrome_metric.proto create mode 100644 src/libtracing/protos/perfetto/metrics/chrome/touch_jank.proto create mode 100644 src/libtracing/protos/perfetto/metrics/chrome/unsymbolized_args.proto create mode 100644 src/libtracing/protos/perfetto/metrics/chrome/user_event_hashes.proto create mode 100644 src/libtracing/protos/perfetto/metrics/custom_options.proto create mode 100644 src/libtracing/protos/perfetto/metrics/metrics.proto create mode 100644 src/libtracing/protos/perfetto/metrics/perfetto_merged_metrics.proto create mode 100644 src/libtracing/protos/perfetto/metrics/webview/all_webview_metrics.proto create mode 100644 src/libtracing/protos/perfetto/metrics/webview/webview_jank_approximation.proto create mode 100644 src/libtracing/protos/perfetto/trace/android/android_game_intervention_list.proto create mode 100644 src/libtracing/protos/perfetto/trace/android/android_input_event.proto create mode 100644 src/libtracing/protos/perfetto/trace/android/android_log.proto create mode 100644 src/libtracing/protos/perfetto/trace/android/android_system_property.proto create mode 100644 src/libtracing/protos/perfetto/trace/android/camera_event.proto create mode 100644 src/libtracing/protos/perfetto/trace/android/frame_timeline_event.proto create mode 100644 src/libtracing/protos/perfetto/trace/android/gpu_mem_event.proto create mode 100644 src/libtracing/protos/perfetto/trace/android/graphics_frame_event.proto create mode 100644 src/libtracing/protos/perfetto/trace/android/initial_display_state.proto create mode 100644 src/libtracing/protos/perfetto/trace/android/network_trace.proto create mode 100644 src/libtracing/protos/perfetto/trace/android/packages_list.proto create mode 100644 src/libtracing/protos/perfetto/trace/android/protolog.proto create mode 100644 src/libtracing/protos/perfetto/trace/android/shell_transition.proto create mode 100644 src/libtracing/protos/perfetto/trace/android/surfaceflinger_common.proto create mode 100644 src/libtracing/protos/perfetto/trace/android/surfaceflinger_layers.proto create mode 100644 src/libtracing/protos/perfetto/trace/android/surfaceflinger_transactions.proto create mode 100644 src/libtracing/protos/perfetto/trace/android/winscope.proto create mode 100644 src/libtracing/protos/perfetto/trace/chrome/chrome_benchmark_metadata.proto create mode 100644 src/libtracing/protos/perfetto/trace/chrome/chrome_metadata.proto create mode 100644 src/libtracing/protos/perfetto/trace/chrome/chrome_trace_event.proto create mode 100644 src/libtracing/protos/perfetto/trace/chrome/chrome_trace_packet.proto create mode 100644 src/libtracing/protos/perfetto/trace/chrome/chrome_trigger.proto create mode 100644 src/libtracing/protos/perfetto/trace/chrome/v8.proto create mode 100644 src/libtracing/protos/perfetto/trace/clock_snapshot.proto create mode 100644 src/libtracing/protos/perfetto/trace/etw/all_protos.gni create mode 100644 src/libtracing/protos/perfetto/trace/etw/etw.proto create mode 100644 src/libtracing/protos/perfetto/trace/etw/etw_event.proto create mode 100644 src/libtracing/protos/perfetto/trace/etw/etw_event_bundle.proto create mode 100644 src/libtracing/protos/perfetto/trace/extension_descriptor.proto create mode 100644 src/libtracing/protos/perfetto/trace/filesystem/inode_file_map.proto create mode 100644 src/libtracing/protos/perfetto/trace/ftrace/all_protos.gni create mode 100644 src/libtracing/protos/perfetto/trace/ftrace/android_fs.proto create mode 100644 src/libtracing/protos/perfetto/trace/ftrace/binder.proto create mode 100644 src/libtracing/protos/perfetto/trace/ftrace/block.proto create mode 100644 src/libtracing/protos/perfetto/trace/ftrace/cgroup.proto create mode 100644 src/libtracing/protos/perfetto/trace/ftrace/clk.proto create mode 100644 src/libtracing/protos/perfetto/trace/ftrace/cma.proto create mode 100644 src/libtracing/protos/perfetto/trace/ftrace/compaction.proto create mode 100644 src/libtracing/protos/perfetto/trace/ftrace/cpuhp.proto create mode 100644 src/libtracing/protos/perfetto/trace/ftrace/cros_ec.proto create mode 100644 src/libtracing/protos/perfetto/trace/ftrace/dma_fence.proto create mode 100644 src/libtracing/protos/perfetto/trace/ftrace/dmabuf_heap.proto create mode 100644 src/libtracing/protos/perfetto/trace/ftrace/dpu.proto create mode 100644 src/libtracing/protos/perfetto/trace/ftrace/drm.proto create mode 100644 src/libtracing/protos/perfetto/trace/ftrace/ext4.proto create mode 100644 src/libtracing/protos/perfetto/trace/ftrace/f2fs.proto create mode 100644 src/libtracing/protos/perfetto/trace/ftrace/fastrpc.proto create mode 100644 src/libtracing/protos/perfetto/trace/ftrace/fence.proto create mode 100644 src/libtracing/protos/perfetto/trace/ftrace/filemap.proto create mode 100644 src/libtracing/protos/perfetto/trace/ftrace/ftrace.proto create mode 100644 src/libtracing/protos/perfetto/trace/ftrace/ftrace_event.proto create mode 100644 src/libtracing/protos/perfetto/trace/ftrace/ftrace_event_bundle.proto create mode 100644 src/libtracing/protos/perfetto/trace/ftrace/ftrace_stats.proto create mode 100644 src/libtracing/protos/perfetto/trace/ftrace/g2d.proto create mode 100644 src/libtracing/protos/perfetto/trace/ftrace/generic.proto create mode 100644 src/libtracing/protos/perfetto/trace/ftrace/gpu_mem.proto create mode 100644 src/libtracing/protos/perfetto/trace/ftrace/gpu_scheduler.proto create mode 100644 src/libtracing/protos/perfetto/trace/ftrace/hyp.proto create mode 100644 src/libtracing/protos/perfetto/trace/ftrace/i2c.proto create mode 100644 src/libtracing/protos/perfetto/trace/ftrace/ion.proto create mode 100644 src/libtracing/protos/perfetto/trace/ftrace/ipi.proto create mode 100644 src/libtracing/protos/perfetto/trace/ftrace/irq.proto create mode 100644 src/libtracing/protos/perfetto/trace/ftrace/kfree.proto create mode 100644 src/libtracing/protos/perfetto/trace/ftrace/kmalloc.proto create mode 100644 src/libtracing/protos/perfetto/trace/ftrace/kmem.proto create mode 100644 src/libtracing/protos/perfetto/trace/ftrace/kvm.proto create mode 100644 src/libtracing/protos/perfetto/trace/ftrace/lowmemorykiller.proto create mode 100644 src/libtracing/protos/perfetto/trace/ftrace/lwis.proto create mode 100644 src/libtracing/protos/perfetto/trace/ftrace/mali.proto create mode 100644 src/libtracing/protos/perfetto/trace/ftrace/mdss.proto create mode 100644 src/libtracing/protos/perfetto/trace/ftrace/mm_event.proto create mode 100644 src/libtracing/protos/perfetto/trace/ftrace/net.proto create mode 100644 src/libtracing/protos/perfetto/trace/ftrace/oom.proto create mode 100644 src/libtracing/protos/perfetto/trace/ftrace/panel.proto create mode 100644 src/libtracing/protos/perfetto/trace/ftrace/perf_trace_counters.proto create mode 100644 src/libtracing/protos/perfetto/trace/ftrace/power.proto create mode 100644 src/libtracing/protos/perfetto/trace/ftrace/print.proto create mode 100644 src/libtracing/protos/perfetto/trace/ftrace/printk.proto create mode 100644 src/libtracing/protos/perfetto/trace/ftrace/raw_syscalls.proto create mode 100644 src/libtracing/protos/perfetto/trace/ftrace/regulator.proto create mode 100644 src/libtracing/protos/perfetto/trace/ftrace/rpm.proto create mode 100644 src/libtracing/protos/perfetto/trace/ftrace/samsung.proto create mode 100644 src/libtracing/protos/perfetto/trace/ftrace/sched.proto create mode 100644 src/libtracing/protos/perfetto/trace/ftrace/scm.proto create mode 100644 src/libtracing/protos/perfetto/trace/ftrace/sde.proto create mode 100644 src/libtracing/protos/perfetto/trace/ftrace/signal.proto create mode 100644 src/libtracing/protos/perfetto/trace/ftrace/skb.proto create mode 100644 src/libtracing/protos/perfetto/trace/ftrace/sock.proto create mode 100644 src/libtracing/protos/perfetto/trace/ftrace/sync.proto create mode 100644 src/libtracing/protos/perfetto/trace/ftrace/synthetic.proto create mode 100644 src/libtracing/protos/perfetto/trace/ftrace/systrace.proto create mode 100644 src/libtracing/protos/perfetto/trace/ftrace/task.proto create mode 100644 src/libtracing/protos/perfetto/trace/ftrace/tcp.proto create mode 100644 src/libtracing/protos/perfetto/trace/ftrace/test_bundle_wrapper.proto create mode 100644 src/libtracing/protos/perfetto/trace/ftrace/thermal.proto create mode 100644 src/libtracing/protos/perfetto/trace/ftrace/trusty.proto create mode 100644 src/libtracing/protos/perfetto/trace/ftrace/ufs.proto create mode 100644 src/libtracing/protos/perfetto/trace/ftrace/v4l2.proto create mode 100644 src/libtracing/protos/perfetto/trace/ftrace/virtio_gpu.proto create mode 100644 src/libtracing/protos/perfetto/trace/ftrace/virtio_video.proto create mode 100644 src/libtracing/protos/perfetto/trace/ftrace/vmscan.proto create mode 100644 src/libtracing/protos/perfetto/trace/ftrace/workqueue.proto create mode 100644 src/libtracing/protos/perfetto/trace/gpu/gpu_counter_event.proto create mode 100644 src/libtracing/protos/perfetto/trace/gpu/gpu_log.proto create mode 100644 src/libtracing/protos/perfetto/trace/gpu/gpu_render_stage_event.proto create mode 100644 src/libtracing/protos/perfetto/trace/gpu/vulkan_api_event.proto create mode 100644 src/libtracing/protos/perfetto/trace/gpu/vulkan_memory_event.proto create mode 100644 src/libtracing/protos/perfetto/trace/interned_data/interned_data.proto create mode 100644 src/libtracing/protos/perfetto/trace/memory_graph.proto create mode 100644 src/libtracing/protos/perfetto/trace/perfetto/perfetto_metatrace.proto create mode 100644 src/libtracing/protos/perfetto/trace/perfetto/tracing_service_event.proto create mode 100644 src/libtracing/protos/perfetto/trace/perfetto_trace.proto create mode 100644 src/libtracing/protos/perfetto/trace/power/android_energy_estimation_breakdown.proto create mode 100644 src/libtracing/protos/perfetto/trace/power/android_entity_state_residency.proto create mode 100644 src/libtracing/protos/perfetto/trace/power/battery_counters.proto create mode 100644 src/libtracing/protos/perfetto/trace/power/power_rails.proto create mode 100644 src/libtracing/protos/perfetto/trace/profiling/deobfuscation.proto create mode 100644 src/libtracing/protos/perfetto/trace/profiling/heap_graph.proto create mode 100644 src/libtracing/protos/perfetto/trace/profiling/profile_common.proto create mode 100644 src/libtracing/protos/perfetto/trace/profiling/profile_packet.proto create mode 100644 src/libtracing/protos/perfetto/trace/profiling/smaps.proto create mode 100644 src/libtracing/protos/perfetto/trace/ps/process_stats.proto create mode 100644 src/libtracing/protos/perfetto/trace/ps/process_tree.proto create mode 100644 src/libtracing/protos/perfetto/trace/remote_clock_sync.proto create mode 100644 src/libtracing/protos/perfetto/trace/statsd/statsd_atom.proto create mode 100644 src/libtracing/protos/perfetto/trace/sys_stats/sys_stats.proto create mode 100644 src/libtracing/protos/perfetto/trace/system_info.proto create mode 100644 src/libtracing/protos/perfetto/trace/system_info/cpu_info.proto create mode 100644 src/libtracing/protos/perfetto/trace/test_event.proto create mode 100644 src/libtracing/protos/perfetto/trace/test_extensions.proto create mode 100644 src/libtracing/protos/perfetto/trace/trace.proto create mode 100644 src/libtracing/protos/perfetto/trace/trace_packet.proto create mode 100644 src/libtracing/protos/perfetto/trace/trace_packet_defaults.proto create mode 100644 src/libtracing/protos/perfetto/trace/trace_uuid.proto create mode 100644 src/libtracing/protos/perfetto/trace/track_event/chrome_active_processes.proto create mode 100644 src/libtracing/protos/perfetto/trace/track_event/chrome_application_state_info.proto create mode 100644 src/libtracing/protos/perfetto/trace/track_event/chrome_compositor_scheduler_state.proto create mode 100644 src/libtracing/protos/perfetto/trace/track_event/chrome_content_settings_event_info.proto create mode 100644 src/libtracing/protos/perfetto/trace/track_event/chrome_frame_reporter.proto create mode 100644 src/libtracing/protos/perfetto/trace/track_event/chrome_histogram_sample.proto create mode 100644 src/libtracing/protos/perfetto/trace/track_event/chrome_keyed_service.proto create mode 100644 src/libtracing/protos/perfetto/trace/track_event/chrome_latency_info.proto create mode 100644 src/libtracing/protos/perfetto/trace/track_event/chrome_legacy_ipc.proto create mode 100644 src/libtracing/protos/perfetto/trace/track_event/chrome_message_pump.proto create mode 100644 src/libtracing/protos/perfetto/trace/track_event/chrome_mojo_event_info.proto create mode 100644 src/libtracing/protos/perfetto/trace/track_event/chrome_process_descriptor.proto create mode 100644 src/libtracing/protos/perfetto/trace/track_event/chrome_renderer_scheduler_state.proto create mode 100644 src/libtracing/protos/perfetto/trace/track_event/chrome_thread_descriptor.proto create mode 100644 src/libtracing/protos/perfetto/trace/track_event/chrome_user_event.proto create mode 100644 src/libtracing/protos/perfetto/trace/track_event/chrome_window_handle_event_info.proto create mode 100644 src/libtracing/protos/perfetto/trace/track_event/counter_descriptor.proto create mode 100644 src/libtracing/protos/perfetto/trace/track_event/debug_annotation.proto create mode 100644 src/libtracing/protos/perfetto/trace/track_event/log_message.proto create mode 100644 src/libtracing/protos/perfetto/trace/track_event/pixel_modem.proto create mode 100644 src/libtracing/protos/perfetto/trace/track_event/process_descriptor.proto create mode 100644 src/libtracing/protos/perfetto/trace/track_event/range_of_interest.proto create mode 100644 src/libtracing/protos/perfetto/trace/track_event/screenshot.proto create mode 100644 src/libtracing/protos/perfetto/trace/track_event/source_location.proto create mode 100644 src/libtracing/protos/perfetto/trace/track_event/task_execution.proto create mode 100644 src/libtracing/protos/perfetto/trace/track_event/thread_descriptor.proto create mode 100644 src/libtracing/protos/perfetto/trace/track_event/track_descriptor.proto create mode 100644 src/libtracing/protos/perfetto/trace/track_event/track_event.proto create mode 100644 src/libtracing/protos/perfetto/trace/translation/translation_table.proto create mode 100644 src/libtracing/protos/perfetto/trace/trigger.proto create mode 100644 src/libtracing/protos/perfetto/trace/ui_state.proto create mode 100644 src/libtracing/protos/perfetto/trace_processor/metatrace_categories.proto create mode 100644 src/libtracing/protos/perfetto/trace_processor/metrics_impl.proto create mode 100644 src/libtracing/protos/perfetto/trace_processor/proto_files.gni create mode 100644 src/libtracing/protos/perfetto/trace_processor/serialization.proto create mode 100644 src/libtracing/protos/perfetto/trace_processor/stack.proto create mode 100644 src/libtracing/protos/perfetto/trace_processor/trace_processor.proto create mode 100644 src/libtracing/protos/third_party/CHROMIUM_OWNERS create mode 100644 src/libtracing/protos/third_party/OWNERS create mode 100644 src/libtracing/protos/third_party/chromium/chrome_track_event.proto create mode 100644 src/libtracing/protos/third_party/chromium/sources.gni create mode 100644 src/libtracing/protos/third_party/pprof/profile.proto create mode 100644 src/libtracing/protos/third_party/statsd/shell_config.proto create mode 100644 src/libtracing/protos/third_party/statsd/shell_data.proto create mode 100644 src/libtracing/protozero_src/copyable_ptr_unittest.cc create mode 100644 src/libtracing/protozero_src/field.cc create mode 100644 src/libtracing/protozero_src/filtering/filter_bytecode_common.h create mode 100644 src/libtracing/protozero_src/filtering/filter_bytecode_generator.cc create mode 100644 src/libtracing/protozero_src/filtering/filter_bytecode_generator.h create mode 100644 src/libtracing/protozero_src/filtering/filter_bytecode_generator_unittest.cc create mode 100644 src/libtracing/protozero_src/filtering/filter_bytecode_parser.cc create mode 100644 src/libtracing/protozero_src/filtering/filter_bytecode_parser.h create mode 100644 src/libtracing/protozero_src/filtering/filter_bytecode_parser_fuzzer.cc create mode 100644 src/libtracing/protozero_src/filtering/filter_bytecode_parser_unittest.cc create mode 100644 src/libtracing/protozero_src/filtering/filter_util.cc create mode 100644 src/libtracing/protozero_src/filtering/filter_util.h create mode 100644 src/libtracing/protozero_src/filtering/filter_util_unittest.cc create mode 100644 src/libtracing/protozero_src/filtering/message_filter.cc create mode 100644 src/libtracing/protozero_src/filtering/message_filter.h create mode 100644 src/libtracing/protozero_src/filtering/message_filter_benchmark.cc create mode 100644 src/libtracing/protozero_src/filtering/message_filter_fuzzer.cc create mode 100644 src/libtracing/protozero_src/filtering/message_filter_unittest.cc create mode 100644 src/libtracing/protozero_src/filtering/message_tokenizer.h create mode 100644 src/libtracing/protozero_src/filtering/message_tokenizer_unittest.cc create mode 100644 src/libtracing/protozero_src/filtering/string_filter.cc create mode 100644 src/libtracing/protozero_src/filtering/string_filter.h create mode 100644 src/libtracing/protozero_src/filtering/string_filter_benchmark.cc create mode 100644 src/libtracing/protozero_src/filtering/string_filter_unittest.cc create mode 100644 src/libtracing/protozero_src/gen_field_helpers.cc create mode 100644 src/libtracing/protozero_src/message.cc create mode 100644 src/libtracing/protozero_src/message_arena.cc create mode 100644 src/libtracing/protozero_src/message_arena_unittest.cc create mode 100644 src/libtracing/protozero_src/message_handle_unittest.cc create mode 100644 src/libtracing/protozero_src/message_unittest.cc create mode 100644 src/libtracing/protozero_src/packed_repeated_fields.cc create mode 100644 src/libtracing/protozero_src/proto_decoder.cc create mode 100644 src/libtracing/protozero_src/proto_decoder_fuzzer.cc create mode 100644 src/libtracing/protozero_src/proto_decoder_unittest.cc create mode 100644 src/libtracing/protozero_src/proto_ring_buffer.cc create mode 100644 src/libtracing/protozero_src/proto_ring_buffer_unittest.cc create mode 100644 src/libtracing/protozero_src/proto_utils_unittest.cc create mode 100644 src/libtracing/protozero_src/protoc_plugin/cppgen_plugin.cc create mode 100644 src/libtracing/protozero_src/protoc_plugin/protozero_c_plugin.cc create mode 100644 src/libtracing/protozero_src/protoc_plugin/protozero_plugin.cc create mode 100644 src/libtracing/protozero_src/scattered_heap_buffer.cc create mode 100644 src/libtracing/protozero_src/scattered_stream_null_delegate.cc create mode 100644 src/libtracing/protozero_src/scattered_stream_writer.cc create mode 100644 src/libtracing/protozero_src/scattered_stream_writer_unittest.cc create mode 100644 src/libtracing/protozero_src/static_buffer.cc create mode 100644 src/libtracing/protozero_src/test/cppgen_conformance_unittest.cc create mode 100644 src/libtracing/protozero_src/test/example_proto/extensions.proto create mode 100644 src/libtracing/protozero_src/test/example_proto/library.proto create mode 100644 src/libtracing/protozero_src/test/example_proto/library_internals/galaxies.proto create mode 100644 src/libtracing/protozero_src/test/example_proto/other_package/test_messages.proto create mode 100644 src/libtracing/protozero_src/test/example_proto/subpackage/test_messages.proto create mode 100644 src/libtracing/protozero_src/test/example_proto/test_messages.proto create mode 100644 src/libtracing/protozero_src/test/example_proto/upper_import.proto create mode 100644 src/libtracing/protozero_src/test/fake_scattered_buffer.cc create mode 100644 src/libtracing/protozero_src/test/fake_scattered_buffer.h create mode 100644 src/libtracing/protozero_src/test/proto_ring_buffer_benchmark.cc create mode 100644 src/libtracing/protozero_src/test/protozero_benchmark.cc create mode 100644 src/libtracing/protozero_src/test/protozero_conformance_unittest.cc create mode 100644 src/libtracing/protozero_src/virtual_destructors.cc diff --git a/src/libtracing/perfetto/base/BUILD.gn b/src/libtracing/perfetto/base/BUILD.gn new file mode 100644 index 000000000..357f89a0c --- /dev/null +++ b/src/libtracing/perfetto/base/BUILD.gn @@ -0,0 +1,33 @@ +# Copyright (C) 2017 The Android Open Source Project +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("../../../gn/perfetto.gni") + +source_set("base") { + sources = [ + "build_config.h", + "compiler.h", + "export.h", + "flat_set.h", + "logging.h", + "platform_handle.h", + "proc_utils.h", + "status.h", + "task_runner.h", + "template_util.h", + "thread_utils.h", + "time.h", + ] + public_deps = [ "../public:base" ] +} diff --git a/src/libtracing/perfetto/base/build_config.h b/src/libtracing/perfetto/base/build_config.h new file mode 100644 index 000000000..5f7a7bd96 --- /dev/null +++ b/src/libtracing/perfetto/base/build_config.h @@ -0,0 +1,160 @@ +/* + * Copyright (C) 2017 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef INCLUDE_PERFETTO_BASE_BUILD_CONFIG_H_ +#define INCLUDE_PERFETTO_BASE_BUILD_CONFIG_H_ + +// Allows to define build flags that give a compiler error if the header that +// defined the flag is not included, instead of silently ignoring the #if block. +#define PERFETTO_BUILDFLAG_CAT_INDIRECT(a, b) a##b +#define PERFETTO_BUILDFLAG_CAT(a, b) PERFETTO_BUILDFLAG_CAT_INDIRECT(a, b) +#define PERFETTO_BUILDFLAG(flag) \ + (PERFETTO_BUILDFLAG_CAT(PERFETTO_BUILDFLAG_DEFINE_, flag)()) + +#if defined(__ANDROID__) +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_ANDROID() 1 +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_LINUX() 0 +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_WIN() 0 +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_APPLE() 0 +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_MAC() 0 +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_IOS() 0 +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_WASM() 0 +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_FUCHSIA() 0 +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_NACL() 0 +#elif defined(__APPLE__) +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_ANDROID() 0 +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_APPLE() 1 +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_LINUX() 0 +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_WIN() 0 +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_WASM() 0 +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_FUCHSIA() 0 +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_NACL() 0 +// Include TARGET_OS_IPHONE when on __APPLE__ systems. +#include +#if defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_MAC() 0 +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_IOS() 1 +#else +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_MAC() 1 +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_IOS() 0 +#endif +#elif defined(__linux__) +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_ANDROID() 0 +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_LINUX() 1 +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_WIN() 0 +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_APPLE() 0 +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_MAC() 0 +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_IOS() 0 +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_WASM() 0 +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_FUCHSIA() 0 +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_NACL() 0 +#elif defined(_WIN32) +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_ANDROID() 0 +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_LINUX() 0 +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_WIN() 1 +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_APPLE() 0 +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_MAC() 0 +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_IOS() 0 +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_WASM() 0 +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_FUCHSIA() 0 +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_NACL() 0 +#elif defined(__EMSCRIPTEN__) +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_ANDROID() 0 +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_LINUX() 0 +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_WIN() 0 +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_APPLE() 0 +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_MAC() 0 +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_IOS() 0 +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_WASM() 1 +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_FUCHSIA() 0 +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_NACL() 0 +#elif defined(__Fuchsia__) +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_ANDROID() 0 +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_APPLE() 0 +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_MAC() 0 +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_IOS() 0 +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_LINUX() 0 +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_WIN() 0 +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_WASM() 0 +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_FUCHSIA() 1 +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_NACL() 0 +#elif defined(__native_client__) +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_ANDROID() 0 +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_LINUX() 0 +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_WIN() 0 +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_APPLE() 0 +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_MAC() 0 +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_IOS() 0 +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_WASM() 0 +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_FUCHSIA() 0 +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_NACL() 1 +#else +#error OS not supported (see build_config.h) +#endif + +#if defined(__clang__) +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_COMPILER_CLANG() 1 +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_COMPILER_GCC() 0 +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_COMPILER_MSVC() 0 +#elif defined(__GNUC__) // Careful: Clang also defines this! +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_COMPILER_CLANG() 0 +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_COMPILER_GCC() 1 +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_COMPILER_MSVC() 0 +#elif defined(_MSC_VER) +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_COMPILER_CLANG() 0 +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_COMPILER_GCC() 0 +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_COMPILER_MSVC() 1 +#else +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_COMPILER_CLANG() 0 +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_COMPILER_GCC() 0 +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_COMPILER_MSVC() 0 +#endif + +#if defined(PERFETTO_BUILD_WITH_ANDROID_USERDEBUG) +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_ANDROID_USERDEBUG_BUILD() 1 +#else +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_ANDROID_USERDEBUG_BUILD() 0 +#endif + +// Processor architecture detection. For more info on what's defined, see: +// http://msdn.microsoft.com/en-us/library/b0084kay.aspx +// http://www.agner.org/optimize/calling_conventions.pdf +// or with gcc, run: "echo | gcc -E -dM -" +#if defined(__aarch64__) || defined(_M_ARM64) +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_ARCH_CPU_ARM64() 1 +#else +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_ARCH_CPU_ARM64() 0 +#endif + +#if defined(__x86_64__) || defined(_M_X64) +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_ARCH_CPU_X86_64() 1 +#else +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_ARCH_CPU_X86_64() 0 +#endif + +// perfetto_build_flags.h contains the tweakable build flags defined via GN. +// - In GN builds (e.g., standalone, chromium, v8) this file is generated at +// build time via the gen_rule //gn/gen_buildflags. +// - In Android in-tree builds, this file is generated by tools/gen_android_bp +// and checked in into include/perfetto/base/build_configs/android_tree/. The +// default cflags add this path to the default include path. +// - Similarly, in bazel builds, this file is generated by tools/gen_bazel and +// checked in into include/perfetto/base/build_configs/bazel/. +// - In amalgamated builds, this file is generated by tools/gen_amalgamated and +// added to the amalgamated headers. +#include "perfetto_build_flags.h" // no-include-violation-check + +#endif // INCLUDE_PERFETTO_BASE_BUILD_CONFIG_H_ diff --git a/src/libtracing/perfetto/base/build_configs/android_tree/perfetto_build_flags.h b/src/libtracing/perfetto/base/build_configs/android_tree/perfetto_build_flags.h new file mode 100644 index 000000000..c36d04b21 --- /dev/null +++ b/src/libtracing/perfetto/base/build_configs/android_tree/perfetto_build_flags.h @@ -0,0 +1,51 @@ +/* + * Copyright (C) 2019 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// Generated by write_buildflag_header.py + +// fix_include_guards: off +#ifndef GEN_BUILD_CONFIG_PERFETTO_BUILD_FLAGS_H_ +#define GEN_BUILD_CONFIG_PERFETTO_BUILD_FLAGS_H_ + +// clang-format off +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_ANDROID_BUILD() (1) +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_CHROMIUM_BUILD() (0) +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_STANDALONE_BUILD() (0) +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_START_DAEMONS() (0) +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_IPC() (1) +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_WATCHDOG() (PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_ANDROID() || PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_LINUX()) +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_COMPONENT_BUILD() (0) +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_FORCE_DLOG_ON() (0) +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_FORCE_DLOG_OFF() (0) +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_FORCE_DCHECK_ON() (0) +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_FORCE_DCHECK_OFF() (0) +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_VERBOSE_LOGS() (1) +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_VERSION_GEN() (1) +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_TP_PERCENTILE() (1) +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_TP_LINENOISE() (0) +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_TP_HTTPD() (1) +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_TP_JSON() (0) +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_LOCAL_SYMBOLIZER() (PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_LINUX() || PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_MAC() ||PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_WIN()) +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_ZLIB() (1) +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_TRACED_PERF() (1) +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_HEAPPROFD() (1) +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_STDERR_CRASH_DUMP() (0) +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_X64_CPU_OPT() (0) +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_LLVM_DEMANGLE() (0) +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_SYSTEM_CONSUMER() (1) + +// clang-format on +#endif // GEN_BUILD_CONFIG_PERFETTO_BUILD_FLAGS_H_ diff --git a/src/libtracing/perfetto/base/build_configs/bazel/perfetto_build_flags.h b/src/libtracing/perfetto/base/build_configs/bazel/perfetto_build_flags.h new file mode 100644 index 000000000..54fe273b6 --- /dev/null +++ b/src/libtracing/perfetto/base/build_configs/bazel/perfetto_build_flags.h @@ -0,0 +1,51 @@ +/* + * Copyright (C) 2019 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// Generated by write_buildflag_header.py + +// fix_include_guards: off +#ifndef GEN_BUILD_CONFIG_PERFETTO_BUILD_FLAGS_H_ +#define GEN_BUILD_CONFIG_PERFETTO_BUILD_FLAGS_H_ + +// clang-format off +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_ANDROID_BUILD() (0) +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_CHROMIUM_BUILD() (0) +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_STANDALONE_BUILD() (1) +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_START_DAEMONS() (1) +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_IPC() (1) +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_WATCHDOG() (0) +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_COMPONENT_BUILD() (0) +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_FORCE_DLOG_ON() (0) +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_FORCE_DLOG_OFF() (0) +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_FORCE_DCHECK_ON() (0) +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_FORCE_DCHECK_OFF() (1) +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_VERBOSE_LOGS() (1) +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_VERSION_GEN() (1) +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_TP_PERCENTILE() (1) +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_TP_LINENOISE() (1) +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_TP_HTTPD() (1) +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_TP_JSON() (1) +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_LOCAL_SYMBOLIZER() (PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_LINUX() || PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_MAC() ||PERFETTO_BUILDFLAG_DEFINE_PERFETTO_OS_WIN()) +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_ZLIB() (1) +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_TRACED_PERF() (0) +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_HEAPPROFD() (0) +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_STDERR_CRASH_DUMP() (0) +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_X64_CPU_OPT() (0) +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_LLVM_DEMANGLE() (1) +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_SYSTEM_CONSUMER() (1) + +// clang-format on +#endif // GEN_BUILD_CONFIG_PERFETTO_BUILD_FLAGS_H_ diff --git a/src/libtracing/perfetto/base/compiler.h b/src/libtracing/perfetto/base/compiler.h new file mode 100644 index 000000000..e4b6b0cae --- /dev/null +++ b/src/libtracing/perfetto/base/compiler.h @@ -0,0 +1,157 @@ +/* + * Copyright (C) 2019 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef INCLUDE_PERFETTO_BASE_COMPILER_H_ +#define INCLUDE_PERFETTO_BASE_COMPILER_H_ + +#include +#include + +#include "perfetto/public/compiler.h" + +// __has_attribute is supported only by clang and recent versions of GCC. +// Add a layer to wrap the __has_attribute macro. +#if defined(__has_attribute) +#define PERFETTO_HAS_ATTRIBUTE(x) __has_attribute(x) +#else +#define PERFETTO_HAS_ATTRIBUTE(x) 0 +#endif + +#if defined(__GNUC__) || defined(__clang__) +#define PERFETTO_WARN_UNUSED_RESULT __attribute__((warn_unused_result)) +#else +#define PERFETTO_WARN_UNUSED_RESULT +#endif + +#if defined(__GNUC__) || defined(__clang__) +#define PERFETTO_UNUSED __attribute__((unused)) +#else +#define PERFETTO_UNUSED +#endif + +#if defined(__clang__) +#define PERFETTO_ALWAYS_INLINE __attribute__((__always_inline__)) +#define PERFETTO_NO_INLINE __attribute__((__noinline__)) +#else +// GCC is too pedantic and often fails with the error: +// "always_inline function might not be inlinable" +#define PERFETTO_ALWAYS_INLINE +#define PERFETTO_NO_INLINE +#endif + +#if defined(__GNUC__) || defined(__clang__) +#define PERFETTO_NORETURN __attribute__((__noreturn__)) +#else +#define PERFETTO_NORETURN __declspec(noreturn) +#endif + +#if defined(__GNUC__) || defined(__clang__) +#define PERFETTO_DEBUG_FUNCTION_IDENTIFIER() __PRETTY_FUNCTION__ +#elif defined(_MSC_VER) +#define PERFETTO_DEBUG_FUNCTION_IDENTIFIER() __FUNCSIG__ +#else +#define PERFETTO_DEBUG_FUNCTION_IDENTIFIER() \ + static_assert(false, "Not implemented for this compiler") +#endif + +#if defined(__GNUC__) || defined(__clang__) +#define PERFETTO_PRINTF_FORMAT(x, y) \ + __attribute__((__format__(__printf__, x, y))) +#else +#define PERFETTO_PRINTF_FORMAT(x, y) +#endif + +#if defined(__GNUC__) || defined(__clang__) +#define PERFETTO_POPCOUNT(x) __builtin_popcountll(x) +#else +#include +#define PERFETTO_POPCOUNT(x) __popcnt64(x) +#endif + +#if defined(__clang__) +#if __has_feature(address_sanitizer) || defined(__SANITIZE_ADDRESS__) +extern "C" void __asan_poison_memory_region(void const volatile*, size_t); +extern "C" void __asan_unpoison_memory_region(void const volatile*, size_t); +#define PERFETTO_ASAN_POISON(a, s) __asan_poison_memory_region((a), (s)) +#define PERFETTO_ASAN_UNPOISON(a, s) __asan_unpoison_memory_region((a), (s)) +#else +#define PERFETTO_ASAN_POISON(addr, size) +#define PERFETTO_ASAN_UNPOISON(addr, size) +#endif // __has_feature(address_sanitizer) +#else +#define PERFETTO_ASAN_POISON(addr, size) +#define PERFETTO_ASAN_UNPOISON(addr, size) +#endif // __clang__ + +#if defined(__GNUC__) || defined(__clang__) +#define PERFETTO_IS_LITTLE_ENDIAN() __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ +#else +// Assume all MSVC targets are little endian. +#define PERFETTO_IS_LITTLE_ENDIAN() 1 +#endif + +// This is used for exporting xxxMain() symbols (e.g., PerfettoCmdMain, +// ProbesMain) from libperfetto.so when the GN arg monolithic_binaries = false. +#if defined(__GNUC__) || defined(__clang__) +#define PERFETTO_EXPORT_ENTRYPOINT __attribute__((visibility("default"))) +#else +// TODO(primiano): on Windows this should be a pair of dllexport/dllimport. But +// that requires a -DXXX_IMPLEMENTATION depending on whether we are on the +// impl-site or call-site. Right now it's not worth the trouble as we +// force-export the xxxMain() symbols only on Android, where we pack all the +// code for N binaries into one .so to save binary size. On Windows we support +// only monolithic binaries, as they are easier to deal with. +#define PERFETTO_EXPORT_ENTRYPOINT +#endif + +// Disables thread safety analysis for functions where the compiler can't +// accurate figure out which locks are being held. +#if defined(__clang__) +#define PERFETTO_NO_THREAD_SAFETY_ANALYSIS \ + __attribute__((no_thread_safety_analysis)) +#else +#define PERFETTO_NO_THREAD_SAFETY_ANALYSIS +#endif + +// Disables undefined behavior analysis for a function. +#if defined(__clang__) +#define PERFETTO_NO_SANITIZE_UNDEFINED __attribute__((no_sanitize("undefined"))) +#else +#define PERFETTO_NO_SANITIZE_UNDEFINED +#endif + +// Avoid calling the exit-time destructor on an object with static lifetime. +#if PERFETTO_HAS_ATTRIBUTE(no_destroy) +#define PERFETTO_HAS_NO_DESTROY() 1 +#define PERFETTO_NO_DESTROY __attribute__((no_destroy)) +#else +#define PERFETTO_HAS_NO_DESTROY() 0 +#define PERFETTO_NO_DESTROY +#endif + +// Macro for telling -Wimplicit-fallthrough that a fallthrough is intentional. +#define PERFETTO_FALLTHROUGH [[fallthrough]] + +namespace perfetto { +namespace base { + +template +inline void ignore_result(const T&...) {} + +} // namespace base +} // namespace perfetto + +#endif // INCLUDE_PERFETTO_BASE_COMPILER_H_ diff --git a/src/libtracing/perfetto/base/export.h b/src/libtracing/perfetto/base/export.h new file mode 100644 index 000000000..14044b37c --- /dev/null +++ b/src/libtracing/perfetto/base/export.h @@ -0,0 +1,41 @@ +/* + * Copyright (C) 2018 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef INCLUDE_PERFETTO_BASE_EXPORT_H_ +#define INCLUDE_PERFETTO_BASE_EXPORT_H_ + +#include "perfetto/base/build_config.h" +#include "perfetto/public/abi/export.h" + +// PERFETTO_EXPORT_COMPONENT: Exports a symbol among C++ components when +// building with is_component = true (mostly used by chromium build). +#if PERFETTO_BUILDFLAG(PERFETTO_COMPONENT_BUILD) + +#if defined(PERFETTO_IMPLEMENTATION) +#define PERFETTO_EXPORT_COMPONENT PERFETTO_INTERNAL_DLL_EXPORT +#else +#define PERFETTO_EXPORT_COMPONENT PERFETTO_INTERNAL_DLL_IMPORT +#endif + +#else // !PERFETTO_BUILDFLAG(PERFETTO_COMPONENT_BUILD) + +#if !defined(PERFETTO_EXPORT_COMPONENT) +#define PERFETTO_EXPORT_COMPONENT +#endif // !defined(PERFETTO_EXPORT_COMPONENT) + +#endif // PERFETTO_BUILDFLAG(PERFETTO_COMPONENT_BUILD) + +#endif // INCLUDE_PERFETTO_BASE_EXPORT_H_ diff --git a/src/libtracing/perfetto/base/flat_set.h b/src/libtracing/perfetto/base/flat_set.h new file mode 100644 index 000000000..9390537b3 --- /dev/null +++ b/src/libtracing/perfetto/base/flat_set.h @@ -0,0 +1,100 @@ +/* + * Copyright (C) 2019 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef INCLUDE_PERFETTO_BASE_FLAT_SET_H_ +#define INCLUDE_PERFETTO_BASE_FLAT_SET_H_ + +#include +#include + +// A vector-based set::set-like container. +// It's more cache friendly than std::*set and performs for cases where: +// 1. A high number of dupes is expected (e.g. pid tracking in ftrace). +// 2. The working set is small (hundreds of elements). + +// Performance characteristics (for uniformly random insertion order): +// - For smaller insertions (up to ~500), it outperforms both std::set and +// std::unordered_set by ~3x. +// - Up until 4k insertions, it is always faster than std::set. +// - unordered_set is faster with more than 2k insertions. +// - unordered_set, however, it's less memory efficient and has more caveats +// (see chromium's base/containers/README.md). +// +// See flat_set_benchmark.cc and the charts in go/perfetto-int-set-benchmark. + +namespace perfetto { +namespace base { + +template +class FlatSet { + public: + using value_type = T; + using const_pointer = const T*; + using iterator = typename std::vector::iterator; + using const_iterator = typename std::vector::const_iterator; + + FlatSet() = default; + + // Mainly for tests. Deliberately not marked as "explicit". + FlatSet(std::initializer_list initial) : entries_(initial) { + std::sort(entries_.begin(), entries_.end()); + entries_.erase(std::unique(entries_.begin(), entries_.end()), + entries_.end()); + } + + const_iterator find(T value) const { + auto entries_end = entries_.end(); + auto it = std::lower_bound(entries_.begin(), entries_end, value); + return (it != entries_end && *it == value) ? it : entries_end; + } + + size_t count(T value) const { return find(value) == entries_.end() ? 0 : 1; } + + std::pair insert(T value) { + auto entries_end = entries_.end(); + auto it = std::lower_bound(entries_.begin(), entries_end, value); + if (it != entries_end && *it == value) + return std::make_pair(it, false); + // If the value is not found |it| is either end() or the next item strictly + // greater than |value|. In both cases we want to insert just before that. + it = entries_.insert(it, std::move(value)); + return std::make_pair(it, true); + } + + size_t erase(T value) { + auto it = find(value); + if (it == entries_.end()) + return 0; + entries_.erase(it); + return 1; + } + + void clear() { entries_.clear(); } + + bool empty() const { return entries_.empty(); } + void reserve(size_t n) { entries_.reserve(n); } + size_t size() const { return entries_.size(); } + const_iterator begin() const { return entries_.begin(); } + const_iterator end() const { return entries_.end(); } + + private: + std::vector entries_; +}; + +} // namespace base +} // namespace perfetto + +#endif // INCLUDE_PERFETTO_BASE_FLAT_SET_H_ diff --git a/src/libtracing/perfetto/base/logging.h b/src/libtracing/perfetto/base/logging.h new file mode 100644 index 000000000..80420826f --- /dev/null +++ b/src/libtracing/perfetto/base/logging.h @@ -0,0 +1,248 @@ +/* + * Copyright (C) 2017 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef INCLUDE_PERFETTO_BASE_LOGGING_H_ +#define INCLUDE_PERFETTO_BASE_LOGGING_H_ + +#include +#include // For strerror. + +#include "perfetto/base/build_config.h" +#include "perfetto/base/compiler.h" +#include "perfetto/base/export.h" + +#if defined(__GNUC__) || defined(__clang__) +// Ignore GCC warning about a missing argument for a variadic macro parameter. +#pragma GCC system_header +#endif + +#if PERFETTO_BUILDFLAG(PERFETTO_FORCE_DCHECK_ON) +#define PERFETTO_DCHECK_IS_ON() 1 +#elif PERFETTO_BUILDFLAG(PERFETTO_FORCE_DCHECK_OFF) +#define PERFETTO_DCHECK_IS_ON() 0 +#elif defined(DCHECK_ALWAYS_ON) || \ + (!defined(NDEBUG) && (PERFETTO_BUILDFLAG(PERFETTO_STANDALONE_BUILD) || \ + PERFETTO_BUILDFLAG(PERFETTO_CHROMIUM_BUILD) || \ + PERFETTO_BUILDFLAG(PERFETTO_ANDROID_BUILD))) +#define PERFETTO_DCHECK_IS_ON() 1 +#else +#define PERFETTO_DCHECK_IS_ON() 0 +#endif + +#if PERFETTO_BUILDFLAG(PERFETTO_FORCE_DLOG_ON) +#define PERFETTO_DLOG_IS_ON() 1 +#elif PERFETTO_BUILDFLAG(PERFETTO_FORCE_DLOG_OFF) +#define PERFETTO_DLOG_IS_ON() 0 +#else +#define PERFETTO_DLOG_IS_ON() PERFETTO_DCHECK_IS_ON() +#endif + +#if defined(PERFETTO_ANDROID_ASYNC_SAFE_LOG) +#if !PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID) || \ + !PERFETTO_BUILDFLAG(PERFETTO_ANDROID_BUILD) +#error "Async-safe logging is limited to Android tree builds" +#endif +// For binaries which need a very lightweight logging implementation. +// Note that this header is incompatible with android/log.h. +#include +#elif PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID) +// Normal android logging. +#include +#endif + +// Enable the "Print the most recent PERFETTO_LOG(s) before crashing" feature +// on Android in-tree builds and on standalone builds (mainly for testing). +// This is deliberately no PERFETTO_OS_ANDROID because we don't want this +// feature when perfetto is embedded in other Android projects (e.g. SDK). +// TODO(b/203795298): TFLite is using the client library in blaze builds and is +// targeting API 19. For now disable the feature based on API level. +#if defined(PERFETTO_ANDROID_ASYNC_SAFE_LOG) +#define PERFETTO_ENABLE_LOG_RING_BUFFER() 0 +#elif PERFETTO_BUILDFLAG(PERFETTO_ANDROID_BUILD) +#define PERFETTO_ENABLE_LOG_RING_BUFFER() 1 +#elif PERFETTO_BUILDFLAG(PERFETTO_STANDALONE_BUILD) && \ + (!PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID) || \ + (defined(__ANDROID_API__) && __ANDROID_API__ >= 21)) +#define PERFETTO_ENABLE_LOG_RING_BUFFER() 0 +#else +#define PERFETTO_ENABLE_LOG_RING_BUFFER() 0 +#endif + +namespace perfetto { +namespace base { + +// Constexpr functions to extract basename(__FILE__), e.g.: ../foo/f.c -> f.c . +constexpr const char* StrEnd(const char* s) { + return *s ? StrEnd(s + 1) : s; +} + +constexpr const char* BasenameRecursive(const char* s, + const char* begin, + const char* end) { + return (*s == '/' && s < end) + ? (s + 1) + : ((s > begin) ? BasenameRecursive(s - 1, begin, end) : s); +} + +constexpr const char* Basename(const char* str) { + return BasenameRecursive(StrEnd(str), str, StrEnd(str)); +} + +enum LogLev { kLogDebug = 0, kLogInfo, kLogImportant, kLogError }; + +struct LogMessageCallbackArgs { + LogLev level; + int line; + const char* filename; + const char* message; +}; + +using LogMessageCallback = void (*)(LogMessageCallbackArgs); + +// This is not thread safe and must be called before using tracing from other +// threads. +PERFETTO_EXPORT_COMPONENT void SetLogMessageCallback( + LogMessageCallback callback); + +PERFETTO_EXPORT_COMPONENT void LogMessage(LogLev, + const char* fname, + int line, + const char* fmt, + ...) PERFETTO_PRINTF_FORMAT(4, 5); + +// This is defined in debug_crash_stack_trace.cc, but that is only linked in +// standalone && debug builds, see enable_perfetto_stderr_crash_dump in +// perfetto.gni. +PERFETTO_EXPORT_COMPONENT void EnableStacktraceOnCrashForDebug(); + +#if PERFETTO_ENABLE_LOG_RING_BUFFER() +// Gets a snapshot of the logs from the internal log ring buffer and: +// - On Android in-tree builds: Passes that to android_set_abort_message(). +// That will attach the logs to the crash report. +// - On standalone builds (all otther OSes) prints that on stderr. +// This function must called only once, right before inducing a crash (This is +// because android_set_abort_message() can only be called once). +PERFETTO_EXPORT_COMPONENT void MaybeSerializeLastLogsForCrashReporting(); +#else +inline void MaybeSerializeLastLogsForCrashReporting() {} +#endif + +#if defined(PERFETTO_ANDROID_ASYNC_SAFE_LOG) +#define PERFETTO_XLOG(level, fmt, ...) \ + do { \ + async_safe_format_log((ANDROID_LOG_DEBUG + level), "perfetto", \ + "%s:%d " fmt, ::perfetto::base::Basename(__FILE__), \ + __LINE__, ##__VA_ARGS__); \ + } while (0) +#elif defined(PERFETTO_DISABLE_LOG) +#define PERFETTO_XLOG(level, fmt, ...) ::perfetto::base::ignore_result(level, \ + fmt, ##__VA_ARGS__) +#else +#define PERFETTO_XLOG(level, fmt, ...) \ + ::perfetto::base::LogMessage(level, ::perfetto::base::Basename(__FILE__), \ + __LINE__, fmt, ##__VA_ARGS__) +#endif + +#if defined(_MSC_VER) +#define PERFETTO_IMMEDIATE_CRASH() \ + do { \ + ::perfetto::base::MaybeSerializeLastLogsForCrashReporting(); \ + __debugbreak(); \ + __assume(0); \ + } while (0) +#else +#define PERFETTO_IMMEDIATE_CRASH() \ + do { \ + ::perfetto::base::MaybeSerializeLastLogsForCrashReporting(); \ + __builtin_trap(); \ + __builtin_unreachable(); \ + } while (0) +#endif + +#if PERFETTO_BUILDFLAG(PERFETTO_VERBOSE_LOGS) +#define PERFETTO_LOG(fmt, ...) \ + PERFETTO_XLOG(::perfetto::base::kLogInfo, fmt, ##__VA_ARGS__) +#else // PERFETTO_BUILDFLAG(PERFETTO_VERBOSE_LOGS) +#define PERFETTO_LOG(...) ::perfetto::base::ignore_result(__VA_ARGS__) +#endif // PERFETTO_BUILDFLAG(PERFETTO_VERBOSE_LOGS) + +#define PERFETTO_ILOG(fmt, ...) \ + PERFETTO_XLOG(::perfetto::base::kLogImportant, fmt, ##__VA_ARGS__) +#define PERFETTO_ELOG(fmt, ...) \ + PERFETTO_XLOG(::perfetto::base::kLogError, fmt, ##__VA_ARGS__) +#define PERFETTO_FATAL(fmt, ...) \ + do { \ + PERFETTO_PLOG(fmt, ##__VA_ARGS__); \ + PERFETTO_IMMEDIATE_CRASH(); \ + } while (0) + +#if defined(__GNUC__) || defined(__clang__) +#define PERFETTO_PLOG(x, ...) \ + PERFETTO_ELOG(x " (errno: %d, %s)", ##__VA_ARGS__, errno, strerror(errno)) +#else +// MSVC expands __VA_ARGS__ in a different order. Give up, not worth it. +#define PERFETTO_PLOG PERFETTO_ELOG +#endif + +#define PERFETTO_CHECK(x) \ + do { \ + if (PERFETTO_UNLIKELY(!(x))) { \ + PERFETTO_PLOG("%s", "PERFETTO_CHECK(" #x ")"); \ + PERFETTO_IMMEDIATE_CRASH(); \ + } \ + } while (0) + +#if PERFETTO_DLOG_IS_ON() + +#define PERFETTO_DLOG(fmt, ...) \ + PERFETTO_XLOG(::perfetto::base::kLogDebug, fmt, ##__VA_ARGS__) + +#if defined(__GNUC__) || defined(__clang__) +#define PERFETTO_DPLOG(x, ...) \ + PERFETTO_DLOG(x " (errno: %d, %s)", ##__VA_ARGS__, errno, strerror(errno)) +#else +// MSVC expands __VA_ARGS__ in a different order. Give up, not worth it. +#define PERFETTO_DPLOG PERFETTO_DLOG +#endif + +#else // PERFETTO_DLOG_IS_ON() + +#define PERFETTO_DLOG(...) ::perfetto::base::ignore_result(__VA_ARGS__) +#define PERFETTO_DPLOG(...) ::perfetto::base::ignore_result(__VA_ARGS__) + +#endif // PERFETTO_DLOG_IS_ON() + +#if PERFETTO_DCHECK_IS_ON() + +#define PERFETTO_DCHECK(x) PERFETTO_CHECK(x) +#define PERFETTO_DFATAL(...) PERFETTO_FATAL(__VA_ARGS__) +#define PERFETTO_DFATAL_OR_ELOG(...) PERFETTO_DFATAL(__VA_ARGS__) + +#else // PERFETTO_DCHECK_IS_ON() + +#define PERFETTO_DCHECK(x) \ + do { \ + } while (false && (x)) + +#define PERFETTO_DFATAL(...) ::perfetto::base::ignore_result(__VA_ARGS__) +#define PERFETTO_DFATAL_OR_ELOG(...) PERFETTO_ELOG(__VA_ARGS__) + +#endif // PERFETTO_DCHECK_IS_ON() + +} // namespace base +} // namespace perfetto + +#endif // INCLUDE_PERFETTO_BASE_LOGGING_H_ diff --git a/src/libtracing/perfetto/base/platform_handle.h b/src/libtracing/perfetto/base/platform_handle.h new file mode 100644 index 000000000..88f6d5966 --- /dev/null +++ b/src/libtracing/perfetto/base/platform_handle.h @@ -0,0 +1,71 @@ +/* + * Copyright (C) 2020 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef INCLUDE_PERFETTO_BASE_PLATFORM_HANDLE_H_ +#define INCLUDE_PERFETTO_BASE_PLATFORM_HANDLE_H_ + +#include + +#include "perfetto/base/build_config.h" + +namespace perfetto { +namespace base { + +// PlatformHandle should be used only for types that are HANDLE(s) in Windows. +// It should NOT be used to blanket-replace "int fd" in the codebase. +// Windows has two types of "handles", which, in UNIX-land, both map to int: +// 1. File handles returned by the posix-compatibility API like _open(). +// These are just int(s) and should stay such, because all the posix-like API +// in Windows.h take an int, not a HANDLE. +// 2. Handles returned by old-school WINAPI like CreateFile, CreateEvent etc. +// These are proper HANDLE(s). PlatformHandle should be used here. +// +// On Windows, sockets have their own type (SOCKET) which is neither a HANDLE +// nor an int. However Windows SOCKET(s) can have an event HANDLE attached +// to them (which in Perfetto is a PlatformHandle), and that can be used in +// WaitForMultipleObjects, hence in base::TaskRunner.AddFileDescriptorWatch(). +// On POSIX OSes, a SocketHandle is really just an int (a file descriptor). +#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN) +// Windows.h typedefs HANDLE to void*, and SOCKET to uintptr_t. We use their +// types to avoid leaking Windows.h through our headers. +using PlatformHandle = void*; +using SocketHandle = uintptr_t; + +// On Windows both nullptr and 0xffff... (INVALID_HANDLE_VALUE) are invalid. +struct PlatformHandleChecker { + static inline bool IsValid(PlatformHandle h) { + return h && h != reinterpret_cast(-1); + } +}; +#else +using PlatformHandle = int; +using SocketHandle = int; +struct PlatformHandleChecker { + static inline bool IsValid(PlatformHandle h) { return h >= 0; } +}; +#endif + +// The definition of this lives in base/file_utils.cc (to avoid creating an +// extra build edge for a one liner). This is really an alias for close() (UNIX) +// CloseHandle() (Windows). THe indirection layer is just to avoid leaking +// system headers like Windows.h through perfetto headers. +// Thre return value is always UNIX-style: 0 on success, -1 on failure. +int ClosePlatformHandle(PlatformHandle); + +} // namespace base +} // namespace perfetto + +#endif // INCLUDE_PERFETTO_BASE_PLATFORM_HANDLE_H_ diff --git a/src/libtracing/perfetto/base/proc_utils.h b/src/libtracing/perfetto/base/proc_utils.h new file mode 100644 index 000000000..cb8e13a58 --- /dev/null +++ b/src/libtracing/perfetto/base/proc_utils.h @@ -0,0 +1,59 @@ +/* + * Copyright (C) 2019 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef INCLUDE_PERFETTO_BASE_PROC_UTILS_H_ +#define INCLUDE_PERFETTO_BASE_PROC_UTILS_H_ + +#include + +#include "perfetto/base/build_config.h" + +#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN) +extern "C" { +// Prototype extracted from the Windows SDK to avoid including windows.h. +__declspec(dllimport) unsigned long __stdcall GetCurrentProcessId(); +} +#elif PERFETTO_BUILDFLAG(PERFETTO_OS_FUCHSIA) +#include +#include +#else +#include +#endif + +namespace perfetto { +namespace base { + +#if PERFETTO_BUILDFLAG(PERFETTO_OS_FUCHSIA) +using PlatformProcessId = zx_handle_t; +inline PlatformProcessId GetProcessId() { + return zx_process_self(); +} +#elif PERFETTO_BUILDFLAG(PERFETTO_OS_WIN) +using PlatformProcessId = uint64_t; +inline PlatformProcessId GetProcessId() { + return static_cast(GetCurrentProcessId()); +} +#else +using PlatformProcessId = pid_t; +inline PlatformProcessId GetProcessId() { + return getpid(); +} +#endif + +} // namespace base +} // namespace perfetto + +#endif // INCLUDE_PERFETTO_BASE_PROC_UTILS_H_ diff --git a/src/libtracing/perfetto/base/status.h b/src/libtracing/perfetto/base/status.h new file mode 100644 index 000000000..506bb6e61 --- /dev/null +++ b/src/libtracing/perfetto/base/status.h @@ -0,0 +1,117 @@ +/* + * Copyright (C) 2019 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef INCLUDE_PERFETTO_BASE_STATUS_H_ +#define INCLUDE_PERFETTO_BASE_STATUS_H_ + +#include +#include +#include +#include + +#include "perfetto/base/compiler.h" +#include "perfetto/base/export.h" +#include "perfetto/base/logging.h" + +namespace perfetto { +namespace base { + +// Represents either the success or the failure message of a function. +// This can used as the return type of functions which would usually return an +// bool for success or int for errno but also wants to add some string context +// (ususally for logging). +// +// Similar to absl::Status, an optional "payload" can also be included with more +// context about the error. This allows passing additional metadata about the +// error (e.g. location of errors, potential mitigations etc). +class PERFETTO_EXPORT_COMPONENT Status { + public: + Status() : ok_(true) {} + explicit Status(std::string msg) : ok_(false), message_(std::move(msg)) { + PERFETTO_CHECK(!message_.empty()); + } + + // Copy operations. + Status(const Status&) = default; + Status& operator=(const Status&) = default; + + // Move operations. The moved-from state is valid but unspecified. + Status(Status&&) noexcept = default; + Status& operator=(Status&&) = default; + + bool ok() const { return ok_; } + + // When ok() is false this returns the error message. Returns the empty string + // otherwise. + const std::string& message() const { return message_; } + const char* c_message() const { return message_.c_str(); } + + ////////////////////////////////////////////////////////////////////////////// + // Payload Management APIs + ////////////////////////////////////////////////////////////////////////////// + + // Payloads can be attached to error statuses to provide additional context. + // + // Payloads are (key, value) pairs, where the key is a string acting as a + // unique "type URL" and the value is an opaque string. The "type URL" should + // be unique, follow the format of a URL and, ideally, documentation on how to + // interpret its associated data should be available. + // + // To attach a payload to a status object, call `Status::SetPayload()`. + // Similarly, to extract the payload from a status, call + // `Status::GetPayload()`. + // + // Note: the payload APIs are only meaningful to call when the status is an + // error. Otherwise, all methods are noops. + + // Gets the payload for the given |type_url| if one exists. + // + // Will always return std::nullopt if |ok()|. + std::optional GetPayload(std::string_view type_url) const; + + // Sets the payload for the given key. The key should + // + // Will always do nothing if |ok()|. + void SetPayload(std::string_view type_url, std::string value); + + // Erases the payload for the given string and returns true if the payload + // existed and was erased. + // + // Will always do nothing if |ok()|. + bool ErasePayload(std::string_view type_url); + + private: + struct Payload { + std::string type_url; + std::string payload; + }; + + bool ok_ = false; + std::string message_; + std::vector payloads_; +}; + +// Returns a status object which represents the Ok status. +inline Status OkStatus() { + return Status(); +} + +PERFETTO_PRINTF_FORMAT(1, 2) Status ErrStatus(const char* format, ...); + +} // namespace base +} // namespace perfetto + +#endif // INCLUDE_PERFETTO_BASE_STATUS_H_ diff --git a/src/libtracing/perfetto/base/task_runner.h b/src/libtracing/perfetto/base/task_runner.h new file mode 100644 index 000000000..653b0e655 --- /dev/null +++ b/src/libtracing/perfetto/base/task_runner.h @@ -0,0 +1,78 @@ +/* + * Copyright (C) 2017 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef INCLUDE_PERFETTO_BASE_TASK_RUNNER_H_ +#define INCLUDE_PERFETTO_BASE_TASK_RUNNER_H_ + +#include + +#include + +#include "perfetto/base/export.h" +#include "perfetto/base/platform_handle.h" + +namespace perfetto { +namespace base { + +// A generic interface to allow the library clients to interleave the execution +// of the tracing internals in their runtime environment. +// The expectation is that all tasks, which are queued either via PostTask() or +// AddFileDescriptorWatch(), are executed on the same sequence (either on the +// same thread, or on a thread pool that gives sequencing guarantees). +// +// Tasks are never executed synchronously inside PostTask and there is a full +// memory barrier between tasks. +// +// All methods of this interface can be called from any thread. +class PERFETTO_EXPORT_COMPONENT TaskRunner { + public: + virtual ~TaskRunner(); + + // Schedule a task for immediate execution. Immediate tasks are always + // executed in the order they are posted. Can be called from any thread. + virtual void PostTask(std::function) = 0; + + // Schedule a task for execution after |delay_ms|. Note that there is no + // strict ordering guarantee between immediate and delayed tasks. Can be + // called from any thread. + virtual void PostDelayedTask(std::function, uint32_t delay_ms) = 0; + + // Schedule a task to run when the handle becomes readable. The same handle + // can only be monitored by one function. Note that this function only needs + // to be implemented on platforms where the built-in ipc framework is used. + // Can be called from any thread. + // TODO(skyostil): Refactor this out of the shared interface. + virtual void AddFileDescriptorWatch(PlatformHandle, + std::function) = 0; + + // Remove a previously scheduled watch for the handle. If this is run on the + // target thread of this TaskRunner, guarantees that the task registered to + // this handle will not be executed after this function call. + // Can be called from any thread. + virtual void RemoveFileDescriptorWatch(PlatformHandle) = 0; + + // Checks if the current thread is the same thread where the TaskRunner's task + // run. This allows single threaded task runners (like the ones used in + // perfetto) to inform the caller that anything posted will run on the same + // thread/sequence. This can allow some callers to skip PostTask and instead + // directly execute the code. Can be called from any thread. + virtual bool RunsTasksOnCurrentThread() const = 0; +}; + +} // namespace base +} // namespace perfetto + +#endif // INCLUDE_PERFETTO_BASE_TASK_RUNNER_H_ diff --git a/src/libtracing/perfetto/base/template_util.h b/src/libtracing/perfetto/base/template_util.h new file mode 100644 index 000000000..4a5359c20 --- /dev/null +++ b/src/libtracing/perfetto/base/template_util.h @@ -0,0 +1,75 @@ +/* + * Copyright (C) 2021 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef INCLUDE_PERFETTO_BASE_TEMPLATE_UTIL_H_ +#define INCLUDE_PERFETTO_BASE_TEMPLATE_UTIL_H_ + +#include +#include + +namespace perfetto { +namespace base { + +// Helper to express preferences in an overload set. If more than one overload +// is available for a given set of parameters the overload with the higher +// priority will be chosen. +template +struct priority_tag : priority_tag {}; + +template <> +struct priority_tag<0> {}; + +// enable_if_t is an implementation of std::enable_if_t from C++14. +// +// Specification: +// https://en.cppreference.com/w/cpp/types/enable_if +template +using enable_if_t = typename std::enable_if::type; + +// decay_t is an implementation of std::decay_t from C++14. +// +// Specification: +// https://en.cppreference.com/w/cpp/types/decay +template +using decay_t = typename std::decay::type; + +// remove_cvref is an implementation of std::remove_cvref from +// C++20. +// +// Specification: +// https://en.cppreference.com/w/cpp/types/remove_cvref + +template +struct remove_cvref { + using type = typename std::remove_cv::type>::type>::type; +}; +template +using remove_cvref_t = typename remove_cvref::type; + +// Check if a given type is a specialization of a given template: +// is_specialization::value. + +template class Template> +struct is_specialization : std::false_type {}; + +template