mainline/platform/sdk/include_gen/external/perfetto/perfetto_protos_perfetto_config_lite_gen_headers/gen/external/perfetto/protos/perfetto/config/trace_config.pb.h

// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: protos/perfetto/config/trace_config.proto

#ifndef GOOGLE_PROTOBUF_INCLUDED_protos_2fperfetto_2fconfig_2ftrace_5fconfig_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_protos_2fperfetto_2fconfig_2ftrace_5fconfig_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3009000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers. Please update
#error your headers.
#endif
#if 3009001 < PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_table_driven.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/inlined_string_field.h>
#include <google/protobuf/metadata_lite.h>
#include <google/protobuf/message_lite.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/generated_enum_util.h>
#include "protos/perfetto/common/builtin_clock.pb.h"
#include "protos/perfetto/config/data_source_config.pb.h"
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_protos_2fperfetto_2fconfig_2ftrace_5fconfig_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_protos_2fperfetto_2fconfig_2ftrace_5fconfig_2eproto {
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxillaryParseTableField aux[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[12]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
};
namespace perfetto {
namespace protos {
class TraceConfig;
class TraceConfigDefaultTypeInternal;
extern TraceConfigDefaultTypeInternal _TraceConfig_default_instance_;
class TraceConfig_BufferConfig;
class TraceConfig_BufferConfigDefaultTypeInternal;
extern TraceConfig_BufferConfigDefaultTypeInternal _TraceConfig_BufferConfig_default_instance_;
class TraceConfig_BuiltinDataSource;
class TraceConfig_BuiltinDataSourceDefaultTypeInternal;
extern TraceConfig_BuiltinDataSourceDefaultTypeInternal _TraceConfig_BuiltinDataSource_default_instance_;
class TraceConfig_DataSource;
class TraceConfig_DataSourceDefaultTypeInternal;
extern TraceConfig_DataSourceDefaultTypeInternal _TraceConfig_DataSource_default_instance_;
class TraceConfig_GuardrailOverrides;
class TraceConfig_GuardrailOverridesDefaultTypeInternal;
extern TraceConfig_GuardrailOverridesDefaultTypeInternal _TraceConfig_GuardrailOverrides_default_instance_;
class TraceConfig_IncidentReportConfig;
class TraceConfig_IncidentReportConfigDefaultTypeInternal;
extern TraceConfig_IncidentReportConfigDefaultTypeInternal _TraceConfig_IncidentReportConfig_default_instance_;
class TraceConfig_IncrementalStateConfig;
class TraceConfig_IncrementalStateConfigDefaultTypeInternal;
extern TraceConfig_IncrementalStateConfigDefaultTypeInternal _TraceConfig_IncrementalStateConfig_default_instance_;
class TraceConfig_ProducerConfig;
class TraceConfig_ProducerConfigDefaultTypeInternal;
extern TraceConfig_ProducerConfigDefaultTypeInternal _TraceConfig_ProducerConfig_default_instance_;
class TraceConfig_StatsdMetadata;
class TraceConfig_StatsdMetadataDefaultTypeInternal;
extern TraceConfig_StatsdMetadataDefaultTypeInternal _TraceConfig_StatsdMetadata_default_instance_;
class TraceConfig_TraceFilter;
class TraceConfig_TraceFilterDefaultTypeInternal;
extern TraceConfig_TraceFilterDefaultTypeInternal _TraceConfig_TraceFilter_default_instance_;
class TraceConfig_TriggerConfig;
class TraceConfig_TriggerConfigDefaultTypeInternal;
extern TraceConfig_TriggerConfigDefaultTypeInternal _TraceConfig_TriggerConfig_default_instance_;
class TraceConfig_TriggerConfig_Trigger;
class TraceConfig_TriggerConfig_TriggerDefaultTypeInternal;
extern TraceConfig_TriggerConfig_TriggerDefaultTypeInternal _TraceConfig_TriggerConfig_Trigger_default_instance_;
}  // namespace protos
}  // namespace perfetto
PROTOBUF_NAMESPACE_OPEN
template<> ::perfetto::protos::TraceConfig* Arena::CreateMaybeMessage<::perfetto::protos::TraceConfig>(Arena*);
template<> ::perfetto::protos::TraceConfig_BufferConfig* Arena::CreateMaybeMessage<::perfetto::protos::TraceConfig_BufferConfig>(Arena*);
template<> ::perfetto::protos::TraceConfig_BuiltinDataSource* Arena::CreateMaybeMessage<::perfetto::protos::TraceConfig_BuiltinDataSource>(Arena*);
template<> ::perfetto::protos::TraceConfig_DataSource* Arena::CreateMaybeMessage<::perfetto::protos::TraceConfig_DataSource>(Arena*);
template<> ::perfetto::protos::TraceConfig_GuardrailOverrides* Arena::CreateMaybeMessage<::perfetto::protos::TraceConfig_GuardrailOverrides>(Arena*);
template<> ::perfetto::protos::TraceConfig_IncidentReportConfig* Arena::CreateMaybeMessage<::perfetto::protos::TraceConfig_IncidentReportConfig>(Arena*);
template<> ::perfetto::protos::TraceConfig_IncrementalStateConfig* Arena::CreateMaybeMessage<::perfetto::protos::TraceConfig_IncrementalStateConfig>(Arena*);
template<> ::perfetto::protos::TraceConfig_ProducerConfig* Arena::CreateMaybeMessage<::perfetto::protos::TraceConfig_ProducerConfig>(Arena*);
template<> ::perfetto::protos::TraceConfig_StatsdMetadata* Arena::CreateMaybeMessage<::perfetto::protos::TraceConfig_StatsdMetadata>(Arena*);
template<> ::perfetto::protos::TraceConfig_TraceFilter* Arena::CreateMaybeMessage<::perfetto::protos::TraceConfig_TraceFilter>(Arena*);
template<> ::perfetto::protos::TraceConfig_TriggerConfig* Arena::CreateMaybeMessage<::perfetto::protos::TraceConfig_TriggerConfig>(Arena*);
template<> ::perfetto::protos::TraceConfig_TriggerConfig_Trigger* Arena::CreateMaybeMessage<::perfetto::protos::TraceConfig_TriggerConfig_Trigger>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace perfetto {
namespace protos {

enum TraceConfig_BufferConfig_FillPolicy : int {
  TraceConfig_BufferConfig_FillPolicy_UNSPECIFIED = 0,
  TraceConfig_BufferConfig_FillPolicy_RING_BUFFER = 1,
  TraceConfig_BufferConfig_FillPolicy_DISCARD = 2
};
bool TraceConfig_BufferConfig_FillPolicy_IsValid(int value);
constexpr TraceConfig_BufferConfig_FillPolicy TraceConfig_BufferConfig_FillPolicy_FillPolicy_MIN = TraceConfig_BufferConfig_FillPolicy_UNSPECIFIED;
constexpr TraceConfig_BufferConfig_FillPolicy TraceConfig_BufferConfig_FillPolicy_FillPolicy_MAX = TraceConfig_BufferConfig_FillPolicy_DISCARD;
constexpr int TraceConfig_BufferConfig_FillPolicy_FillPolicy_ARRAYSIZE = TraceConfig_BufferConfig_FillPolicy_FillPolicy_MAX + 1;

const std::string& TraceConfig_BufferConfig_FillPolicy_Name(TraceConfig_BufferConfig_FillPolicy value);
template<typename T>
inline const std::string& TraceConfig_BufferConfig_FillPolicy_Name(T enum_t_value) {
  static_assert(::std::is_same<T, TraceConfig_BufferConfig_FillPolicy>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function TraceConfig_BufferConfig_FillPolicy_Name.");
  return TraceConfig_BufferConfig_FillPolicy_Name(static_cast<TraceConfig_BufferConfig_FillPolicy>(enum_t_value));
}
bool TraceConfig_BufferConfig_FillPolicy_Parse(
    const std::string& name, TraceConfig_BufferConfig_FillPolicy* value);
enum TraceConfig_TriggerConfig_TriggerMode : int {
  TraceConfig_TriggerConfig_TriggerMode_UNSPECIFIED = 0,
  TraceConfig_TriggerConfig_TriggerMode_START_TRACING = 1,
  TraceConfig_TriggerConfig_TriggerMode_STOP_TRACING = 2
};
bool TraceConfig_TriggerConfig_TriggerMode_IsValid(int value);
constexpr TraceConfig_TriggerConfig_TriggerMode TraceConfig_TriggerConfig_TriggerMode_TriggerMode_MIN = TraceConfig_TriggerConfig_TriggerMode_UNSPECIFIED;
constexpr TraceConfig_TriggerConfig_TriggerMode TraceConfig_TriggerConfig_TriggerMode_TriggerMode_MAX = TraceConfig_TriggerConfig_TriggerMode_STOP_TRACING;
constexpr int TraceConfig_TriggerConfig_TriggerMode_TriggerMode_ARRAYSIZE = TraceConfig_TriggerConfig_TriggerMode_TriggerMode_MAX + 1;

const std::string& TraceConfig_TriggerConfig_TriggerMode_Name(TraceConfig_TriggerConfig_TriggerMode value);
template<typename T>
inline const std::string& TraceConfig_TriggerConfig_TriggerMode_Name(T enum_t_value) {
  static_assert(::std::is_same<T, TraceConfig_TriggerConfig_TriggerMode>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function TraceConfig_TriggerConfig_TriggerMode_Name.");
  return TraceConfig_TriggerConfig_TriggerMode_Name(static_cast<TraceConfig_TriggerConfig_TriggerMode>(enum_t_value));
}
bool TraceConfig_TriggerConfig_TriggerMode_Parse(
    const std::string& name, TraceConfig_TriggerConfig_TriggerMode* value);
enum TraceConfig_LockdownModeOperation : int {
  TraceConfig_LockdownModeOperation_LOCKDOWN_UNCHANGED = 0,
  TraceConfig_LockdownModeOperation_LOCKDOWN_CLEAR = 1,
  TraceConfig_LockdownModeOperation_LOCKDOWN_SET = 2
};
bool TraceConfig_LockdownModeOperation_IsValid(int value);
constexpr TraceConfig_LockdownModeOperation TraceConfig_LockdownModeOperation_LockdownModeOperation_MIN = TraceConfig_LockdownModeOperation_LOCKDOWN_UNCHANGED;
constexpr TraceConfig_LockdownModeOperation TraceConfig_LockdownModeOperation_LockdownModeOperation_MAX = TraceConfig_LockdownModeOperation_LOCKDOWN_SET;
constexpr int TraceConfig_LockdownModeOperation_LockdownModeOperation_ARRAYSIZE = TraceConfig_LockdownModeOperation_LockdownModeOperation_MAX + 1;

const std::string& TraceConfig_LockdownModeOperation_Name(TraceConfig_LockdownModeOperation value);
template<typename T>
inline const std::string& TraceConfig_LockdownModeOperation_Name(T enum_t_value) {
  static_assert(::std::is_same<T, TraceConfig_LockdownModeOperation>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function TraceConfig_LockdownModeOperation_Name.");
  return TraceConfig_LockdownModeOperation_Name(static_cast<TraceConfig_LockdownModeOperation>(enum_t_value));
}
bool TraceConfig_LockdownModeOperation_Parse(
    const std::string& name, TraceConfig_LockdownModeOperation* value);
enum TraceConfig_CompressionType : int {
  TraceConfig_CompressionType_COMPRESSION_TYPE_UNSPECIFIED = 0,
  TraceConfig_CompressionType_COMPRESSION_TYPE_DEFLATE = 1
};
bool TraceConfig_CompressionType_IsValid(int value);
constexpr TraceConfig_CompressionType TraceConfig_CompressionType_CompressionType_MIN = TraceConfig_CompressionType_COMPRESSION_TYPE_UNSPECIFIED;
constexpr TraceConfig_CompressionType TraceConfig_CompressionType_CompressionType_MAX = TraceConfig_CompressionType_COMPRESSION_TYPE_DEFLATE;
constexpr int TraceConfig_CompressionType_CompressionType_ARRAYSIZE = TraceConfig_CompressionType_CompressionType_MAX + 1;

const std::string& TraceConfig_CompressionType_Name(TraceConfig_CompressionType value);
template<typename T>
inline const std::string& TraceConfig_CompressionType_Name(T enum_t_value) {
  static_assert(::std::is_same<T, TraceConfig_CompressionType>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function TraceConfig_CompressionType_Name.");
  return TraceConfig_CompressionType_Name(static_cast<TraceConfig_CompressionType>(enum_t_value));
}
bool TraceConfig_CompressionType_Parse(
    const std::string& name, TraceConfig_CompressionType* value);
enum TraceConfig_StatsdLogging : int {
  TraceConfig_StatsdLogging_STATSD_LOGGING_UNSPECIFIED = 0,
  TraceConfig_StatsdLogging_STATSD_LOGGING_ENABLED = 1,
  TraceConfig_StatsdLogging_STATSD_LOGGING_DISABLED = 2
};
bool TraceConfig_StatsdLogging_IsValid(int value);
constexpr TraceConfig_StatsdLogging TraceConfig_StatsdLogging_StatsdLogging_MIN = TraceConfig_StatsdLogging_STATSD_LOGGING_UNSPECIFIED;
constexpr TraceConfig_StatsdLogging TraceConfig_StatsdLogging_StatsdLogging_MAX = TraceConfig_StatsdLogging_STATSD_LOGGING_DISABLED;
constexpr int TraceConfig_StatsdLogging_StatsdLogging_ARRAYSIZE = TraceConfig_StatsdLogging_StatsdLogging_MAX + 1;

const std::string& TraceConfig_StatsdLogging_Name(TraceConfig_StatsdLogging value);
template<typename T>
inline const std::string& TraceConfig_StatsdLogging_Name(T enum_t_value) {
  static_assert(::std::is_same<T, TraceConfig_StatsdLogging>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function TraceConfig_StatsdLogging_Name.");
  return TraceConfig_StatsdLogging_Name(static_cast<TraceConfig_StatsdLogging>(enum_t_value));
}
bool TraceConfig_StatsdLogging_Parse(
    const std::string& name, TraceConfig_StatsdLogging* value);
// ===================================================================

class TraceConfig_BufferConfig :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:perfetto.protos.TraceConfig.BufferConfig) */ {
 public:
  TraceConfig_BufferConfig();
  virtual ~TraceConfig_BufferConfig();

  TraceConfig_BufferConfig(const TraceConfig_BufferConfig& from);
  TraceConfig_BufferConfig(TraceConfig_BufferConfig&& from) noexcept
    : TraceConfig_BufferConfig() {
    *this = ::std::move(from);
  }

  inline TraceConfig_BufferConfig& operator=(const TraceConfig_BufferConfig& from) {
    CopyFrom(from);
    return *this;
  }
  inline TraceConfig_BufferConfig& operator=(TraceConfig_BufferConfig&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const TraceConfig_BufferConfig& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TraceConfig_BufferConfig* internal_default_instance() {
    return reinterpret_cast<const TraceConfig_BufferConfig*>(
               &_TraceConfig_BufferConfig_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  friend void swap(TraceConfig_BufferConfig& a, TraceConfig_BufferConfig& b) {
    a.Swap(&b);
  }
  inline void Swap(TraceConfig_BufferConfig* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline TraceConfig_BufferConfig* New() const final {
    return CreateMaybeMessage<TraceConfig_BufferConfig>(nullptr);
  }

  TraceConfig_BufferConfig* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<TraceConfig_BufferConfig>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
    final;
  void CopyFrom(const TraceConfig_BufferConfig& from);
  void MergeFrom(const TraceConfig_BufferConfig& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(TraceConfig_BufferConfig* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "perfetto.protos.TraceConfig.BufferConfig";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  typedef TraceConfig_BufferConfig_FillPolicy FillPolicy;
  static constexpr FillPolicy UNSPECIFIED =
    TraceConfig_BufferConfig_FillPolicy_UNSPECIFIED;
  static constexpr FillPolicy RING_BUFFER =
    TraceConfig_BufferConfig_FillPolicy_RING_BUFFER;
  static constexpr FillPolicy DISCARD =
    TraceConfig_BufferConfig_FillPolicy_DISCARD;
  static inline bool FillPolicy_IsValid(int value) {
    return TraceConfig_BufferConfig_FillPolicy_IsValid(value);
  }
  static constexpr FillPolicy FillPolicy_MIN =
    TraceConfig_BufferConfig_FillPolicy_FillPolicy_MIN;
  static constexpr FillPolicy FillPolicy_MAX =
    TraceConfig_BufferConfig_FillPolicy_FillPolicy_MAX;
  static constexpr int FillPolicy_ARRAYSIZE =
    TraceConfig_BufferConfig_FillPolicy_FillPolicy_ARRAYSIZE;
  template<typename T>
  static inline const std::string& FillPolicy_Name(T enum_t_value) {
    static_assert(::std::is_same<T, FillPolicy>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function FillPolicy_Name.");
    return TraceConfig_BufferConfig_FillPolicy_Name(enum_t_value);
  }
  static inline bool FillPolicy_Parse(const std::string& name,
      FillPolicy* value) {
    return TraceConfig_BufferConfig_FillPolicy_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  enum : int {
    kSizeKbFieldNumber = 1,
    kFillPolicyFieldNumber = 4,
  };
  // optional uint32 size_kb = 1;
  bool has_size_kb() const;
  void clear_size_kb();
  ::PROTOBUF_NAMESPACE_ID::uint32 size_kb() const;
  void set_size_kb(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // optional .perfetto.protos.TraceConfig.BufferConfig.FillPolicy fill_policy = 4;
  bool has_fill_policy() const;
  void clear_fill_policy();
  ::perfetto::protos::TraceConfig_BufferConfig_FillPolicy fill_policy() const;
  void set_fill_policy(::perfetto::protos::TraceConfig_BufferConfig_FillPolicy value);

  // @@protoc_insertion_point(class_scope:perfetto.protos.TraceConfig.BufferConfig)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::uint32 size_kb_;
  int fill_policy_;
  friend struct ::TableStruct_protos_2fperfetto_2fconfig_2ftrace_5fconfig_2eproto;
};
// -------------------------------------------------------------------

class TraceConfig_DataSource :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:perfetto.protos.TraceConfig.DataSource) */ {
 public:
  TraceConfig_DataSource();
  virtual ~TraceConfig_DataSource();

  TraceConfig_DataSource(const TraceConfig_DataSource& from);
  TraceConfig_DataSource(TraceConfig_DataSource&& from) noexcept
    : TraceConfig_DataSource() {
    *this = ::std::move(from);
  }

  inline TraceConfig_DataSource& operator=(const TraceConfig_DataSource& from) {
    CopyFrom(from);
    return *this;
  }
  inline TraceConfig_DataSource& operator=(TraceConfig_DataSource&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const TraceConfig_DataSource& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TraceConfig_DataSource* internal_default_instance() {
    return reinterpret_cast<const TraceConfig_DataSource*>(
               &_TraceConfig_DataSource_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

  friend void swap(TraceConfig_DataSource& a, TraceConfig_DataSource& b) {
    a.Swap(&b);
  }
  inline void Swap(TraceConfig_DataSource* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline TraceConfig_DataSource* New() const final {
    return CreateMaybeMessage<TraceConfig_DataSource>(nullptr);
  }

  TraceConfig_DataSource* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<TraceConfig_DataSource>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
    final;
  void CopyFrom(const TraceConfig_DataSource& from);
  void MergeFrom(const TraceConfig_DataSource& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(TraceConfig_DataSource* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "perfetto.protos.TraceConfig.DataSource";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kProducerNameFilterFieldNumber = 2,
    kProducerNameRegexFilterFieldNumber = 3,
    kConfigFieldNumber = 1,
  };
  // repeated string producer_name_filter = 2;
  int producer_name_filter_size() const;
  void clear_producer_name_filter();
  const std::string& producer_name_filter(int index) const;
  std::string* mutable_producer_name_filter(int index);
  void set_producer_name_filter(int index, const std::string& value);
  void set_producer_name_filter(int index, std::string&& value);
  void set_producer_name_filter(int index, const char* value);
  void set_producer_name_filter(int index, const char* value, size_t size);
  std::string* add_producer_name_filter();
  void add_producer_name_filter(const std::string& value);
  void add_producer_name_filter(std::string&& value);
  void add_producer_name_filter(const char* value);
  void add_producer_name_filter(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& producer_name_filter() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_producer_name_filter();

  // repeated string producer_name_regex_filter = 3;
  int producer_name_regex_filter_size() const;
  void clear_producer_name_regex_filter();
  const std::string& producer_name_regex_filter(int index) const;
  std::string* mutable_producer_name_regex_filter(int index);
  void set_producer_name_regex_filter(int index, const std::string& value);
  void set_producer_name_regex_filter(int index, std::string&& value);
  void set_producer_name_regex_filter(int index, const char* value);
  void set_producer_name_regex_filter(int index, const char* value, size_t size);
  std::string* add_producer_name_regex_filter();
  void add_producer_name_regex_filter(const std::string& value);
  void add_producer_name_regex_filter(std::string&& value);
  void add_producer_name_regex_filter(const char* value);
  void add_producer_name_regex_filter(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& producer_name_regex_filter() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_producer_name_regex_filter();

  // optional .perfetto.protos.DataSourceConfig config = 1;
  bool has_config() const;
  void clear_config();
  const ::perfetto::protos::DataSourceConfig& config() const;
  ::perfetto::protos::DataSourceConfig* release_config();
  ::perfetto::protos::DataSourceConfig* mutable_config();
  void set_allocated_config(::perfetto::protos::DataSourceConfig* config);

  // @@protoc_insertion_point(class_scope:perfetto.protos.TraceConfig.DataSource)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> producer_name_filter_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> producer_name_regex_filter_;
  ::perfetto::protos::DataSourceConfig* config_;
  friend struct ::TableStruct_protos_2fperfetto_2fconfig_2ftrace_5fconfig_2eproto;
};
// -------------------------------------------------------------------

class TraceConfig_BuiltinDataSource :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:perfetto.protos.TraceConfig.BuiltinDataSource) */ {
 public:
  TraceConfig_BuiltinDataSource();
  virtual ~TraceConfig_BuiltinDataSource();

  TraceConfig_BuiltinDataSource(const TraceConfig_BuiltinDataSource& from);
  TraceConfig_BuiltinDataSource(TraceConfig_BuiltinDataSource&& from) noexcept
    : TraceConfig_BuiltinDataSource() {
    *this = ::std::move(from);
  }

  inline TraceConfig_BuiltinDataSource& operator=(const TraceConfig_BuiltinDataSource& from) {
    CopyFrom(from);
    return *this;
  }
  inline TraceConfig_BuiltinDataSource& operator=(TraceConfig_BuiltinDataSource&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const TraceConfig_BuiltinDataSource& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TraceConfig_BuiltinDataSource* internal_default_instance() {
    return reinterpret_cast<const TraceConfig_BuiltinDataSource*>(
               &_TraceConfig_BuiltinDataSource_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

  friend void swap(TraceConfig_BuiltinDataSource& a, TraceConfig_BuiltinDataSource& b) {
    a.Swap(&b);
  }
  inline void Swap(TraceConfig_BuiltinDataSource* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline TraceConfig_BuiltinDataSource* New() const final {
    return CreateMaybeMessage<TraceConfig_BuiltinDataSource>(nullptr);
  }

  TraceConfig_BuiltinDataSource* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<TraceConfig_BuiltinDataSource>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
    final;
  void CopyFrom(const TraceConfig_BuiltinDataSource& from);
  void MergeFrom(const TraceConfig_BuiltinDataSource& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(TraceConfig_BuiltinDataSource* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "perfetto.protos.TraceConfig.BuiltinDataSource";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kDisableClockSnapshottingFieldNumber = 1,
    kDisableTraceConfigFieldNumber = 2,
    kDisableSystemInfoFieldNumber = 3,
    kDisableServiceEventsFieldNumber = 4,
    kPrimaryTraceClockFieldNumber = 5,
    kSnapshotIntervalMsFieldNumber = 6,
    kPreferSuspendClockForSnapshotFieldNumber = 7,
  };
  // optional bool disable_clock_snapshotting = 1;
  bool has_disable_clock_snapshotting() const;
  void clear_disable_clock_snapshotting();
  bool disable_clock_snapshotting() const;
  void set_disable_clock_snapshotting(bool value);

  // optional bool disable_trace_config = 2;
  bool has_disable_trace_config() const;
  void clear_disable_trace_config();
  bool disable_trace_config() const;
  void set_disable_trace_config(bool value);

  // optional bool disable_system_info = 3;
  bool has_disable_system_info() const;
  void clear_disable_system_info();
  bool disable_system_info() const;
  void set_disable_system_info(bool value);

  // optional bool disable_service_events = 4;
  bool has_disable_service_events() const;
  void clear_disable_service_events();
  bool disable_service_events() const;
  void set_disable_service_events(bool value);

  // optional .perfetto.protos.BuiltinClock primary_trace_clock = 5;
  bool has_primary_trace_clock() const;
  void clear_primary_trace_clock();
  ::perfetto::protos::BuiltinClock primary_trace_clock() const;
  void set_primary_trace_clock(::perfetto::protos::BuiltinClock value);

  // optional uint32 snapshot_interval_ms = 6;
  bool has_snapshot_interval_ms() const;
  void clear_snapshot_interval_ms();
  ::PROTOBUF_NAMESPACE_ID::uint32 snapshot_interval_ms() const;
  void set_snapshot_interval_ms(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // optional bool prefer_suspend_clock_for_snapshot = 7;
  bool has_prefer_suspend_clock_for_snapshot() const;
  void clear_prefer_suspend_clock_for_snapshot();
  bool prefer_suspend_clock_for_snapshot() const;
  void set_prefer_suspend_clock_for_snapshot(bool value);

  // @@protoc_insertion_point(class_scope:perfetto.protos.TraceConfig.BuiltinDataSource)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  bool disable_clock_snapshotting_;
  bool disable_trace_config_;
  bool disable_system_info_;
  bool disable_service_events_;
  int primary_trace_clock_;
  ::PROTOBUF_NAMESPACE_ID::uint32 snapshot_interval_ms_;
  bool prefer_suspend_clock_for_snapshot_;
  friend struct ::TableStruct_protos_2fperfetto_2fconfig_2ftrace_5fconfig_2eproto;
};
// -------------------------------------------------------------------

class TraceConfig_ProducerConfig :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:perfetto.protos.TraceConfig.ProducerConfig) */ {
 public:
  TraceConfig_ProducerConfig();
  virtual ~TraceConfig_ProducerConfig();

  TraceConfig_ProducerConfig(const TraceConfig_ProducerConfig& from);
  TraceConfig_ProducerConfig(TraceConfig_ProducerConfig&& from) noexcept
    : TraceConfig_ProducerConfig() {
    *this = ::std::move(from);
  }

  inline TraceConfig_ProducerConfig& operator=(const TraceConfig_ProducerConfig& from) {
    CopyFrom(from);
    return *this;
  }
  inline TraceConfig_ProducerConfig& operator=(TraceConfig_ProducerConfig&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const TraceConfig_ProducerConfig& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TraceConfig_ProducerConfig* internal_default_instance() {
    return reinterpret_cast<const TraceConfig_ProducerConfig*>(
               &_TraceConfig_ProducerConfig_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

  friend void swap(TraceConfig_ProducerConfig& a, TraceConfig_ProducerConfig& b) {
    a.Swap(&b);
  }
  inline void Swap(TraceConfig_ProducerConfig* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline TraceConfig_ProducerConfig* New() const final {
    return CreateMaybeMessage<TraceConfig_ProducerConfig>(nullptr);
  }

  TraceConfig_ProducerConfig* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<TraceConfig_ProducerConfig>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
    final;
  void CopyFrom(const TraceConfig_ProducerConfig& from);
  void MergeFrom(const TraceConfig_ProducerConfig& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(TraceConfig_ProducerConfig* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "perfetto.protos.TraceConfig.ProducerConfig";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kProducerNameFieldNumber = 1,
    kShmSizeKbFieldNumber = 2,
    kPageSizeKbFieldNumber = 3,
  };
  // optional string producer_name = 1;
  bool has_producer_name() const;
  void clear_producer_name();
  const std::string& producer_name() const;
  void set_producer_name(const std::string& value);
  void set_producer_name(std::string&& value);
  void set_producer_name(const char* value);
  void set_producer_name(const char* value, size_t size);
  std::string* mutable_producer_name();
  std::string* release_producer_name();
  void set_allocated_producer_name(std::string* producer_name);

  // optional uint32 shm_size_kb = 2;
  bool has_shm_size_kb() const;
  void clear_shm_size_kb();
  ::PROTOBUF_NAMESPACE_ID::uint32 shm_size_kb() const;
  void set_shm_size_kb(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // optional uint32 page_size_kb = 3;
  bool has_page_size_kb() const;
  void clear_page_size_kb();
  ::PROTOBUF_NAMESPACE_ID::uint32 page_size_kb() const;
  void set_page_size_kb(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // @@protoc_insertion_point(class_scope:perfetto.protos.TraceConfig.ProducerConfig)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr producer_name_;
  ::PROTOBUF_NAMESPACE_ID::uint32 shm_size_kb_;
  ::PROTOBUF_NAMESPACE_ID::uint32 page_size_kb_;
  friend struct ::TableStruct_protos_2fperfetto_2fconfig_2ftrace_5fconfig_2eproto;
};
// -------------------------------------------------------------------

class TraceConfig_StatsdMetadata :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:perfetto.protos.TraceConfig.StatsdMetadata) */ {
 public:
  TraceConfig_StatsdMetadata();
  virtual ~TraceConfig_StatsdMetadata();

  TraceConfig_StatsdMetadata(const TraceConfig_StatsdMetadata& from);
  TraceConfig_StatsdMetadata(TraceConfig_StatsdMetadata&& from) noexcept
    : TraceConfig_StatsdMetadata() {
    *this = ::std::move(from);
  }

  inline TraceConfig_StatsdMetadata& operator=(const TraceConfig_StatsdMetadata& from) {
    CopyFrom(from);
    return *this;
  }
  inline TraceConfig_StatsdMetadata& operator=(TraceConfig_StatsdMetadata&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const TraceConfig_StatsdMetadata& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TraceConfig_StatsdMetadata* internal_default_instance() {
    return reinterpret_cast<const TraceConfig_StatsdMetadata*>(
               &_TraceConfig_StatsdMetadata_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

  friend void swap(TraceConfig_StatsdMetadata& a, TraceConfig_StatsdMetadata& b) {
    a.Swap(&b);
  }
  inline void Swap(TraceConfig_StatsdMetadata* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline TraceConfig_StatsdMetadata* New() const final {
    return CreateMaybeMessage<TraceConfig_StatsdMetadata>(nullptr);
  }

  TraceConfig_StatsdMetadata* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<TraceConfig_StatsdMetadata>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
    final;
  void CopyFrom(const TraceConfig_StatsdMetadata& from);
  void MergeFrom(const TraceConfig_StatsdMetadata& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(TraceConfig_StatsdMetadata* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "perfetto.protos.TraceConfig.StatsdMetadata";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kTriggeringAlertIdFieldNumber = 1,
    kTriggeringConfigIdFieldNumber = 3,
    kTriggeringSubscriptionIdFieldNumber = 4,
    kTriggeringConfigUidFieldNumber = 2,
  };
  // optional int64 triggering_alert_id = 1;
  bool has_triggering_alert_id() const;
  void clear_triggering_alert_id();
  ::PROTOBUF_NAMESPACE_ID::int64 triggering_alert_id() const;
  void set_triggering_alert_id(::PROTOBUF_NAMESPACE_ID::int64 value);

  // optional int64 triggering_config_id = 3;
  bool has_triggering_config_id() const;
  void clear_triggering_config_id();
  ::PROTOBUF_NAMESPACE_ID::int64 triggering_config_id() const;
  void set_triggering_config_id(::PROTOBUF_NAMESPACE_ID::int64 value);

  // optional int64 triggering_subscription_id = 4;
  bool has_triggering_subscription_id() const;
  void clear_triggering_subscription_id();
  ::PROTOBUF_NAMESPACE_ID::int64 triggering_subscription_id() const;
  void set_triggering_subscription_id(::PROTOBUF_NAMESPACE_ID::int64 value);

  // optional int32 triggering_config_uid = 2;
  bool has_triggering_config_uid() const;
  void clear_triggering_config_uid();
  ::PROTOBUF_NAMESPACE_ID::int32 triggering_config_uid() const;
  void set_triggering_config_uid(::PROTOBUF_NAMESPACE_ID::int32 value);

  // @@protoc_insertion_point(class_scope:perfetto.protos.TraceConfig.StatsdMetadata)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::int64 triggering_alert_id_;
  ::PROTOBUF_NAMESPACE_ID::int64 triggering_config_id_;
  ::PROTOBUF_NAMESPACE_ID::int64 triggering_subscription_id_;
  ::PROTOBUF_NAMESPACE_ID::int32 triggering_config_uid_;
  friend struct ::TableStruct_protos_2fperfetto_2fconfig_2ftrace_5fconfig_2eproto;
};
// -------------------------------------------------------------------

class TraceConfig_GuardrailOverrides :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:perfetto.protos.TraceConfig.GuardrailOverrides) */ {
 public:
  TraceConfig_GuardrailOverrides();
  virtual ~TraceConfig_GuardrailOverrides();

  TraceConfig_GuardrailOverrides(const TraceConfig_GuardrailOverrides& from);
  TraceConfig_GuardrailOverrides(TraceConfig_GuardrailOverrides&& from) noexcept
    : TraceConfig_GuardrailOverrides() {
    *this = ::std::move(from);
  }

  inline TraceConfig_GuardrailOverrides& operator=(const TraceConfig_GuardrailOverrides& from) {
    CopyFrom(from);
    return *this;
  }
  inline TraceConfig_GuardrailOverrides& operator=(TraceConfig_GuardrailOverrides&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const TraceConfig_GuardrailOverrides& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TraceConfig_GuardrailOverrides* internal_default_instance() {
    return reinterpret_cast<const TraceConfig_GuardrailOverrides*>(
               &_TraceConfig_GuardrailOverrides_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;

  friend void swap(TraceConfig_GuardrailOverrides& a, TraceConfig_GuardrailOverrides& b) {
    a.Swap(&b);
  }
  inline void Swap(TraceConfig_GuardrailOverrides* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline TraceConfig_GuardrailOverrides* New() const final {
    return CreateMaybeMessage<TraceConfig_GuardrailOverrides>(nullptr);
  }

  TraceConfig_GuardrailOverrides* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<TraceConfig_GuardrailOverrides>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
    final;
  void CopyFrom(const TraceConfig_GuardrailOverrides& from);
  void MergeFrom(const TraceConfig_GuardrailOverrides& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(TraceConfig_GuardrailOverrides* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "perfetto.protos.TraceConfig.GuardrailOverrides";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kMaxUploadPerDayBytesFieldNumber = 1,
  };
  // optional uint64 max_upload_per_day_bytes = 1;
  bool has_max_upload_per_day_bytes() const;
  void clear_max_upload_per_day_bytes();
  ::PROTOBUF_NAMESPACE_ID::uint64 max_upload_per_day_bytes() const;
  void set_max_upload_per_day_bytes(::PROTOBUF_NAMESPACE_ID::uint64 value);

  // @@protoc_insertion_point(class_scope:perfetto.protos.TraceConfig.GuardrailOverrides)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::uint64 max_upload_per_day_bytes_;
  friend struct ::TableStruct_protos_2fperfetto_2fconfig_2ftrace_5fconfig_2eproto;
};
// -------------------------------------------------------------------

class TraceConfig_TriggerConfig_Trigger :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:perfetto.protos.TraceConfig.TriggerConfig.Trigger) */ {
 public:
  TraceConfig_TriggerConfig_Trigger();
  virtual ~TraceConfig_TriggerConfig_Trigger();

  TraceConfig_TriggerConfig_Trigger(const TraceConfig_TriggerConfig_Trigger& from);
  TraceConfig_TriggerConfig_Trigger(TraceConfig_TriggerConfig_Trigger&& from) noexcept
    : TraceConfig_TriggerConfig_Trigger() {
    *this = ::std::move(from);
  }

  inline TraceConfig_TriggerConfig_Trigger& operator=(const TraceConfig_TriggerConfig_Trigger& from) {
    CopyFrom(from);
    return *this;
  }
  inline TraceConfig_TriggerConfig_Trigger& operator=(TraceConfig_TriggerConfig_Trigger&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const TraceConfig_TriggerConfig_Trigger& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TraceConfig_TriggerConfig_Trigger* internal_default_instance() {
    return reinterpret_cast<const TraceConfig_TriggerConfig_Trigger*>(
               &_TraceConfig_TriggerConfig_Trigger_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    6;

  friend void swap(TraceConfig_TriggerConfig_Trigger& a, TraceConfig_TriggerConfig_Trigger& b) {
    a.Swap(&b);
  }
  inline void Swap(TraceConfig_TriggerConfig_Trigger* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline TraceConfig_TriggerConfig_Trigger* New() const final {
    return CreateMaybeMessage<TraceConfig_TriggerConfig_Trigger>(nullptr);
  }

  TraceConfig_TriggerConfig_Trigger* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<TraceConfig_TriggerConfig_Trigger>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
    final;
  void CopyFrom(const TraceConfig_TriggerConfig_Trigger& from);
  void MergeFrom(const TraceConfig_TriggerConfig_Trigger& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(TraceConfig_TriggerConfig_Trigger* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "perfetto.protos.TraceConfig.TriggerConfig.Trigger";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kNameFieldNumber = 1,
    kProducerNameRegexFieldNumber = 2,
    kStopDelayMsFieldNumber = 3,
    kMaxPer24HFieldNumber = 4,
    kSkipProbabilityFieldNumber = 5,
  };
  // optional string name = 1;
  bool has_name() const;
  void clear_name();
  const std::string& name() const;
  void set_name(const std::string& value);
  void set_name(std::string&& value);
  void set_name(const char* value);
  void set_name(const char* value, size_t size);
  std::string* mutable_name();
  std::string* release_name();
  void set_allocated_name(std::string* name);

  // optional string producer_name_regex = 2;
  bool has_producer_name_regex() const;
  void clear_producer_name_regex();
  const std::string& producer_name_regex() const;
  void set_producer_name_regex(const std::string& value);
  void set_producer_name_regex(std::string&& value);
  void set_producer_name_regex(const char* value);
  void set_producer_name_regex(const char* value, size_t size);
  std::string* mutable_producer_name_regex();
  std::string* release_producer_name_regex();
  void set_allocated_producer_name_regex(std::string* producer_name_regex);

  // optional uint32 stop_delay_ms = 3;
  bool has_stop_delay_ms() const;
  void clear_stop_delay_ms();
  ::PROTOBUF_NAMESPACE_ID::uint32 stop_delay_ms() const;
  void set_stop_delay_ms(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // optional uint32 max_per_24_h = 4;
  bool has_max_per_24_h() const;
  void clear_max_per_24_h();
  ::PROTOBUF_NAMESPACE_ID::uint32 max_per_24_h() const;
  void set_max_per_24_h(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // optional double skip_probability = 5;
  bool has_skip_probability() const;
  void clear_skip_probability();
  double skip_probability() const;
  void set_skip_probability(double value);

  // @@protoc_insertion_point(class_scope:perfetto.protos.TraceConfig.TriggerConfig.Trigger)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr producer_name_regex_;
  ::PROTOBUF_NAMESPACE_ID::uint32 stop_delay_ms_;
  ::PROTOBUF_NAMESPACE_ID::uint32 max_per_24_h_;
  double skip_probability_;
  friend struct ::TableStruct_protos_2fperfetto_2fconfig_2ftrace_5fconfig_2eproto;
};
// -------------------------------------------------------------------

class TraceConfig_TriggerConfig :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:perfetto.protos.TraceConfig.TriggerConfig) */ {
 public:
  TraceConfig_TriggerConfig();
  virtual ~TraceConfig_TriggerConfig();

  TraceConfig_TriggerConfig(const TraceConfig_TriggerConfig& from);
  TraceConfig_TriggerConfig(TraceConfig_TriggerConfig&& from) noexcept
    : TraceConfig_TriggerConfig() {
    *this = ::std::move(from);
  }

  inline TraceConfig_TriggerConfig& operator=(const TraceConfig_TriggerConfig& from) {
    CopyFrom(from);
    return *this;
  }
  inline TraceConfig_TriggerConfig& operator=(TraceConfig_TriggerConfig&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const TraceConfig_TriggerConfig& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TraceConfig_TriggerConfig* internal_default_instance() {
    return reinterpret_cast<const TraceConfig_TriggerConfig*>(
               &_TraceConfig_TriggerConfig_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    7;

  friend void swap(TraceConfig_TriggerConfig& a, TraceConfig_TriggerConfig& b) {
    a.Swap(&b);
  }
  inline void Swap(TraceConfig_TriggerConfig* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline TraceConfig_TriggerConfig* New() const final {
    return CreateMaybeMessage<TraceConfig_TriggerConfig>(nullptr);
  }

  TraceConfig_TriggerConfig* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<TraceConfig_TriggerConfig>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
    final;
  void CopyFrom(const TraceConfig_TriggerConfig& from);
  void MergeFrom(const TraceConfig_TriggerConfig& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(TraceConfig_TriggerConfig* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "perfetto.protos.TraceConfig.TriggerConfig";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  typedef TraceConfig_TriggerConfig_Trigger Trigger;

  typedef TraceConfig_TriggerConfig_TriggerMode TriggerMode;
  static constexpr TriggerMode UNSPECIFIED =
    TraceConfig_TriggerConfig_TriggerMode_UNSPECIFIED;
  static constexpr TriggerMode START_TRACING =
    TraceConfig_TriggerConfig_TriggerMode_START_TRACING;
  static constexpr TriggerMode STOP_TRACING =
    TraceConfig_TriggerConfig_TriggerMode_STOP_TRACING;
  static inline bool TriggerMode_IsValid(int value) {
    return TraceConfig_TriggerConfig_TriggerMode_IsValid(value);
  }
  static constexpr TriggerMode TriggerMode_MIN =
    TraceConfig_TriggerConfig_TriggerMode_TriggerMode_MIN;
  static constexpr TriggerMode TriggerMode_MAX =
    TraceConfig_TriggerConfig_TriggerMode_TriggerMode_MAX;
  static constexpr int TriggerMode_ARRAYSIZE =
    TraceConfig_TriggerConfig_TriggerMode_TriggerMode_ARRAYSIZE;
  template<typename T>
  static inline const std::string& TriggerMode_Name(T enum_t_value) {
    static_assert(::std::is_same<T, TriggerMode>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function TriggerMode_Name.");
    return TraceConfig_TriggerConfig_TriggerMode_Name(enum_t_value);
  }
  static inline bool TriggerMode_Parse(const std::string& name,
      TriggerMode* value) {
    return TraceConfig_TriggerConfig_TriggerMode_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  enum : int {
    kTriggersFieldNumber = 2,
    kTriggerModeFieldNumber = 1,
    kTriggerTimeoutMsFieldNumber = 3,
  };
  // repeated .perfetto.protos.TraceConfig.TriggerConfig.Trigger triggers = 2;
  int triggers_size() const;
  void clear_triggers();
  ::perfetto::protos::TraceConfig_TriggerConfig_Trigger* mutable_triggers(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::TraceConfig_TriggerConfig_Trigger >*
      mutable_triggers();
  const ::perfetto::protos::TraceConfig_TriggerConfig_Trigger& triggers(int index) const;
  ::perfetto::protos::TraceConfig_TriggerConfig_Trigger* add_triggers();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::TraceConfig_TriggerConfig_Trigger >&
      triggers() const;

  // optional .perfetto.protos.TraceConfig.TriggerConfig.TriggerMode trigger_mode = 1;
  bool has_trigger_mode() const;
  void clear_trigger_mode();
  ::perfetto::protos::TraceConfig_TriggerConfig_TriggerMode trigger_mode() const;
  void set_trigger_mode(::perfetto::protos::TraceConfig_TriggerConfig_TriggerMode value);

  // optional uint32 trigger_timeout_ms = 3;
  bool has_trigger_timeout_ms() const;
  void clear_trigger_timeout_ms();
  ::PROTOBUF_NAMESPACE_ID::uint32 trigger_timeout_ms() const;
  void set_trigger_timeout_ms(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // @@protoc_insertion_point(class_scope:perfetto.protos.TraceConfig.TriggerConfig)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::TraceConfig_TriggerConfig_Trigger > triggers_;
  int trigger_mode_;
  ::PROTOBUF_NAMESPACE_ID::uint32 trigger_timeout_ms_;
  friend struct ::TableStruct_protos_2fperfetto_2fconfig_2ftrace_5fconfig_2eproto;
};
// -------------------------------------------------------------------

class TraceConfig_IncrementalStateConfig :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:perfetto.protos.TraceConfig.IncrementalStateConfig) */ {
 public:
  TraceConfig_IncrementalStateConfig();
  virtual ~TraceConfig_IncrementalStateConfig();

  TraceConfig_IncrementalStateConfig(const TraceConfig_IncrementalStateConfig& from);
  TraceConfig_IncrementalStateConfig(TraceConfig_IncrementalStateConfig&& from) noexcept
    : TraceConfig_IncrementalStateConfig() {
    *this = ::std::move(from);
  }

  inline TraceConfig_IncrementalStateConfig& operator=(const TraceConfig_IncrementalStateConfig& from) {
    CopyFrom(from);
    return *this;
  }
  inline TraceConfig_IncrementalStateConfig& operator=(TraceConfig_IncrementalStateConfig&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const TraceConfig_IncrementalStateConfig& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TraceConfig_IncrementalStateConfig* internal_default_instance() {
    return reinterpret_cast<const TraceConfig_IncrementalStateConfig*>(
               &_TraceConfig_IncrementalStateConfig_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    8;

  friend void swap(TraceConfig_IncrementalStateConfig& a, TraceConfig_IncrementalStateConfig& b) {
    a.Swap(&b);
  }
  inline void Swap(TraceConfig_IncrementalStateConfig* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline TraceConfig_IncrementalStateConfig* New() const final {
    return CreateMaybeMessage<TraceConfig_IncrementalStateConfig>(nullptr);
  }

  TraceConfig_IncrementalStateConfig* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<TraceConfig_IncrementalStateConfig>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
    final;
  void CopyFrom(const TraceConfig_IncrementalStateConfig& from);
  void MergeFrom(const TraceConfig_IncrementalStateConfig& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(TraceConfig_IncrementalStateConfig* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "perfetto.protos.TraceConfig.IncrementalStateConfig";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kClearPeriodMsFieldNumber = 1,
  };
  // optional uint32 clear_period_ms = 1;
  bool has_clear_period_ms() const;
  void clear_clear_period_ms();
  ::PROTOBUF_NAMESPACE_ID::uint32 clear_period_ms() const;
  void set_clear_period_ms(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // @@protoc_insertion_point(class_scope:perfetto.protos.TraceConfig.IncrementalStateConfig)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::uint32 clear_period_ms_;
  friend struct ::TableStruct_protos_2fperfetto_2fconfig_2ftrace_5fconfig_2eproto;
};
// -------------------------------------------------------------------

class TraceConfig_IncidentReportConfig :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:perfetto.protos.TraceConfig.IncidentReportConfig) */ {
 public:
  TraceConfig_IncidentReportConfig();
  virtual ~TraceConfig_IncidentReportConfig();

  TraceConfig_IncidentReportConfig(const TraceConfig_IncidentReportConfig& from);
  TraceConfig_IncidentReportConfig(TraceConfig_IncidentReportConfig&& from) noexcept
    : TraceConfig_IncidentReportConfig() {
    *this = ::std::move(from);
  }

  inline TraceConfig_IncidentReportConfig& operator=(const TraceConfig_IncidentReportConfig& from) {
    CopyFrom(from);
    return *this;
  }
  inline TraceConfig_IncidentReportConfig& operator=(TraceConfig_IncidentReportConfig&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const TraceConfig_IncidentReportConfig& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TraceConfig_IncidentReportConfig* internal_default_instance() {
    return reinterpret_cast<const TraceConfig_IncidentReportConfig*>(
               &_TraceConfig_IncidentReportConfig_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    9;

  friend void swap(TraceConfig_IncidentReportConfig& a, TraceConfig_IncidentReportConfig& b) {
    a.Swap(&b);
  }
  inline void Swap(TraceConfig_IncidentReportConfig* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline TraceConfig_IncidentReportConfig* New() const final {
    return CreateMaybeMessage<TraceConfig_IncidentReportConfig>(nullptr);
  }

  TraceConfig_IncidentReportConfig* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<TraceConfig_IncidentReportConfig>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
    final;
  void CopyFrom(const TraceConfig_IncidentReportConfig& from);
  void MergeFrom(const TraceConfig_IncidentReportConfig& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(TraceConfig_IncidentReportConfig* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "perfetto.protos.TraceConfig.IncidentReportConfig";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kDestinationPackageFieldNumber = 1,
    kDestinationClassFieldNumber = 2,
    kPrivacyLevelFieldNumber = 3,
    kSkipIncidentdFieldNumber = 5,
    kSkipDropboxFieldNumber = 4,
  };
  // optional string destination_package = 1;
  bool has_destination_package() const;
  void clear_destination_package();
  const std::string& destination_package() const;
  void set_destination_package(const std::string& value);
  void set_destination_package(std::string&& value);
  void set_destination_package(const char* value);
  void set_destination_package(const char* value, size_t size);
  std::string* mutable_destination_package();
  std::string* release_destination_package();
  void set_allocated_destination_package(std::string* destination_package);

  // optional string destination_class = 2;
  bool has_destination_class() const;
  void clear_destination_class();
  const std::string& destination_class() const;
  void set_destination_class(const std::string& value);
  void set_destination_class(std::string&& value);
  void set_destination_class(const char* value);
  void set_destination_class(const char* value, size_t size);
  std::string* mutable_destination_class();
  std::string* release_destination_class();
  void set_allocated_destination_class(std::string* destination_class);

  // optional int32 privacy_level = 3;
  bool has_privacy_level() const;
  void clear_privacy_level();
  ::PROTOBUF_NAMESPACE_ID::int32 privacy_level() const;
  void set_privacy_level(::PROTOBUF_NAMESPACE_ID::int32 value);

  // optional bool skip_incidentd = 5;
  bool has_skip_incidentd() const;
  void clear_skip_incidentd();
  bool skip_incidentd() const;
  void set_skip_incidentd(bool value);

  // optional bool skip_dropbox = 4 [deprecated = true];
  PROTOBUF_DEPRECATED bool has_skip_dropbox() const;
  PROTOBUF_DEPRECATED void clear_skip_dropbox();
  PROTOBUF_DEPRECATED bool skip_dropbox() const;
  PROTOBUF_DEPRECATED void set_skip_dropbox(bool value);

  // @@protoc_insertion_point(class_scope:perfetto.protos.TraceConfig.IncidentReportConfig)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr destination_package_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr destination_class_;
  ::PROTOBUF_NAMESPACE_ID::int32 privacy_level_;
  bool skip_incidentd_;
  bool skip_dropbox_;
  friend struct ::TableStruct_protos_2fperfetto_2fconfig_2ftrace_5fconfig_2eproto;
};
// -------------------------------------------------------------------

class TraceConfig_TraceFilter :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:perfetto.protos.TraceConfig.TraceFilter) */ {
 public:
  TraceConfig_TraceFilter();
  virtual ~TraceConfig_TraceFilter();

  TraceConfig_TraceFilter(const TraceConfig_TraceFilter& from);
  TraceConfig_TraceFilter(TraceConfig_TraceFilter&& from) noexcept
    : TraceConfig_TraceFilter() {
    *this = ::std::move(from);
  }

  inline TraceConfig_TraceFilter& operator=(const TraceConfig_TraceFilter& from) {
    CopyFrom(from);
    return *this;
  }
  inline TraceConfig_TraceFilter& operator=(TraceConfig_TraceFilter&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const TraceConfig_TraceFilter& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TraceConfig_TraceFilter* internal_default_instance() {
    return reinterpret_cast<const TraceConfig_TraceFilter*>(
               &_TraceConfig_TraceFilter_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    10;

  friend void swap(TraceConfig_TraceFilter& a, TraceConfig_TraceFilter& b) {
    a.Swap(&b);
  }
  inline void Swap(TraceConfig_TraceFilter* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline TraceConfig_TraceFilter* New() const final {
    return CreateMaybeMessage<TraceConfig_TraceFilter>(nullptr);
  }

  TraceConfig_TraceFilter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<TraceConfig_TraceFilter>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
    final;
  void CopyFrom(const TraceConfig_TraceFilter& from);
  void MergeFrom(const TraceConfig_TraceFilter& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(TraceConfig_TraceFilter* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "perfetto.protos.TraceConfig.TraceFilter";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kBytecodeFieldNumber = 1,
  };
  // optional bytes bytecode = 1;
  bool has_bytecode() const;
  void clear_bytecode();
  const std::string& bytecode() const;
  void set_bytecode(const std::string& value);
  void set_bytecode(std::string&& value);
  void set_bytecode(const char* value);
  void set_bytecode(const void* value, size_t size);
  std::string* mutable_bytecode();
  std::string* release_bytecode();
  void set_allocated_bytecode(std::string* bytecode);

  // @@protoc_insertion_point(class_scope:perfetto.protos.TraceConfig.TraceFilter)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr bytecode_;
  friend struct ::TableStruct_protos_2fperfetto_2fconfig_2ftrace_5fconfig_2eproto;
};
// -------------------------------------------------------------------

class TraceConfig :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:perfetto.protos.TraceConfig) */ {
 public:
  TraceConfig();
  virtual ~TraceConfig();

  TraceConfig(const TraceConfig& from);
  TraceConfig(TraceConfig&& from) noexcept
    : TraceConfig() {
    *this = ::std::move(from);
  }

  inline TraceConfig& operator=(const TraceConfig& from) {
    CopyFrom(from);
    return *this;
  }
  inline TraceConfig& operator=(TraceConfig&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  inline const std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const TraceConfig& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TraceConfig* internal_default_instance() {
    return reinterpret_cast<const TraceConfig*>(
               &_TraceConfig_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    11;

  friend void swap(TraceConfig& a, TraceConfig& b) {
    a.Swap(&b);
  }
  inline void Swap(TraceConfig* other) {
    if (other == this) return;
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline TraceConfig* New() const final {
    return CreateMaybeMessage<TraceConfig>(nullptr);
  }

  TraceConfig* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<TraceConfig>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
    final;
  void CopyFrom(const TraceConfig& from);
  void MergeFrom(const TraceConfig& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  #else
  bool MergePartialFromCodedStream(
      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
  void SerializeWithCachedSizes(
      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(TraceConfig* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "perfetto.protos.TraceConfig";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  typedef TraceConfig_BufferConfig BufferConfig;
  typedef TraceConfig_DataSource DataSource;
  typedef TraceConfig_BuiltinDataSource BuiltinDataSource;
  typedef TraceConfig_ProducerConfig ProducerConfig;
  typedef TraceConfig_StatsdMetadata StatsdMetadata;
  typedef TraceConfig_GuardrailOverrides GuardrailOverrides;
  typedef TraceConfig_TriggerConfig TriggerConfig;
  typedef TraceConfig_IncrementalStateConfig IncrementalStateConfig;
  typedef TraceConfig_IncidentReportConfig IncidentReportConfig;
  typedef TraceConfig_TraceFilter TraceFilter;

  typedef TraceConfig_LockdownModeOperation LockdownModeOperation;
  static constexpr LockdownModeOperation LOCKDOWN_UNCHANGED =
    TraceConfig_LockdownModeOperation_LOCKDOWN_UNCHANGED;
  static constexpr LockdownModeOperation LOCKDOWN_CLEAR =
    TraceConfig_LockdownModeOperation_LOCKDOWN_CLEAR;
  static constexpr LockdownModeOperation LOCKDOWN_SET =
    TraceConfig_LockdownModeOperation_LOCKDOWN_SET;
  static inline bool LockdownModeOperation_IsValid(int value) {
    return TraceConfig_LockdownModeOperation_IsValid(value);
  }
  static constexpr LockdownModeOperation LockdownModeOperation_MIN =
    TraceConfig_LockdownModeOperation_LockdownModeOperation_MIN;
  static constexpr LockdownModeOperation LockdownModeOperation_MAX =
    TraceConfig_LockdownModeOperation_LockdownModeOperation_MAX;
  static constexpr int LockdownModeOperation_ARRAYSIZE =
    TraceConfig_LockdownModeOperation_LockdownModeOperation_ARRAYSIZE;
  template<typename T>
  static inline const std::string& LockdownModeOperation_Name(T enum_t_value) {
    static_assert(::std::is_same<T, LockdownModeOperation>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function LockdownModeOperation_Name.");
    return TraceConfig_LockdownModeOperation_Name(enum_t_value);
  }
  static inline bool LockdownModeOperation_Parse(const std::string& name,
      LockdownModeOperation* value) {
    return TraceConfig_LockdownModeOperation_Parse(name, value);
  }

  typedef TraceConfig_CompressionType CompressionType;
  static constexpr CompressionType COMPRESSION_TYPE_UNSPECIFIED =
    TraceConfig_CompressionType_COMPRESSION_TYPE_UNSPECIFIED;
  static constexpr CompressionType COMPRESSION_TYPE_DEFLATE =
    TraceConfig_CompressionType_COMPRESSION_TYPE_DEFLATE;
  static inline bool CompressionType_IsValid(int value) {
    return TraceConfig_CompressionType_IsValid(value);
  }
  static constexpr CompressionType CompressionType_MIN =
    TraceConfig_CompressionType_CompressionType_MIN;
  static constexpr CompressionType CompressionType_MAX =
    TraceConfig_CompressionType_CompressionType_MAX;
  static constexpr int CompressionType_ARRAYSIZE =
    TraceConfig_CompressionType_CompressionType_ARRAYSIZE;
  template<typename T>
  static inline const std::string& CompressionType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, CompressionType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function CompressionType_Name.");
    return TraceConfig_CompressionType_Name(enum_t_value);
  }
  static inline bool CompressionType_Parse(const std::string& name,
      CompressionType* value) {
    return TraceConfig_CompressionType_Parse(name, value);
  }

  typedef TraceConfig_StatsdLogging StatsdLogging;
  static constexpr StatsdLogging STATSD_LOGGING_UNSPECIFIED =
    TraceConfig_StatsdLogging_STATSD_LOGGING_UNSPECIFIED;
  static constexpr StatsdLogging STATSD_LOGGING_ENABLED =
    TraceConfig_StatsdLogging_STATSD_LOGGING_ENABLED;
  static constexpr StatsdLogging STATSD_LOGGING_DISABLED =
    TraceConfig_StatsdLogging_STATSD_LOGGING_DISABLED;
  static inline bool StatsdLogging_IsValid(int value) {
    return TraceConfig_StatsdLogging_IsValid(value);
  }
  static constexpr StatsdLogging StatsdLogging_MIN =
    TraceConfig_StatsdLogging_StatsdLogging_MIN;
  static constexpr StatsdLogging StatsdLogging_MAX =
    TraceConfig_StatsdLogging_StatsdLogging_MAX;
  static constexpr int StatsdLogging_ARRAYSIZE =
    TraceConfig_StatsdLogging_StatsdLogging_ARRAYSIZE;
  template<typename T>
  static inline const std::string& StatsdLogging_Name(T enum_t_value) {
    static_assert(::std::is_same<T, StatsdLogging>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function StatsdLogging_Name.");
    return TraceConfig_StatsdLogging_Name(enum_t_value);
  }
  static inline bool StatsdLogging_Parse(const std::string& name,
      StatsdLogging* value) {
    return TraceConfig_StatsdLogging_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  enum : int {
    kBuffersFieldNumber = 1,
    kDataSourcesFieldNumber = 2,
    kProducersFieldNumber = 6,
    kActivateTriggersFieldNumber = 18,
    kUniqueSessionNameFieldNumber = 22,
    kOutputPathFieldNumber = 29,
    kStatsdMetadataFieldNumber = 7,
    kGuardrailOverridesFieldNumber = 11,
    kTriggerConfigFieldNumber = 17,
    kBuiltinDataSourcesFieldNumber = 20,
    kIncrementalStateConfigFieldNumber = 21,
    kIncidentReportConfigFieldNumber = 25,
    kTraceFilterFieldNumber = 33,
    kDurationMsFieldNumber = 3,
    kLockdownModeFieldNumber = 5,
    kFileWritePeriodMsFieldNumber = 9,
    kEnableExtraGuardrailsFieldNumber = 4,
    kWriteIntoFileFieldNumber = 8,
    kDeferredStartFieldNumber = 12,
    kNotifyTraceurFieldNumber = 16,
    kMaxFileSizeBytesFieldNumber = 10,
    kFlushPeriodMsFieldNumber = 13,
    kFlushTimeoutMsFieldNumber = 14,
    kAllowUserBuildTracingFieldNumber = 19,
    kDataSourceStopTimeoutMsFieldNumber = 23,
    kTraceUuidMsbFieldNumber = 27,
    kCompressionTypeFieldNumber = 24,
    kBugreportScoreFieldNumber = 30,
    kTraceUuidLsbFieldNumber = 28,
    kStatsdLoggingFieldNumber = 31,
  };
  // repeated .perfetto.protos.TraceConfig.BufferConfig buffers = 1;
  int buffers_size() const;
  void clear_buffers();
  ::perfetto::protos::TraceConfig_BufferConfig* mutable_buffers(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::TraceConfig_BufferConfig >*
      mutable_buffers();
  const ::perfetto::protos::TraceConfig_BufferConfig& buffers(int index) const;
  ::perfetto::protos::TraceConfig_BufferConfig* add_buffers();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::TraceConfig_BufferConfig >&
      buffers() const;

  // repeated .perfetto.protos.TraceConfig.DataSource data_sources = 2;
  int data_sources_size() const;
  void clear_data_sources();
  ::perfetto::protos::TraceConfig_DataSource* mutable_data_sources(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::TraceConfig_DataSource >*
      mutable_data_sources();
  const ::perfetto::protos::TraceConfig_DataSource& data_sources(int index) const;
  ::perfetto::protos::TraceConfig_DataSource* add_data_sources();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::TraceConfig_DataSource >&
      data_sources() const;

  // repeated .perfetto.protos.TraceConfig.ProducerConfig producers = 6;
  int producers_size() const;
  void clear_producers();
  ::perfetto::protos::TraceConfig_ProducerConfig* mutable_producers(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::TraceConfig_ProducerConfig >*
      mutable_producers();
  const ::perfetto::protos::TraceConfig_ProducerConfig& producers(int index) const;
  ::perfetto::protos::TraceConfig_ProducerConfig* add_producers();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::TraceConfig_ProducerConfig >&
      producers() const;

  // repeated string activate_triggers = 18;
  int activate_triggers_size() const;
  void clear_activate_triggers();
  const std::string& activate_triggers(int index) const;
  std::string* mutable_activate_triggers(int index);
  void set_activate_triggers(int index, const std::string& value);
  void set_activate_triggers(int index, std::string&& value);
  void set_activate_triggers(int index, const char* value);
  void set_activate_triggers(int index, const char* value, size_t size);
  std::string* add_activate_triggers();
  void add_activate_triggers(const std::string& value);
  void add_activate_triggers(std::string&& value);
  void add_activate_triggers(const char* value);
  void add_activate_triggers(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& activate_triggers() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_activate_triggers();

  // optional string unique_session_name = 22;
  bool has_unique_session_name() const;
  void clear_unique_session_name();
  const std::string& unique_session_name() const;
  void set_unique_session_name(const std::string& value);
  void set_unique_session_name(std::string&& value);
  void set_unique_session_name(const char* value);
  void set_unique_session_name(const char* value, size_t size);
  std::string* mutable_unique_session_name();
  std::string* release_unique_session_name();
  void set_allocated_unique_session_name(std::string* unique_session_name);

  // optional string output_path = 29;
  bool has_output_path() const;
  void clear_output_path();
  const std::string& output_path() const;
  void set_output_path(const std::string& value);
  void set_output_path(std::string&& value);
  void set_output_path(const char* value);
  void set_output_path(const char* value, size_t size);
  std::string* mutable_output_path();
  std::string* release_output_path();
  void set_allocated_output_path(std::string* output_path);

  // optional .perfetto.protos.TraceConfig.StatsdMetadata statsd_metadata = 7;
  bool has_statsd_metadata() const;
  void clear_statsd_metadata();
  const ::perfetto::protos::TraceConfig_StatsdMetadata& statsd_metadata() const;
  ::perfetto::protos::TraceConfig_StatsdMetadata* release_statsd_metadata();
  ::perfetto::protos::TraceConfig_StatsdMetadata* mutable_statsd_metadata();
  void set_allocated_statsd_metadata(::perfetto::protos::TraceConfig_StatsdMetadata* statsd_metadata);

  // optional .perfetto.protos.TraceConfig.GuardrailOverrides guardrail_overrides = 11;
  bool has_guardrail_overrides() const;
  void clear_guardrail_overrides();
  const ::perfetto::protos::TraceConfig_GuardrailOverrides& guardrail_overrides() const;
  ::perfetto::protos::TraceConfig_GuardrailOverrides* release_guardrail_overrides();
  ::perfetto::protos::TraceConfig_GuardrailOverrides* mutable_guardrail_overrides();
  void set_allocated_guardrail_overrides(::perfetto::protos::TraceConfig_GuardrailOverrides* guardrail_overrides);

  // optional .perfetto.protos.TraceConfig.TriggerConfig trigger_config = 17;
  bool has_trigger_config() const;
  void clear_trigger_config();
  const ::perfetto::protos::TraceConfig_TriggerConfig& trigger_config() const;
  ::perfetto::protos::TraceConfig_TriggerConfig* release_trigger_config();
  ::perfetto::protos::TraceConfig_TriggerConfig* mutable_trigger_config();
  void set_allocated_trigger_config(::perfetto::protos::TraceConfig_TriggerConfig* trigger_config);

  // optional .perfetto.protos.TraceConfig.BuiltinDataSource builtin_data_sources = 20;
  bool has_builtin_data_sources() const;
  void clear_builtin_data_sources();
  const ::perfetto::protos::TraceConfig_BuiltinDataSource& builtin_data_sources() const;
  ::perfetto::protos::TraceConfig_BuiltinDataSource* release_builtin_data_sources();
  ::perfetto::protos::TraceConfig_BuiltinDataSource* mutable_builtin_data_sources();
  void set_allocated_builtin_data_sources(::perfetto::protos::TraceConfig_BuiltinDataSource* builtin_data_sources);

  // optional .perfetto.protos.TraceConfig.IncrementalStateConfig incremental_state_config = 21;
  bool has_incremental_state_config() const;
  void clear_incremental_state_config();
  const ::perfetto::protos::TraceConfig_IncrementalStateConfig& incremental_state_config() const;
  ::perfetto::protos::TraceConfig_IncrementalStateConfig* release_incremental_state_config();
  ::perfetto::protos::TraceConfig_IncrementalStateConfig* mutable_incremental_state_config();
  void set_allocated_incremental_state_config(::perfetto::protos::TraceConfig_IncrementalStateConfig* incremental_state_config);

  // optional .perfetto.protos.TraceConfig.IncidentReportConfig incident_report_config = 25;
  bool has_incident_report_config() const;
  void clear_incident_report_config();
  const ::perfetto::protos::TraceConfig_IncidentReportConfig& incident_report_config() const;
  ::perfetto::protos::TraceConfig_IncidentReportConfig* release_incident_report_config();
  ::perfetto::protos::TraceConfig_IncidentReportConfig* mutable_incident_report_config();
  void set_allocated_incident_report_config(::perfetto::protos::TraceConfig_IncidentReportConfig* incident_report_config);

  // optional .perfetto.protos.TraceConfig.TraceFilter trace_filter = 33;
  bool has_trace_filter() const;
  void clear_trace_filter();
  const ::perfetto::protos::TraceConfig_TraceFilter& trace_filter() const;
  ::perfetto::protos::TraceConfig_TraceFilter* release_trace_filter();
  ::perfetto::protos::TraceConfig_TraceFilter* mutable_trace_filter();
  void set_allocated_trace_filter(::perfetto::protos::TraceConfig_TraceFilter* trace_filter);

  // optional uint32 duration_ms = 3;
  bool has_duration_ms() const;
  void clear_duration_ms();
  ::PROTOBUF_NAMESPACE_ID::uint32 duration_ms() const;
  void set_duration_ms(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // optional .perfetto.protos.TraceConfig.LockdownModeOperation lockdown_mode = 5;
  bool has_lockdown_mode() const;
  void clear_lockdown_mode();
  ::perfetto::protos::TraceConfig_LockdownModeOperation lockdown_mode() const;
  void set_lockdown_mode(::perfetto::protos::TraceConfig_LockdownModeOperation value);

  // optional uint32 file_write_period_ms = 9;
  bool has_file_write_period_ms() const;
  void clear_file_write_period_ms();
  ::PROTOBUF_NAMESPACE_ID::uint32 file_write_period_ms() const;
  void set_file_write_period_ms(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // optional bool enable_extra_guardrails = 4;
  bool has_enable_extra_guardrails() const;
  void clear_enable_extra_guardrails();
  bool enable_extra_guardrails() const;
  void set_enable_extra_guardrails(bool value);

  // optional bool write_into_file = 8;
  bool has_write_into_file() const;
  void clear_write_into_file();
  bool write_into_file() const;
  void set_write_into_file(bool value);

  // optional bool deferred_start = 12;
  bool has_deferred_start() const;
  void clear_deferred_start();
  bool deferred_start() const;
  void set_deferred_start(bool value);

  // optional bool notify_traceur = 16;
  bool has_notify_traceur() const;
  void clear_notify_traceur();
  bool notify_traceur() const;
  void set_notify_traceur(bool value);

  // optional uint64 max_file_size_bytes = 10;
  bool has_max_file_size_bytes() const;
  void clear_max_file_size_bytes();
  ::PROTOBUF_NAMESPACE_ID::uint64 max_file_size_bytes() const;
  void set_max_file_size_bytes(::PROTOBUF_NAMESPACE_ID::uint64 value);

  // optional uint32 flush_period_ms = 13;
  bool has_flush_period_ms() const;
  void clear_flush_period_ms();
  ::PROTOBUF_NAMESPACE_ID::uint32 flush_period_ms() const;
  void set_flush_period_ms(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // optional uint32 flush_timeout_ms = 14;
  bool has_flush_timeout_ms() const;
  void clear_flush_timeout_ms();
  ::PROTOBUF_NAMESPACE_ID::uint32 flush_timeout_ms() const;
  void set_flush_timeout_ms(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // optional bool allow_user_build_tracing = 19;
  bool has_allow_user_build_tracing() const;
  void clear_allow_user_build_tracing();
  bool allow_user_build_tracing() const;
  void set_allow_user_build_tracing(bool value);

  // optional uint32 data_source_stop_timeout_ms = 23;
  bool has_data_source_stop_timeout_ms() const;
  void clear_data_source_stop_timeout_ms();
  ::PROTOBUF_NAMESPACE_ID::uint32 data_source_stop_timeout_ms() const;
  void set_data_source_stop_timeout_ms(::PROTOBUF_NAMESPACE_ID::uint32 value);

  // optional int64 trace_uuid_msb = 27;
  bool has_trace_uuid_msb() const;
  void clear_trace_uuid_msb();
  ::PROTOBUF_NAMESPACE_ID::int64 trace_uuid_msb() const;
  void set_trace_uuid_msb(::PROTOBUF_NAMESPACE_ID::int64 value);

  // optional .perfetto.protos.TraceConfig.CompressionType compression_type = 24;
  bool has_compression_type() const;
  void clear_compression_type();
  ::perfetto::protos::TraceConfig_CompressionType compression_type() const;
  void set_compression_type(::perfetto::protos::TraceConfig_CompressionType value);

  // optional int32 bugreport_score = 30;
  bool has_bugreport_score() const;
  void clear_bugreport_score();
  ::PROTOBUF_NAMESPACE_ID::int32 bugreport_score() const;
  void set_bugreport_score(::PROTOBUF_NAMESPACE_ID::int32 value);

  // optional int64 trace_uuid_lsb = 28;
  bool has_trace_uuid_lsb() const;
  void clear_trace_uuid_lsb();
  ::PROTOBUF_NAMESPACE_ID::int64 trace_uuid_lsb() const;
  void set_trace_uuid_lsb(::PROTOBUF_NAMESPACE_ID::int64 value);

  // optional .perfetto.protos.TraceConfig.StatsdLogging statsd_logging = 31;
  bool has_statsd_logging() const;
  void clear_statsd_logging();
  ::perfetto::protos::TraceConfig_StatsdLogging statsd_logging() const;
  void set_statsd_logging(::perfetto::protos::TraceConfig_StatsdLogging value);

  // @@protoc_insertion_point(class_scope:perfetto.protos.TraceConfig)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::TraceConfig_BufferConfig > buffers_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::TraceConfig_DataSource > data_sources_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::TraceConfig_ProducerConfig > producers_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> activate_triggers_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr unique_session_name_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr output_path_;
  ::perfetto::protos::TraceConfig_StatsdMetadata* statsd_metadata_;
  ::perfetto::protos::TraceConfig_GuardrailOverrides* guardrail_overrides_;
  ::perfetto::protos::TraceConfig_TriggerConfig* trigger_config_;
  ::perfetto::protos::TraceConfig_BuiltinDataSource* builtin_data_sources_;
  ::perfetto::protos::TraceConfig_IncrementalStateConfig* incremental_state_config_;
  ::perfetto::protos::TraceConfig_IncidentReportConfig* incident_report_config_;
  ::perfetto::protos::TraceConfig_TraceFilter* trace_filter_;
  ::PROTOBUF_NAMESPACE_ID::uint32 duration_ms_;
  int lockdown_mode_;
  ::PROTOBUF_NAMESPACE_ID::uint32 file_write_period_ms_;
  bool enable_extra_guardrails_;
  bool write_into_file_;
  bool deferred_start_;
  bool notify_traceur_;
  ::PROTOBUF_NAMESPACE_ID::uint64 max_file_size_bytes_;
  ::PROTOBUF_NAMESPACE_ID::uint32 flush_period_ms_;
  ::PROTOBUF_NAMESPACE_ID::uint32 flush_timeout_ms_;
  bool allow_user_build_tracing_;
  ::PROTOBUF_NAMESPACE_ID::uint32 data_source_stop_timeout_ms_;
  ::PROTOBUF_NAMESPACE_ID::int64 trace_uuid_msb_;
  int compression_type_;
  ::PROTOBUF_NAMESPACE_ID::int32 bugreport_score_;
  ::PROTOBUF_NAMESPACE_ID::int64 trace_uuid_lsb_;
  int statsd_logging_;
  friend struct ::TableStruct_protos_2fperfetto_2fconfig_2ftrace_5fconfig_2eproto;
};
// ===================================================================


// ===================================================================

#ifdef __GNUC__
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// TraceConfig_BufferConfig

// optional uint32 size_kb = 1;
inline bool TraceConfig_BufferConfig::has_size_kb() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TraceConfig_BufferConfig::clear_size_kb() {
  size_kb_ = 0u;
  _has_bits_[0] &= ~0x00000001u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 TraceConfig_BufferConfig::size_kb() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.TraceConfig.BufferConfig.size_kb)
  return size_kb_;
}
inline void TraceConfig_BufferConfig::set_size_kb(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _has_bits_[0] |= 0x00000001u;
  size_kb_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.TraceConfig.BufferConfig.size_kb)
}

// optional .perfetto.protos.TraceConfig.BufferConfig.FillPolicy fill_policy = 4;
inline bool TraceConfig_BufferConfig::has_fill_policy() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void TraceConfig_BufferConfig::clear_fill_policy() {
  fill_policy_ = 0;
  _has_bits_[0] &= ~0x00000002u;
}
inline ::perfetto::protos::TraceConfig_BufferConfig_FillPolicy TraceConfig_BufferConfig::fill_policy() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.TraceConfig.BufferConfig.fill_policy)
  return static_cast< ::perfetto::protos::TraceConfig_BufferConfig_FillPolicy >(fill_policy_);
}
inline void TraceConfig_BufferConfig::set_fill_policy(::perfetto::protos::TraceConfig_BufferConfig_FillPolicy value) {
  assert(::perfetto::protos::TraceConfig_BufferConfig_FillPolicy_IsValid(value));
  _has_bits_[0] |= 0x00000002u;
  fill_policy_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.TraceConfig.BufferConfig.fill_policy)
}

// -------------------------------------------------------------------

// TraceConfig_DataSource

// optional .perfetto.protos.DataSourceConfig config = 1;
inline bool TraceConfig_DataSource::has_config() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline const ::perfetto::protos::DataSourceConfig& TraceConfig_DataSource::config() const {
  const ::perfetto::protos::DataSourceConfig* p = config_;
  // @@protoc_insertion_point(field_get:perfetto.protos.TraceConfig.DataSource.config)
  return p != nullptr ? *p : *reinterpret_cast<const ::perfetto::protos::DataSourceConfig*>(
      &::perfetto::protos::_DataSourceConfig_default_instance_);
}
inline ::perfetto::protos::DataSourceConfig* TraceConfig_DataSource::release_config() {
  // @@protoc_insertion_point(field_release:perfetto.protos.TraceConfig.DataSource.config)
  _has_bits_[0] &= ~0x00000001u;
  ::perfetto::protos::DataSourceConfig* temp = config_;
  config_ = nullptr;
  return temp;
}
inline ::perfetto::protos::DataSourceConfig* TraceConfig_DataSource::mutable_config() {
  _has_bits_[0] |= 0x00000001u;
  if (config_ == nullptr) {
    auto* p = CreateMaybeMessage<::perfetto::protos::DataSourceConfig>(GetArenaNoVirtual());
    config_ = p;
  }
  // @@protoc_insertion_point(field_mutable:perfetto.protos.TraceConfig.DataSource.config)
  return config_;
}
inline void TraceConfig_DataSource::set_allocated_config(::perfetto::protos::DataSourceConfig* config) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(config_);
  }
  if (config) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      config = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, config, submessage_arena);
    }
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  config_ = config;
  // @@protoc_insertion_point(field_set_allocated:perfetto.protos.TraceConfig.DataSource.config)
}

// repeated string producer_name_filter = 2;
inline int TraceConfig_DataSource::producer_name_filter_size() const {
  return producer_name_filter_.size();
}
inline void TraceConfig_DataSource::clear_producer_name_filter() {
  producer_name_filter_.Clear();
}
inline const std::string& TraceConfig_DataSource::producer_name_filter(int index) const {
  // @@protoc_insertion_point(field_get:perfetto.protos.TraceConfig.DataSource.producer_name_filter)
  return producer_name_filter_.Get(index);
}
inline std::string* TraceConfig_DataSource::mutable_producer_name_filter(int index) {
  // @@protoc_insertion_point(field_mutable:perfetto.protos.TraceConfig.DataSource.producer_name_filter)
  return producer_name_filter_.Mutable(index);
}
inline void TraceConfig_DataSource::set_producer_name_filter(int index, const std::string& value) {
  // @@protoc_insertion_point(field_set:perfetto.protos.TraceConfig.DataSource.producer_name_filter)
  producer_name_filter_.Mutable(index)->assign(value);
}
inline void TraceConfig_DataSource::set_producer_name_filter(int index, std::string&& value) {
  // @@protoc_insertion_point(field_set:perfetto.protos.TraceConfig.DataSource.producer_name_filter)
  producer_name_filter_.Mutable(index)->assign(std::move(value));
}
inline void TraceConfig_DataSource::set_producer_name_filter(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  producer_name_filter_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:perfetto.protos.TraceConfig.DataSource.producer_name_filter)
}
inline void TraceConfig_DataSource::set_producer_name_filter(int index, const char* value, size_t size) {
  producer_name_filter_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:perfetto.protos.TraceConfig.DataSource.producer_name_filter)
}
inline std::string* TraceConfig_DataSource::add_producer_name_filter() {
  // @@protoc_insertion_point(field_add_mutable:perfetto.protos.TraceConfig.DataSource.producer_name_filter)
  return producer_name_filter_.Add();
}
inline void TraceConfig_DataSource::add_producer_name_filter(const std::string& value) {
  producer_name_filter_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:perfetto.protos.TraceConfig.DataSource.producer_name_filter)
}
inline void TraceConfig_DataSource::add_producer_name_filter(std::string&& value) {
  producer_name_filter_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:perfetto.protos.TraceConfig.DataSource.producer_name_filter)
}
inline void TraceConfig_DataSource::add_producer_name_filter(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  producer_name_filter_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:perfetto.protos.TraceConfig.DataSource.producer_name_filter)
}
inline void TraceConfig_DataSource::add_producer_name_filter(const char* value, size_t size) {
  producer_name_filter_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:perfetto.protos.TraceConfig.DataSource.producer_name_filter)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
TraceConfig_DataSource::producer_name_filter() const {
  // @@protoc_insertion_point(field_list:perfetto.protos.TraceConfig.DataSource.producer_name_filter)
  return producer_name_filter_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
TraceConfig_DataSource::mutable_producer_name_filter() {
  // @@protoc_insertion_point(field_mutable_list:perfetto.protos.TraceConfig.DataSource.producer_name_filter)
  return &producer_name_filter_;
}

// repeated string producer_name_regex_filter = 3;
inline int TraceConfig_DataSource::producer_name_regex_filter_size() const {
  return producer_name_regex_filter_.size();
}
inline void TraceConfig_DataSource::clear_producer_name_regex_filter() {
  producer_name_regex_filter_.Clear();
}
inline const std::string& TraceConfig_DataSource::producer_name_regex_filter(int index) const {
  // @@protoc_insertion_point(field_get:perfetto.protos.TraceConfig.DataSource.producer_name_regex_filter)
  return producer_name_regex_filter_.Get(index);
}
inline std::string* TraceConfig_DataSource::mutable_producer_name_regex_filter(int index) {
  // @@protoc_insertion_point(field_mutable:perfetto.protos.TraceConfig.DataSource.producer_name_regex_filter)
  return producer_name_regex_filter_.Mutable(index);
}
inline void TraceConfig_DataSource::set_producer_name_regex_filter(int index, const std::string& value) {
  // @@protoc_insertion_point(field_set:perfetto.protos.TraceConfig.DataSource.producer_name_regex_filter)
  producer_name_regex_filter_.Mutable(index)->assign(value);
}
inline void TraceConfig_DataSource::set_producer_name_regex_filter(int index, std::string&& value) {
  // @@protoc_insertion_point(field_set:perfetto.protos.TraceConfig.DataSource.producer_name_regex_filter)
  producer_name_regex_filter_.Mutable(index)->assign(std::move(value));
}
inline void TraceConfig_DataSource::set_producer_name_regex_filter(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  producer_name_regex_filter_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:perfetto.protos.TraceConfig.DataSource.producer_name_regex_filter)
}
inline void TraceConfig_DataSource::set_producer_name_regex_filter(int index, const char* value, size_t size) {
  producer_name_regex_filter_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:perfetto.protos.TraceConfig.DataSource.producer_name_regex_filter)
}
inline std::string* TraceConfig_DataSource::add_producer_name_regex_filter() {
  // @@protoc_insertion_point(field_add_mutable:perfetto.protos.TraceConfig.DataSource.producer_name_regex_filter)
  return producer_name_regex_filter_.Add();
}
inline void TraceConfig_DataSource::add_producer_name_regex_filter(const std::string& value) {
  producer_name_regex_filter_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:perfetto.protos.TraceConfig.DataSource.producer_name_regex_filter)
}
inline void TraceConfig_DataSource::add_producer_name_regex_filter(std::string&& value) {
  producer_name_regex_filter_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:perfetto.protos.TraceConfig.DataSource.producer_name_regex_filter)
}
inline void TraceConfig_DataSource::add_producer_name_regex_filter(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  producer_name_regex_filter_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:perfetto.protos.TraceConfig.DataSource.producer_name_regex_filter)
}
inline void TraceConfig_DataSource::add_producer_name_regex_filter(const char* value, size_t size) {
  producer_name_regex_filter_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:perfetto.protos.TraceConfig.DataSource.producer_name_regex_filter)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
TraceConfig_DataSource::producer_name_regex_filter() const {
  // @@protoc_insertion_point(field_list:perfetto.protos.TraceConfig.DataSource.producer_name_regex_filter)
  return producer_name_regex_filter_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
TraceConfig_DataSource::mutable_producer_name_regex_filter() {
  // @@protoc_insertion_point(field_mutable_list:perfetto.protos.TraceConfig.DataSource.producer_name_regex_filter)
  return &producer_name_regex_filter_;
}

// -------------------------------------------------------------------

// TraceConfig_BuiltinDataSource

// optional bool disable_clock_snapshotting = 1;
inline bool TraceConfig_BuiltinDataSource::has_disable_clock_snapshotting() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TraceConfig_BuiltinDataSource::clear_disable_clock_snapshotting() {
  disable_clock_snapshotting_ = false;
  _has_bits_[0] &= ~0x00000001u;
}
inline bool TraceConfig_BuiltinDataSource::disable_clock_snapshotting() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.TraceConfig.BuiltinDataSource.disable_clock_snapshotting)
  return disable_clock_snapshotting_;
}
inline void TraceConfig_BuiltinDataSource::set_disable_clock_snapshotting(bool value) {
  _has_bits_[0] |= 0x00000001u;
  disable_clock_snapshotting_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.TraceConfig.BuiltinDataSource.disable_clock_snapshotting)
}

// optional bool disable_trace_config = 2;
inline bool TraceConfig_BuiltinDataSource::has_disable_trace_config() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void TraceConfig_BuiltinDataSource::clear_disable_trace_config() {
  disable_trace_config_ = false;
  _has_bits_[0] &= ~0x00000002u;
}
inline bool TraceConfig_BuiltinDataSource::disable_trace_config() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.TraceConfig.BuiltinDataSource.disable_trace_config)
  return disable_trace_config_;
}
inline void TraceConfig_BuiltinDataSource::set_disable_trace_config(bool value) {
  _has_bits_[0] |= 0x00000002u;
  disable_trace_config_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.TraceConfig.BuiltinDataSource.disable_trace_config)
}

// optional bool disable_system_info = 3;
inline bool TraceConfig_BuiltinDataSource::has_disable_system_info() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void TraceConfig_BuiltinDataSource::clear_disable_system_info() {
  disable_system_info_ = false;
  _has_bits_[0] &= ~0x00000004u;
}
inline bool TraceConfig_BuiltinDataSource::disable_system_info() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.TraceConfig.BuiltinDataSource.disable_system_info)
  return disable_system_info_;
}
inline void TraceConfig_BuiltinDataSource::set_disable_system_info(bool value) {
  _has_bits_[0] |= 0x00000004u;
  disable_system_info_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.TraceConfig.BuiltinDataSource.disable_system_info)
}

// optional bool disable_service_events = 4;
inline bool TraceConfig_BuiltinDataSource::has_disable_service_events() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void TraceConfig_BuiltinDataSource::clear_disable_service_events() {
  disable_service_events_ = false;
  _has_bits_[0] &= ~0x00000008u;
}
inline bool TraceConfig_BuiltinDataSource::disable_service_events() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.TraceConfig.BuiltinDataSource.disable_service_events)
  return disable_service_events_;
}
inline void TraceConfig_BuiltinDataSource::set_disable_service_events(bool value) {
  _has_bits_[0] |= 0x00000008u;
  disable_service_events_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.TraceConfig.BuiltinDataSource.disable_service_events)
}

// optional .perfetto.protos.BuiltinClock primary_trace_clock = 5;
inline bool TraceConfig_BuiltinDataSource::has_primary_trace_clock() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void TraceConfig_BuiltinDataSource::clear_primary_trace_clock() {
  primary_trace_clock_ = 0;
  _has_bits_[0] &= ~0x00000010u;
}
inline ::perfetto::protos::BuiltinClock TraceConfig_BuiltinDataSource::primary_trace_clock() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.TraceConfig.BuiltinDataSource.primary_trace_clock)
  return static_cast< ::perfetto::protos::BuiltinClock >(primary_trace_clock_);
}
inline void TraceConfig_BuiltinDataSource::set_primary_trace_clock(::perfetto::protos::BuiltinClock value) {
  assert(::perfetto::protos::BuiltinClock_IsValid(value));
  _has_bits_[0] |= 0x00000010u;
  primary_trace_clock_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.TraceConfig.BuiltinDataSource.primary_trace_clock)
}

// optional uint32 snapshot_interval_ms = 6;
inline bool TraceConfig_BuiltinDataSource::has_snapshot_interval_ms() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void TraceConfig_BuiltinDataSource::clear_snapshot_interval_ms() {
  snapshot_interval_ms_ = 0u;
  _has_bits_[0] &= ~0x00000020u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 TraceConfig_BuiltinDataSource::snapshot_interval_ms() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.TraceConfig.BuiltinDataSource.snapshot_interval_ms)
  return snapshot_interval_ms_;
}
inline void TraceConfig_BuiltinDataSource::set_snapshot_interval_ms(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _has_bits_[0] |= 0x00000020u;
  snapshot_interval_ms_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.TraceConfig.BuiltinDataSource.snapshot_interval_ms)
}

// optional bool prefer_suspend_clock_for_snapshot = 7;
inline bool TraceConfig_BuiltinDataSource::has_prefer_suspend_clock_for_snapshot() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void TraceConfig_BuiltinDataSource::clear_prefer_suspend_clock_for_snapshot() {
  prefer_suspend_clock_for_snapshot_ = false;
  _has_bits_[0] &= ~0x00000040u;
}
inline bool TraceConfig_BuiltinDataSource::prefer_suspend_clock_for_snapshot() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.TraceConfig.BuiltinDataSource.prefer_suspend_clock_for_snapshot)
  return prefer_suspend_clock_for_snapshot_;
}
inline void TraceConfig_BuiltinDataSource::set_prefer_suspend_clock_for_snapshot(bool value) {
  _has_bits_[0] |= 0x00000040u;
  prefer_suspend_clock_for_snapshot_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.TraceConfig.BuiltinDataSource.prefer_suspend_clock_for_snapshot)
}

// -------------------------------------------------------------------

// TraceConfig_ProducerConfig

// optional string producer_name = 1;
inline bool TraceConfig_ProducerConfig::has_producer_name() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TraceConfig_ProducerConfig::clear_producer_name() {
  producer_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& TraceConfig_ProducerConfig::producer_name() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.TraceConfig.ProducerConfig.producer_name)
  return producer_name_.GetNoArena();
}
inline void TraceConfig_ProducerConfig::set_producer_name(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  producer_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:perfetto.protos.TraceConfig.ProducerConfig.producer_name)
}
inline void TraceConfig_ProducerConfig::set_producer_name(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  producer_name_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:perfetto.protos.TraceConfig.ProducerConfig.producer_name)
}
inline void TraceConfig_ProducerConfig::set_producer_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  producer_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:perfetto.protos.TraceConfig.ProducerConfig.producer_name)
}
inline void TraceConfig_ProducerConfig::set_producer_name(const char* value, size_t size) {
  _has_bits_[0] |= 0x00000001u;
  producer_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:perfetto.protos.TraceConfig.ProducerConfig.producer_name)
}
inline std::string* TraceConfig_ProducerConfig::mutable_producer_name() {
  _has_bits_[0] |= 0x00000001u;
  // @@protoc_insertion_point(field_mutable:perfetto.protos.TraceConfig.ProducerConfig.producer_name)
  return producer_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* TraceConfig_ProducerConfig::release_producer_name() {
  // @@protoc_insertion_point(field_release:perfetto.protos.TraceConfig.ProducerConfig.producer_name)
  if (!has_producer_name()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return producer_name_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void TraceConfig_ProducerConfig::set_allocated_producer_name(std::string* producer_name) {
  if (producer_name != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  producer_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), producer_name);
  // @@protoc_insertion_point(field_set_allocated:perfetto.protos.TraceConfig.ProducerConfig.producer_name)
}

// optional uint32 shm_size_kb = 2;
inline bool TraceConfig_ProducerConfig::has_shm_size_kb() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void TraceConfig_ProducerConfig::clear_shm_size_kb() {
  shm_size_kb_ = 0u;
  _has_bits_[0] &= ~0x00000002u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 TraceConfig_ProducerConfig::shm_size_kb() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.TraceConfig.ProducerConfig.shm_size_kb)
  return shm_size_kb_;
}
inline void TraceConfig_ProducerConfig::set_shm_size_kb(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _has_bits_[0] |= 0x00000002u;
  shm_size_kb_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.TraceConfig.ProducerConfig.shm_size_kb)
}

// optional uint32 page_size_kb = 3;
inline bool TraceConfig_ProducerConfig::has_page_size_kb() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void TraceConfig_ProducerConfig::clear_page_size_kb() {
  page_size_kb_ = 0u;
  _has_bits_[0] &= ~0x00000004u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 TraceConfig_ProducerConfig::page_size_kb() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.TraceConfig.ProducerConfig.page_size_kb)
  return page_size_kb_;
}
inline void TraceConfig_ProducerConfig::set_page_size_kb(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _has_bits_[0] |= 0x00000004u;
  page_size_kb_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.TraceConfig.ProducerConfig.page_size_kb)
}

// -------------------------------------------------------------------

// TraceConfig_StatsdMetadata

// optional int64 triggering_alert_id = 1;
inline bool TraceConfig_StatsdMetadata::has_triggering_alert_id() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TraceConfig_StatsdMetadata::clear_triggering_alert_id() {
  triggering_alert_id_ = PROTOBUF_LONGLONG(0);
  _has_bits_[0] &= ~0x00000001u;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 TraceConfig_StatsdMetadata::triggering_alert_id() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.TraceConfig.StatsdMetadata.triggering_alert_id)
  return triggering_alert_id_;
}
inline void TraceConfig_StatsdMetadata::set_triggering_alert_id(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _has_bits_[0] |= 0x00000001u;
  triggering_alert_id_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.TraceConfig.StatsdMetadata.triggering_alert_id)
}

// optional int32 triggering_config_uid = 2;
inline bool TraceConfig_StatsdMetadata::has_triggering_config_uid() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void TraceConfig_StatsdMetadata::clear_triggering_config_uid() {
  triggering_config_uid_ = 0;
  _has_bits_[0] &= ~0x00000008u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 TraceConfig_StatsdMetadata::triggering_config_uid() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.TraceConfig.StatsdMetadata.triggering_config_uid)
  return triggering_config_uid_;
}
inline void TraceConfig_StatsdMetadata::set_triggering_config_uid(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[0] |= 0x00000008u;
  triggering_config_uid_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.TraceConfig.StatsdMetadata.triggering_config_uid)
}

// optional int64 triggering_config_id = 3;
inline bool TraceConfig_StatsdMetadata::has_triggering_config_id() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void TraceConfig_StatsdMetadata::clear_triggering_config_id() {
  triggering_config_id_ = PROTOBUF_LONGLONG(0);
  _has_bits_[0] &= ~0x00000002u;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 TraceConfig_StatsdMetadata::triggering_config_id() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.TraceConfig.StatsdMetadata.triggering_config_id)
  return triggering_config_id_;
}
inline void TraceConfig_StatsdMetadata::set_triggering_config_id(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _has_bits_[0] |= 0x00000002u;
  triggering_config_id_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.TraceConfig.StatsdMetadata.triggering_config_id)
}

// optional int64 triggering_subscription_id = 4;
inline bool TraceConfig_StatsdMetadata::has_triggering_subscription_id() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void TraceConfig_StatsdMetadata::clear_triggering_subscription_id() {
  triggering_subscription_id_ = PROTOBUF_LONGLONG(0);
  _has_bits_[0] &= ~0x00000004u;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 TraceConfig_StatsdMetadata::triggering_subscription_id() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.TraceConfig.StatsdMetadata.triggering_subscription_id)
  return triggering_subscription_id_;
}
inline void TraceConfig_StatsdMetadata::set_triggering_subscription_id(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _has_bits_[0] |= 0x00000004u;
  triggering_subscription_id_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.TraceConfig.StatsdMetadata.triggering_subscription_id)
}

// -------------------------------------------------------------------

// TraceConfig_GuardrailOverrides

// optional uint64 max_upload_per_day_bytes = 1;
inline bool TraceConfig_GuardrailOverrides::has_max_upload_per_day_bytes() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TraceConfig_GuardrailOverrides::clear_max_upload_per_day_bytes() {
  max_upload_per_day_bytes_ = PROTOBUF_ULONGLONG(0);
  _has_bits_[0] &= ~0x00000001u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 TraceConfig_GuardrailOverrides::max_upload_per_day_bytes() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.TraceConfig.GuardrailOverrides.max_upload_per_day_bytes)
  return max_upload_per_day_bytes_;
}
inline void TraceConfig_GuardrailOverrides::set_max_upload_per_day_bytes(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  _has_bits_[0] |= 0x00000001u;
  max_upload_per_day_bytes_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.TraceConfig.GuardrailOverrides.max_upload_per_day_bytes)
}

// -------------------------------------------------------------------

// TraceConfig_TriggerConfig_Trigger

// optional string name = 1;
inline bool TraceConfig_TriggerConfig_Trigger::has_name() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TraceConfig_TriggerConfig_Trigger::clear_name() {
  name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& TraceConfig_TriggerConfig_Trigger::name() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.TraceConfig.TriggerConfig.Trigger.name)
  return name_.GetNoArena();
}
inline void TraceConfig_TriggerConfig_Trigger::set_name(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:perfetto.protos.TraceConfig.TriggerConfig.Trigger.name)
}
inline void TraceConfig_TriggerConfig_Trigger::set_name(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  name_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:perfetto.protos.TraceConfig.TriggerConfig.Trigger.name)
}
inline void TraceConfig_TriggerConfig_Trigger::set_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:perfetto.protos.TraceConfig.TriggerConfig.Trigger.name)
}
inline void TraceConfig_TriggerConfig_Trigger::set_name(const char* value, size_t size) {
  _has_bits_[0] |= 0x00000001u;
  name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:perfetto.protos.TraceConfig.TriggerConfig.Trigger.name)
}
inline std::string* TraceConfig_TriggerConfig_Trigger::mutable_name() {
  _has_bits_[0] |= 0x00000001u;
  // @@protoc_insertion_point(field_mutable:perfetto.protos.TraceConfig.TriggerConfig.Trigger.name)
  return name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* TraceConfig_TriggerConfig_Trigger::release_name() {
  // @@protoc_insertion_point(field_release:perfetto.protos.TraceConfig.TriggerConfig.Trigger.name)
  if (!has_name()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return name_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void TraceConfig_TriggerConfig_Trigger::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name);
  // @@protoc_insertion_point(field_set_allocated:perfetto.protos.TraceConfig.TriggerConfig.Trigger.name)
}

// optional string producer_name_regex = 2;
inline bool TraceConfig_TriggerConfig_Trigger::has_producer_name_regex() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void TraceConfig_TriggerConfig_Trigger::clear_producer_name_regex() {
  producer_name_regex_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  _has_bits_[0] &= ~0x00000002u;
}
inline const std::string& TraceConfig_TriggerConfig_Trigger::producer_name_regex() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.TraceConfig.TriggerConfig.Trigger.producer_name_regex)
  return producer_name_regex_.GetNoArena();
}
inline void TraceConfig_TriggerConfig_Trigger::set_producer_name_regex(const std::string& value) {
  _has_bits_[0] |= 0x00000002u;
  producer_name_regex_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:perfetto.protos.TraceConfig.TriggerConfig.Trigger.producer_name_regex)
}
inline void TraceConfig_TriggerConfig_Trigger::set_producer_name_regex(std::string&& value) {
  _has_bits_[0] |= 0x00000002u;
  producer_name_regex_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:perfetto.protos.TraceConfig.TriggerConfig.Trigger.producer_name_regex)
}
inline void TraceConfig_TriggerConfig_Trigger::set_producer_name_regex(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000002u;
  producer_name_regex_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:perfetto.protos.TraceConfig.TriggerConfig.Trigger.producer_name_regex)
}
inline void TraceConfig_TriggerConfig_Trigger::set_producer_name_regex(const char* value, size_t size) {
  _has_bits_[0] |= 0x00000002u;
  producer_name_regex_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:perfetto.protos.TraceConfig.TriggerConfig.Trigger.producer_name_regex)
}
inline std::string* TraceConfig_TriggerConfig_Trigger::mutable_producer_name_regex() {
  _has_bits_[0] |= 0x00000002u;
  // @@protoc_insertion_point(field_mutable:perfetto.protos.TraceConfig.TriggerConfig.Trigger.producer_name_regex)
  return producer_name_regex_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* TraceConfig_TriggerConfig_Trigger::release_producer_name_regex() {
  // @@protoc_insertion_point(field_release:perfetto.protos.TraceConfig.TriggerConfig.Trigger.producer_name_regex)
  if (!has_producer_name_regex()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000002u;
  return producer_name_regex_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void TraceConfig_TriggerConfig_Trigger::set_allocated_producer_name_regex(std::string* producer_name_regex) {
  if (producer_name_regex != nullptr) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  producer_name_regex_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), producer_name_regex);
  // @@protoc_insertion_point(field_set_allocated:perfetto.protos.TraceConfig.TriggerConfig.Trigger.producer_name_regex)
}

// optional uint32 stop_delay_ms = 3;
inline bool TraceConfig_TriggerConfig_Trigger::has_stop_delay_ms() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void TraceConfig_TriggerConfig_Trigger::clear_stop_delay_ms() {
  stop_delay_ms_ = 0u;
  _has_bits_[0] &= ~0x00000004u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 TraceConfig_TriggerConfig_Trigger::stop_delay_ms() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.TraceConfig.TriggerConfig.Trigger.stop_delay_ms)
  return stop_delay_ms_;
}
inline void TraceConfig_TriggerConfig_Trigger::set_stop_delay_ms(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _has_bits_[0] |= 0x00000004u;
  stop_delay_ms_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.TraceConfig.TriggerConfig.Trigger.stop_delay_ms)
}

// optional uint32 max_per_24_h = 4;
inline bool TraceConfig_TriggerConfig_Trigger::has_max_per_24_h() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void TraceConfig_TriggerConfig_Trigger::clear_max_per_24_h() {
  max_per_24_h_ = 0u;
  _has_bits_[0] &= ~0x00000008u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 TraceConfig_TriggerConfig_Trigger::max_per_24_h() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.TraceConfig.TriggerConfig.Trigger.max_per_24_h)
  return max_per_24_h_;
}
inline void TraceConfig_TriggerConfig_Trigger::set_max_per_24_h(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _has_bits_[0] |= 0x00000008u;
  max_per_24_h_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.TraceConfig.TriggerConfig.Trigger.max_per_24_h)
}

// optional double skip_probability = 5;
inline bool TraceConfig_TriggerConfig_Trigger::has_skip_probability() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void TraceConfig_TriggerConfig_Trigger::clear_skip_probability() {
  skip_probability_ = 0;
  _has_bits_[0] &= ~0x00000010u;
}
inline double TraceConfig_TriggerConfig_Trigger::skip_probability() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.TraceConfig.TriggerConfig.Trigger.skip_probability)
  return skip_probability_;
}
inline void TraceConfig_TriggerConfig_Trigger::set_skip_probability(double value) {
  _has_bits_[0] |= 0x00000010u;
  skip_probability_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.TraceConfig.TriggerConfig.Trigger.skip_probability)
}

// -------------------------------------------------------------------

// TraceConfig_TriggerConfig

// optional .perfetto.protos.TraceConfig.TriggerConfig.TriggerMode trigger_mode = 1;
inline bool TraceConfig_TriggerConfig::has_trigger_mode() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TraceConfig_TriggerConfig::clear_trigger_mode() {
  trigger_mode_ = 0;
  _has_bits_[0] &= ~0x00000001u;
}
inline ::perfetto::protos::TraceConfig_TriggerConfig_TriggerMode TraceConfig_TriggerConfig::trigger_mode() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.TraceConfig.TriggerConfig.trigger_mode)
  return static_cast< ::perfetto::protos::TraceConfig_TriggerConfig_TriggerMode >(trigger_mode_);
}
inline void TraceConfig_TriggerConfig::set_trigger_mode(::perfetto::protos::TraceConfig_TriggerConfig_TriggerMode value) {
  assert(::perfetto::protos::TraceConfig_TriggerConfig_TriggerMode_IsValid(value));
  _has_bits_[0] |= 0x00000001u;
  trigger_mode_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.TraceConfig.TriggerConfig.trigger_mode)
}

// repeated .perfetto.protos.TraceConfig.TriggerConfig.Trigger triggers = 2;
inline int TraceConfig_TriggerConfig::triggers_size() const {
  return triggers_.size();
}
inline void TraceConfig_TriggerConfig::clear_triggers() {
  triggers_.Clear();
}
inline ::perfetto::protos::TraceConfig_TriggerConfig_Trigger* TraceConfig_TriggerConfig::mutable_triggers(int index) {
  // @@protoc_insertion_point(field_mutable:perfetto.protos.TraceConfig.TriggerConfig.triggers)
  return triggers_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::TraceConfig_TriggerConfig_Trigger >*
TraceConfig_TriggerConfig::mutable_triggers() {
  // @@protoc_insertion_point(field_mutable_list:perfetto.protos.TraceConfig.TriggerConfig.triggers)
  return &triggers_;
}
inline const ::perfetto::protos::TraceConfig_TriggerConfig_Trigger& TraceConfig_TriggerConfig::triggers(int index) const {
  // @@protoc_insertion_point(field_get:perfetto.protos.TraceConfig.TriggerConfig.triggers)
  return triggers_.Get(index);
}
inline ::perfetto::protos::TraceConfig_TriggerConfig_Trigger* TraceConfig_TriggerConfig::add_triggers() {
  // @@protoc_insertion_point(field_add:perfetto.protos.TraceConfig.TriggerConfig.triggers)
  return triggers_.Add();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::TraceConfig_TriggerConfig_Trigger >&
TraceConfig_TriggerConfig::triggers() const {
  // @@protoc_insertion_point(field_list:perfetto.protos.TraceConfig.TriggerConfig.triggers)
  return triggers_;
}

// optional uint32 trigger_timeout_ms = 3;
inline bool TraceConfig_TriggerConfig::has_trigger_timeout_ms() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void TraceConfig_TriggerConfig::clear_trigger_timeout_ms() {
  trigger_timeout_ms_ = 0u;
  _has_bits_[0] &= ~0x00000002u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 TraceConfig_TriggerConfig::trigger_timeout_ms() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.TraceConfig.TriggerConfig.trigger_timeout_ms)
  return trigger_timeout_ms_;
}
inline void TraceConfig_TriggerConfig::set_trigger_timeout_ms(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _has_bits_[0] |= 0x00000002u;
  trigger_timeout_ms_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.TraceConfig.TriggerConfig.trigger_timeout_ms)
}

// -------------------------------------------------------------------

// TraceConfig_IncrementalStateConfig

// optional uint32 clear_period_ms = 1;
inline bool TraceConfig_IncrementalStateConfig::has_clear_period_ms() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TraceConfig_IncrementalStateConfig::clear_clear_period_ms() {
  clear_period_ms_ = 0u;
  _has_bits_[0] &= ~0x00000001u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 TraceConfig_IncrementalStateConfig::clear_period_ms() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.TraceConfig.IncrementalStateConfig.clear_period_ms)
  return clear_period_ms_;
}
inline void TraceConfig_IncrementalStateConfig::set_clear_period_ms(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _has_bits_[0] |= 0x00000001u;
  clear_period_ms_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.TraceConfig.IncrementalStateConfig.clear_period_ms)
}

// -------------------------------------------------------------------

// TraceConfig_IncidentReportConfig

// optional string destination_package = 1;
inline bool TraceConfig_IncidentReportConfig::has_destination_package() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TraceConfig_IncidentReportConfig::clear_destination_package() {
  destination_package_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& TraceConfig_IncidentReportConfig::destination_package() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.TraceConfig.IncidentReportConfig.destination_package)
  return destination_package_.GetNoArena();
}
inline void TraceConfig_IncidentReportConfig::set_destination_package(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  destination_package_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:perfetto.protos.TraceConfig.IncidentReportConfig.destination_package)
}
inline void TraceConfig_IncidentReportConfig::set_destination_package(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  destination_package_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:perfetto.protos.TraceConfig.IncidentReportConfig.destination_package)
}
inline void TraceConfig_IncidentReportConfig::set_destination_package(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  destination_package_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:perfetto.protos.TraceConfig.IncidentReportConfig.destination_package)
}
inline void TraceConfig_IncidentReportConfig::set_destination_package(const char* value, size_t size) {
  _has_bits_[0] |= 0x00000001u;
  destination_package_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:perfetto.protos.TraceConfig.IncidentReportConfig.destination_package)
}
inline std::string* TraceConfig_IncidentReportConfig::mutable_destination_package() {
  _has_bits_[0] |= 0x00000001u;
  // @@protoc_insertion_point(field_mutable:perfetto.protos.TraceConfig.IncidentReportConfig.destination_package)
  return destination_package_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* TraceConfig_IncidentReportConfig::release_destination_package() {
  // @@protoc_insertion_point(field_release:perfetto.protos.TraceConfig.IncidentReportConfig.destination_package)
  if (!has_destination_package()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return destination_package_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void TraceConfig_IncidentReportConfig::set_allocated_destination_package(std::string* destination_package) {
  if (destination_package != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  destination_package_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), destination_package);
  // @@protoc_insertion_point(field_set_allocated:perfetto.protos.TraceConfig.IncidentReportConfig.destination_package)
}

// optional string destination_class = 2;
inline bool TraceConfig_IncidentReportConfig::has_destination_class() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void TraceConfig_IncidentReportConfig::clear_destination_class() {
  destination_class_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  _has_bits_[0] &= ~0x00000002u;
}
inline const std::string& TraceConfig_IncidentReportConfig::destination_class() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.TraceConfig.IncidentReportConfig.destination_class)
  return destination_class_.GetNoArena();
}
inline void TraceConfig_IncidentReportConfig::set_destination_class(const std::string& value) {
  _has_bits_[0] |= 0x00000002u;
  destination_class_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:perfetto.protos.TraceConfig.IncidentReportConfig.destination_class)
}
inline void TraceConfig_IncidentReportConfig::set_destination_class(std::string&& value) {
  _has_bits_[0] |= 0x00000002u;
  destination_class_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:perfetto.protos.TraceConfig.IncidentReportConfig.destination_class)
}
inline void TraceConfig_IncidentReportConfig::set_destination_class(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000002u;
  destination_class_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:perfetto.protos.TraceConfig.IncidentReportConfig.destination_class)
}
inline void TraceConfig_IncidentReportConfig::set_destination_class(const char* value, size_t size) {
  _has_bits_[0] |= 0x00000002u;
  destination_class_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:perfetto.protos.TraceConfig.IncidentReportConfig.destination_class)
}
inline std::string* TraceConfig_IncidentReportConfig::mutable_destination_class() {
  _has_bits_[0] |= 0x00000002u;
  // @@protoc_insertion_point(field_mutable:perfetto.protos.TraceConfig.IncidentReportConfig.destination_class)
  return destination_class_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* TraceConfig_IncidentReportConfig::release_destination_class() {
  // @@protoc_insertion_point(field_release:perfetto.protos.TraceConfig.IncidentReportConfig.destination_class)
  if (!has_destination_class()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000002u;
  return destination_class_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void TraceConfig_IncidentReportConfig::set_allocated_destination_class(std::string* destination_class) {
  if (destination_class != nullptr) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  destination_class_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), destination_class);
  // @@protoc_insertion_point(field_set_allocated:perfetto.protos.TraceConfig.IncidentReportConfig.destination_class)
}

// optional int32 privacy_level = 3;
inline bool TraceConfig_IncidentReportConfig::has_privacy_level() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void TraceConfig_IncidentReportConfig::clear_privacy_level() {
  privacy_level_ = 0;
  _has_bits_[0] &= ~0x00000004u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 TraceConfig_IncidentReportConfig::privacy_level() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.TraceConfig.IncidentReportConfig.privacy_level)
  return privacy_level_;
}
inline void TraceConfig_IncidentReportConfig::set_privacy_level(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[0] |= 0x00000004u;
  privacy_level_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.TraceConfig.IncidentReportConfig.privacy_level)
}

// optional bool skip_incidentd = 5;
inline bool TraceConfig_IncidentReportConfig::has_skip_incidentd() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void TraceConfig_IncidentReportConfig::clear_skip_incidentd() {
  skip_incidentd_ = false;
  _has_bits_[0] &= ~0x00000008u;
}
inline bool TraceConfig_IncidentReportConfig::skip_incidentd() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.TraceConfig.IncidentReportConfig.skip_incidentd)
  return skip_incidentd_;
}
inline void TraceConfig_IncidentReportConfig::set_skip_incidentd(bool value) {
  _has_bits_[0] |= 0x00000008u;
  skip_incidentd_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.TraceConfig.IncidentReportConfig.skip_incidentd)
}

// optional bool skip_dropbox = 4 [deprecated = true];
inline bool TraceConfig_IncidentReportConfig::has_skip_dropbox() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void TraceConfig_IncidentReportConfig::clear_skip_dropbox() {
  skip_dropbox_ = false;
  _has_bits_[0] &= ~0x00000010u;
}
inline bool TraceConfig_IncidentReportConfig::skip_dropbox() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.TraceConfig.IncidentReportConfig.skip_dropbox)
  return skip_dropbox_;
}
inline void TraceConfig_IncidentReportConfig::set_skip_dropbox(bool value) {
  _has_bits_[0] |= 0x00000010u;
  skip_dropbox_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.TraceConfig.IncidentReportConfig.skip_dropbox)
}

// -------------------------------------------------------------------

// TraceConfig_TraceFilter

// optional bytes bytecode = 1;
inline bool TraceConfig_TraceFilter::has_bytecode() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TraceConfig_TraceFilter::clear_bytecode() {
  bytecode_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& TraceConfig_TraceFilter::bytecode() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.TraceConfig.TraceFilter.bytecode)
  return bytecode_.GetNoArena();
}
inline void TraceConfig_TraceFilter::set_bytecode(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  bytecode_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:perfetto.protos.TraceConfig.TraceFilter.bytecode)
}
inline void TraceConfig_TraceFilter::set_bytecode(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  bytecode_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:perfetto.protos.TraceConfig.TraceFilter.bytecode)
}
inline void TraceConfig_TraceFilter::set_bytecode(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  bytecode_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:perfetto.protos.TraceConfig.TraceFilter.bytecode)
}
inline void TraceConfig_TraceFilter::set_bytecode(const void* value, size_t size) {
  _has_bits_[0] |= 0x00000001u;
  bytecode_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:perfetto.protos.TraceConfig.TraceFilter.bytecode)
}
inline std::string* TraceConfig_TraceFilter::mutable_bytecode() {
  _has_bits_[0] |= 0x00000001u;
  // @@protoc_insertion_point(field_mutable:perfetto.protos.TraceConfig.TraceFilter.bytecode)
  return bytecode_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* TraceConfig_TraceFilter::release_bytecode() {
  // @@protoc_insertion_point(field_release:perfetto.protos.TraceConfig.TraceFilter.bytecode)
  if (!has_bytecode()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return bytecode_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void TraceConfig_TraceFilter::set_allocated_bytecode(std::string* bytecode) {
  if (bytecode != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  bytecode_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), bytecode);
  // @@protoc_insertion_point(field_set_allocated:perfetto.protos.TraceConfig.TraceFilter.bytecode)
}

// -------------------------------------------------------------------

// TraceConfig

// repeated .perfetto.protos.TraceConfig.BufferConfig buffers = 1;
inline int TraceConfig::buffers_size() const {
  return buffers_.size();
}
inline void TraceConfig::clear_buffers() {
  buffers_.Clear();
}
inline ::perfetto::protos::TraceConfig_BufferConfig* TraceConfig::mutable_buffers(int index) {
  // @@protoc_insertion_point(field_mutable:perfetto.protos.TraceConfig.buffers)
  return buffers_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::TraceConfig_BufferConfig >*
TraceConfig::mutable_buffers() {
  // @@protoc_insertion_point(field_mutable_list:perfetto.protos.TraceConfig.buffers)
  return &buffers_;
}
inline const ::perfetto::protos::TraceConfig_BufferConfig& TraceConfig::buffers(int index) const {
  // @@protoc_insertion_point(field_get:perfetto.protos.TraceConfig.buffers)
  return buffers_.Get(index);
}
inline ::perfetto::protos::TraceConfig_BufferConfig* TraceConfig::add_buffers() {
  // @@protoc_insertion_point(field_add:perfetto.protos.TraceConfig.buffers)
  return buffers_.Add();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::TraceConfig_BufferConfig >&
TraceConfig::buffers() const {
  // @@protoc_insertion_point(field_list:perfetto.protos.TraceConfig.buffers)
  return buffers_;
}

// repeated .perfetto.protos.TraceConfig.DataSource data_sources = 2;
inline int TraceConfig::data_sources_size() const {
  return data_sources_.size();
}
inline void TraceConfig::clear_data_sources() {
  data_sources_.Clear();
}
inline ::perfetto::protos::TraceConfig_DataSource* TraceConfig::mutable_data_sources(int index) {
  // @@protoc_insertion_point(field_mutable:perfetto.protos.TraceConfig.data_sources)
  return data_sources_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::TraceConfig_DataSource >*
TraceConfig::mutable_data_sources() {
  // @@protoc_insertion_point(field_mutable_list:perfetto.protos.TraceConfig.data_sources)
  return &data_sources_;
}
inline const ::perfetto::protos::TraceConfig_DataSource& TraceConfig::data_sources(int index) const {
  // @@protoc_insertion_point(field_get:perfetto.protos.TraceConfig.data_sources)
  return data_sources_.Get(index);
}
inline ::perfetto::protos::TraceConfig_DataSource* TraceConfig::add_data_sources() {
  // @@protoc_insertion_point(field_add:perfetto.protos.TraceConfig.data_sources)
  return data_sources_.Add();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::TraceConfig_DataSource >&
TraceConfig::data_sources() const {
  // @@protoc_insertion_point(field_list:perfetto.protos.TraceConfig.data_sources)
  return data_sources_;
}

// optional .perfetto.protos.TraceConfig.BuiltinDataSource builtin_data_sources = 20;
inline bool TraceConfig::has_builtin_data_sources() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void TraceConfig::clear_builtin_data_sources() {
  if (builtin_data_sources_ != nullptr) builtin_data_sources_->Clear();
  _has_bits_[0] &= ~0x00000020u;
}
inline const ::perfetto::protos::TraceConfig_BuiltinDataSource& TraceConfig::builtin_data_sources() const {
  const ::perfetto::protos::TraceConfig_BuiltinDataSource* p = builtin_data_sources_;
  // @@protoc_insertion_point(field_get:perfetto.protos.TraceConfig.builtin_data_sources)
  return p != nullptr ? *p : *reinterpret_cast<const ::perfetto::protos::TraceConfig_BuiltinDataSource*>(
      &::perfetto::protos::_TraceConfig_BuiltinDataSource_default_instance_);
}
inline ::perfetto::protos::TraceConfig_BuiltinDataSource* TraceConfig::release_builtin_data_sources() {
  // @@protoc_insertion_point(field_release:perfetto.protos.TraceConfig.builtin_data_sources)
  _has_bits_[0] &= ~0x00000020u;
  ::perfetto::protos::TraceConfig_BuiltinDataSource* temp = builtin_data_sources_;
  builtin_data_sources_ = nullptr;
  return temp;
}
inline ::perfetto::protos::TraceConfig_BuiltinDataSource* TraceConfig::mutable_builtin_data_sources() {
  _has_bits_[0] |= 0x00000020u;
  if (builtin_data_sources_ == nullptr) {
    auto* p = CreateMaybeMessage<::perfetto::protos::TraceConfig_BuiltinDataSource>(GetArenaNoVirtual());
    builtin_data_sources_ = p;
  }
  // @@protoc_insertion_point(field_mutable:perfetto.protos.TraceConfig.builtin_data_sources)
  return builtin_data_sources_;
}
inline void TraceConfig::set_allocated_builtin_data_sources(::perfetto::protos::TraceConfig_BuiltinDataSource* builtin_data_sources) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete builtin_data_sources_;
  }
  if (builtin_data_sources) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      builtin_data_sources = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, builtin_data_sources, submessage_arena);
    }
    _has_bits_[0] |= 0x00000020u;
  } else {
    _has_bits_[0] &= ~0x00000020u;
  }
  builtin_data_sources_ = builtin_data_sources;
  // @@protoc_insertion_point(field_set_allocated:perfetto.protos.TraceConfig.builtin_data_sources)
}

// optional uint32 duration_ms = 3;
inline bool TraceConfig::has_duration_ms() const {
  return (_has_bits_[0] & 0x00000200u) != 0;
}
inline void TraceConfig::clear_duration_ms() {
  duration_ms_ = 0u;
  _has_bits_[0] &= ~0x00000200u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 TraceConfig::duration_ms() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.TraceConfig.duration_ms)
  return duration_ms_;
}
inline void TraceConfig::set_duration_ms(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _has_bits_[0] |= 0x00000200u;
  duration_ms_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.TraceConfig.duration_ms)
}

// optional bool enable_extra_guardrails = 4;
inline bool TraceConfig::has_enable_extra_guardrails() const {
  return (_has_bits_[0] & 0x00001000u) != 0;
}
inline void TraceConfig::clear_enable_extra_guardrails() {
  enable_extra_guardrails_ = false;
  _has_bits_[0] &= ~0x00001000u;
}
inline bool TraceConfig::enable_extra_guardrails() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.TraceConfig.enable_extra_guardrails)
  return enable_extra_guardrails_;
}
inline void TraceConfig::set_enable_extra_guardrails(bool value) {
  _has_bits_[0] |= 0x00001000u;
  enable_extra_guardrails_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.TraceConfig.enable_extra_guardrails)
}

// optional .perfetto.protos.TraceConfig.LockdownModeOperation lockdown_mode = 5;
inline bool TraceConfig::has_lockdown_mode() const {
  return (_has_bits_[0] & 0x00000400u) != 0;
}
inline void TraceConfig::clear_lockdown_mode() {
  lockdown_mode_ = 0;
  _has_bits_[0] &= ~0x00000400u;
}
inline ::perfetto::protos::TraceConfig_LockdownModeOperation TraceConfig::lockdown_mode() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.TraceConfig.lockdown_mode)
  return static_cast< ::perfetto::protos::TraceConfig_LockdownModeOperation >(lockdown_mode_);
}
inline void TraceConfig::set_lockdown_mode(::perfetto::protos::TraceConfig_LockdownModeOperation value) {
  assert(::perfetto::protos::TraceConfig_LockdownModeOperation_IsValid(value));
  _has_bits_[0] |= 0x00000400u;
  lockdown_mode_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.TraceConfig.lockdown_mode)
}

// repeated .perfetto.protos.TraceConfig.ProducerConfig producers = 6;
inline int TraceConfig::producers_size() const {
  return producers_.size();
}
inline void TraceConfig::clear_producers() {
  producers_.Clear();
}
inline ::perfetto::protos::TraceConfig_ProducerConfig* TraceConfig::mutable_producers(int index) {
  // @@protoc_insertion_point(field_mutable:perfetto.protos.TraceConfig.producers)
  return producers_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::TraceConfig_ProducerConfig >*
TraceConfig::mutable_producers() {
  // @@protoc_insertion_point(field_mutable_list:perfetto.protos.TraceConfig.producers)
  return &producers_;
}
inline const ::perfetto::protos::TraceConfig_ProducerConfig& TraceConfig::producers(int index) const {
  // @@protoc_insertion_point(field_get:perfetto.protos.TraceConfig.producers)
  return producers_.Get(index);
}
inline ::perfetto::protos::TraceConfig_ProducerConfig* TraceConfig::add_producers() {
  // @@protoc_insertion_point(field_add:perfetto.protos.TraceConfig.producers)
  return producers_.Add();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::TraceConfig_ProducerConfig >&
TraceConfig::producers() const {
  // @@protoc_insertion_point(field_list:perfetto.protos.TraceConfig.producers)
  return producers_;
}

// optional .perfetto.protos.TraceConfig.StatsdMetadata statsd_metadata = 7;
inline bool TraceConfig::has_statsd_metadata() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void TraceConfig::clear_statsd_metadata() {
  if (statsd_metadata_ != nullptr) statsd_metadata_->Clear();
  _has_bits_[0] &= ~0x00000004u;
}
inline const ::perfetto::protos::TraceConfig_StatsdMetadata& TraceConfig::statsd_metadata() const {
  const ::perfetto::protos::TraceConfig_StatsdMetadata* p = statsd_metadata_;
  // @@protoc_insertion_point(field_get:perfetto.protos.TraceConfig.statsd_metadata)
  return p != nullptr ? *p : *reinterpret_cast<const ::perfetto::protos::TraceConfig_StatsdMetadata*>(
      &::perfetto::protos::_TraceConfig_StatsdMetadata_default_instance_);
}
inline ::perfetto::protos::TraceConfig_StatsdMetadata* TraceConfig::release_statsd_metadata() {
  // @@protoc_insertion_point(field_release:perfetto.protos.TraceConfig.statsd_metadata)
  _has_bits_[0] &= ~0x00000004u;
  ::perfetto::protos::TraceConfig_StatsdMetadata* temp = statsd_metadata_;
  statsd_metadata_ = nullptr;
  return temp;
}
inline ::perfetto::protos::TraceConfig_StatsdMetadata* TraceConfig::mutable_statsd_metadata() {
  _has_bits_[0] |= 0x00000004u;
  if (statsd_metadata_ == nullptr) {
    auto* p = CreateMaybeMessage<::perfetto::protos::TraceConfig_StatsdMetadata>(GetArenaNoVirtual());
    statsd_metadata_ = p;
  }
  // @@protoc_insertion_point(field_mutable:perfetto.protos.TraceConfig.statsd_metadata)
  return statsd_metadata_;
}
inline void TraceConfig::set_allocated_statsd_metadata(::perfetto::protos::TraceConfig_StatsdMetadata* statsd_metadata) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete statsd_metadata_;
  }
  if (statsd_metadata) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      statsd_metadata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, statsd_metadata, submessage_arena);
    }
    _has_bits_[0] |= 0x00000004u;
  } else {
    _has_bits_[0] &= ~0x00000004u;
  }
  statsd_metadata_ = statsd_metadata;
  // @@protoc_insertion_point(field_set_allocated:perfetto.protos.TraceConfig.statsd_metadata)
}

// optional bool write_into_file = 8;
inline bool TraceConfig::has_write_into_file() const {
  return (_has_bits_[0] & 0x00002000u) != 0;
}
inline void TraceConfig::clear_write_into_file() {
  write_into_file_ = false;
  _has_bits_[0] &= ~0x00002000u;
}
inline bool TraceConfig::write_into_file() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.TraceConfig.write_into_file)
  return write_into_file_;
}
inline void TraceConfig::set_write_into_file(bool value) {
  _has_bits_[0] |= 0x00002000u;
  write_into_file_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.TraceConfig.write_into_file)
}

// optional string output_path = 29;
inline bool TraceConfig::has_output_path() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void TraceConfig::clear_output_path() {
  output_path_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  _has_bits_[0] &= ~0x00000002u;
}
inline const std::string& TraceConfig::output_path() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.TraceConfig.output_path)
  return output_path_.GetNoArena();
}
inline void TraceConfig::set_output_path(const std::string& value) {
  _has_bits_[0] |= 0x00000002u;
  output_path_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:perfetto.protos.TraceConfig.output_path)
}
inline void TraceConfig::set_output_path(std::string&& value) {
  _has_bits_[0] |= 0x00000002u;
  output_path_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:perfetto.protos.TraceConfig.output_path)
}
inline void TraceConfig::set_output_path(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000002u;
  output_path_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:perfetto.protos.TraceConfig.output_path)
}
inline void TraceConfig::set_output_path(const char* value, size_t size) {
  _has_bits_[0] |= 0x00000002u;
  output_path_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:perfetto.protos.TraceConfig.output_path)
}
inline std::string* TraceConfig::mutable_output_path() {
  _has_bits_[0] |= 0x00000002u;
  // @@protoc_insertion_point(field_mutable:perfetto.protos.TraceConfig.output_path)
  return output_path_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* TraceConfig::release_output_path() {
  // @@protoc_insertion_point(field_release:perfetto.protos.TraceConfig.output_path)
  if (!has_output_path()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000002u;
  return output_path_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void TraceConfig::set_allocated_output_path(std::string* output_path) {
  if (output_path != nullptr) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  output_path_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), output_path);
  // @@protoc_insertion_point(field_set_allocated:perfetto.protos.TraceConfig.output_path)
}

// optional uint32 file_write_period_ms = 9;
inline bool TraceConfig::has_file_write_period_ms() const {
  return (_has_bits_[0] & 0x00000800u) != 0;
}
inline void TraceConfig::clear_file_write_period_ms() {
  file_write_period_ms_ = 0u;
  _has_bits_[0] &= ~0x00000800u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 TraceConfig::file_write_period_ms() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.TraceConfig.file_write_period_ms)
  return file_write_period_ms_;
}
inline void TraceConfig::set_file_write_period_ms(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _has_bits_[0] |= 0x00000800u;
  file_write_period_ms_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.TraceConfig.file_write_period_ms)
}

// optional uint64 max_file_size_bytes = 10;
inline bool TraceConfig::has_max_file_size_bytes() const {
  return (_has_bits_[0] & 0x00010000u) != 0;
}
inline void TraceConfig::clear_max_file_size_bytes() {
  max_file_size_bytes_ = PROTOBUF_ULONGLONG(0);
  _has_bits_[0] &= ~0x00010000u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 TraceConfig::max_file_size_bytes() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.TraceConfig.max_file_size_bytes)
  return max_file_size_bytes_;
}
inline void TraceConfig::set_max_file_size_bytes(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  _has_bits_[0] |= 0x00010000u;
  max_file_size_bytes_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.TraceConfig.max_file_size_bytes)
}

// optional .perfetto.protos.TraceConfig.GuardrailOverrides guardrail_overrides = 11;
inline bool TraceConfig::has_guardrail_overrides() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void TraceConfig::clear_guardrail_overrides() {
  if (guardrail_overrides_ != nullptr) guardrail_overrides_->Clear();
  _has_bits_[0] &= ~0x00000008u;
}
inline const ::perfetto::protos::TraceConfig_GuardrailOverrides& TraceConfig::guardrail_overrides() const {
  const ::perfetto::protos::TraceConfig_GuardrailOverrides* p = guardrail_overrides_;
  // @@protoc_insertion_point(field_get:perfetto.protos.TraceConfig.guardrail_overrides)
  return p != nullptr ? *p : *reinterpret_cast<const ::perfetto::protos::TraceConfig_GuardrailOverrides*>(
      &::perfetto::protos::_TraceConfig_GuardrailOverrides_default_instance_);
}
inline ::perfetto::protos::TraceConfig_GuardrailOverrides* TraceConfig::release_guardrail_overrides() {
  // @@protoc_insertion_point(field_release:perfetto.protos.TraceConfig.guardrail_overrides)
  _has_bits_[0] &= ~0x00000008u;
  ::perfetto::protos::TraceConfig_GuardrailOverrides* temp = guardrail_overrides_;
  guardrail_overrides_ = nullptr;
  return temp;
}
inline ::perfetto::protos::TraceConfig_GuardrailOverrides* TraceConfig::mutable_guardrail_overrides() {
  _has_bits_[0] |= 0x00000008u;
  if (guardrail_overrides_ == nullptr) {
    auto* p = CreateMaybeMessage<::perfetto::protos::TraceConfig_GuardrailOverrides>(GetArenaNoVirtual());
    guardrail_overrides_ = p;
  }
  // @@protoc_insertion_point(field_mutable:perfetto.protos.TraceConfig.guardrail_overrides)
  return guardrail_overrides_;
}
inline void TraceConfig::set_allocated_guardrail_overrides(::perfetto::protos::TraceConfig_GuardrailOverrides* guardrail_overrides) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete guardrail_overrides_;
  }
  if (guardrail_overrides) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      guardrail_overrides = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, guardrail_overrides, submessage_arena);
    }
    _has_bits_[0] |= 0x00000008u;
  } else {
    _has_bits_[0] &= ~0x00000008u;
  }
  guardrail_overrides_ = guardrail_overrides;
  // @@protoc_insertion_point(field_set_allocated:perfetto.protos.TraceConfig.guardrail_overrides)
}

// optional bool deferred_start = 12;
inline bool TraceConfig::has_deferred_start() const {
  return (_has_bits_[0] & 0x00004000u) != 0;
}
inline void TraceConfig::clear_deferred_start() {
  deferred_start_ = false;
  _has_bits_[0] &= ~0x00004000u;
}
inline bool TraceConfig::deferred_start() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.TraceConfig.deferred_start)
  return deferred_start_;
}
inline void TraceConfig::set_deferred_start(bool value) {
  _has_bits_[0] |= 0x00004000u;
  deferred_start_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.TraceConfig.deferred_start)
}

// optional uint32 flush_period_ms = 13;
inline bool TraceConfig::has_flush_period_ms() const {
  return (_has_bits_[0] & 0x00020000u) != 0;
}
inline void TraceConfig::clear_flush_period_ms() {
  flush_period_ms_ = 0u;
  _has_bits_[0] &= ~0x00020000u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 TraceConfig::flush_period_ms() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.TraceConfig.flush_period_ms)
  return flush_period_ms_;
}
inline void TraceConfig::set_flush_period_ms(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _has_bits_[0] |= 0x00020000u;
  flush_period_ms_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.TraceConfig.flush_period_ms)
}

// optional uint32 flush_timeout_ms = 14;
inline bool TraceConfig::has_flush_timeout_ms() const {
  return (_has_bits_[0] & 0x00040000u) != 0;
}
inline void TraceConfig::clear_flush_timeout_ms() {
  flush_timeout_ms_ = 0u;
  _has_bits_[0] &= ~0x00040000u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 TraceConfig::flush_timeout_ms() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.TraceConfig.flush_timeout_ms)
  return flush_timeout_ms_;
}
inline void TraceConfig::set_flush_timeout_ms(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _has_bits_[0] |= 0x00040000u;
  flush_timeout_ms_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.TraceConfig.flush_timeout_ms)
}

// optional uint32 data_source_stop_timeout_ms = 23;
inline bool TraceConfig::has_data_source_stop_timeout_ms() const {
  return (_has_bits_[0] & 0x00100000u) != 0;
}
inline void TraceConfig::clear_data_source_stop_timeout_ms() {
  data_source_stop_timeout_ms_ = 0u;
  _has_bits_[0] &= ~0x00100000u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 TraceConfig::data_source_stop_timeout_ms() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.TraceConfig.data_source_stop_timeout_ms)
  return data_source_stop_timeout_ms_;
}
inline void TraceConfig::set_data_source_stop_timeout_ms(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _has_bits_[0] |= 0x00100000u;
  data_source_stop_timeout_ms_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.TraceConfig.data_source_stop_timeout_ms)
}

// optional bool notify_traceur = 16;
inline bool TraceConfig::has_notify_traceur() const {
  return (_has_bits_[0] & 0x00008000u) != 0;
}
inline void TraceConfig::clear_notify_traceur() {
  notify_traceur_ = false;
  _has_bits_[0] &= ~0x00008000u;
}
inline bool TraceConfig::notify_traceur() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.TraceConfig.notify_traceur)
  return notify_traceur_;
}
inline void TraceConfig::set_notify_traceur(bool value) {
  _has_bits_[0] |= 0x00008000u;
  notify_traceur_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.TraceConfig.notify_traceur)
}

// optional int32 bugreport_score = 30;
inline bool TraceConfig::has_bugreport_score() const {
  return (_has_bits_[0] & 0x00800000u) != 0;
}
inline void TraceConfig::clear_bugreport_score() {
  bugreport_score_ = 0;
  _has_bits_[0] &= ~0x00800000u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 TraceConfig::bugreport_score() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.TraceConfig.bugreport_score)
  return bugreport_score_;
}
inline void TraceConfig::set_bugreport_score(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[0] |= 0x00800000u;
  bugreport_score_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.TraceConfig.bugreport_score)
}

// optional .perfetto.protos.TraceConfig.TriggerConfig trigger_config = 17;
inline bool TraceConfig::has_trigger_config() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void TraceConfig::clear_trigger_config() {
  if (trigger_config_ != nullptr) trigger_config_->Clear();
  _has_bits_[0] &= ~0x00000010u;
}
inline const ::perfetto::protos::TraceConfig_TriggerConfig& TraceConfig::trigger_config() const {
  const ::perfetto::protos::TraceConfig_TriggerConfig* p = trigger_config_;
  // @@protoc_insertion_point(field_get:perfetto.protos.TraceConfig.trigger_config)
  return p != nullptr ? *p : *reinterpret_cast<const ::perfetto::protos::TraceConfig_TriggerConfig*>(
      &::perfetto::protos::_TraceConfig_TriggerConfig_default_instance_);
}
inline ::perfetto::protos::TraceConfig_TriggerConfig* TraceConfig::release_trigger_config() {
  // @@protoc_insertion_point(field_release:perfetto.protos.TraceConfig.trigger_config)
  _has_bits_[0] &= ~0x00000010u;
  ::perfetto::protos::TraceConfig_TriggerConfig* temp = trigger_config_;
  trigger_config_ = nullptr;
  return temp;
}
inline ::perfetto::protos::TraceConfig_TriggerConfig* TraceConfig::mutable_trigger_config() {
  _has_bits_[0] |= 0x00000010u;
  if (trigger_config_ == nullptr) {
    auto* p = CreateMaybeMessage<::perfetto::protos::TraceConfig_TriggerConfig>(GetArenaNoVirtual());
    trigger_config_ = p;
  }
  // @@protoc_insertion_point(field_mutable:perfetto.protos.TraceConfig.trigger_config)
  return trigger_config_;
}
inline void TraceConfig::set_allocated_trigger_config(::perfetto::protos::TraceConfig_TriggerConfig* trigger_config) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete trigger_config_;
  }
  if (trigger_config) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      trigger_config = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, trigger_config, submessage_arena);
    }
    _has_bits_[0] |= 0x00000010u;
  } else {
    _has_bits_[0] &= ~0x00000010u;
  }
  trigger_config_ = trigger_config;
  // @@protoc_insertion_point(field_set_allocated:perfetto.protos.TraceConfig.trigger_config)
}

// repeated string activate_triggers = 18;
inline int TraceConfig::activate_triggers_size() const {
  return activate_triggers_.size();
}
inline void TraceConfig::clear_activate_triggers() {
  activate_triggers_.Clear();
}
inline const std::string& TraceConfig::activate_triggers(int index) const {
  // @@protoc_insertion_point(field_get:perfetto.protos.TraceConfig.activate_triggers)
  return activate_triggers_.Get(index);
}
inline std::string* TraceConfig::mutable_activate_triggers(int index) {
  // @@protoc_insertion_point(field_mutable:perfetto.protos.TraceConfig.activate_triggers)
  return activate_triggers_.Mutable(index);
}
inline void TraceConfig::set_activate_triggers(int index, const std::string& value) {
  // @@protoc_insertion_point(field_set:perfetto.protos.TraceConfig.activate_triggers)
  activate_triggers_.Mutable(index)->assign(value);
}
inline void TraceConfig::set_activate_triggers(int index, std::string&& value) {
  // @@protoc_insertion_point(field_set:perfetto.protos.TraceConfig.activate_triggers)
  activate_triggers_.Mutable(index)->assign(std::move(value));
}
inline void TraceConfig::set_activate_triggers(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  activate_triggers_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:perfetto.protos.TraceConfig.activate_triggers)
}
inline void TraceConfig::set_activate_triggers(int index, const char* value, size_t size) {
  activate_triggers_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:perfetto.protos.TraceConfig.activate_triggers)
}
inline std::string* TraceConfig::add_activate_triggers() {
  // @@protoc_insertion_point(field_add_mutable:perfetto.protos.TraceConfig.activate_triggers)
  return activate_triggers_.Add();
}
inline void TraceConfig::add_activate_triggers(const std::string& value) {
  activate_triggers_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:perfetto.protos.TraceConfig.activate_triggers)
}
inline void TraceConfig::add_activate_triggers(std::string&& value) {
  activate_triggers_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:perfetto.protos.TraceConfig.activate_triggers)
}
inline void TraceConfig::add_activate_triggers(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  activate_triggers_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:perfetto.protos.TraceConfig.activate_triggers)
}
inline void TraceConfig::add_activate_triggers(const char* value, size_t size) {
  activate_triggers_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:perfetto.protos.TraceConfig.activate_triggers)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
TraceConfig::activate_triggers() const {
  // @@protoc_insertion_point(field_list:perfetto.protos.TraceConfig.activate_triggers)
  return activate_triggers_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
TraceConfig::mutable_activate_triggers() {
  // @@protoc_insertion_point(field_mutable_list:perfetto.protos.TraceConfig.activate_triggers)
  return &activate_triggers_;
}

// optional .perfetto.protos.TraceConfig.IncrementalStateConfig incremental_state_config = 21;
inline bool TraceConfig::has_incremental_state_config() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void TraceConfig::clear_incremental_state_config() {
  if (incremental_state_config_ != nullptr) incremental_state_config_->Clear();
  _has_bits_[0] &= ~0x00000040u;
}
inline const ::perfetto::protos::TraceConfig_IncrementalStateConfig& TraceConfig::incremental_state_config() const {
  const ::perfetto::protos::TraceConfig_IncrementalStateConfig* p = incremental_state_config_;
  // @@protoc_insertion_point(field_get:perfetto.protos.TraceConfig.incremental_state_config)
  return p != nullptr ? *p : *reinterpret_cast<const ::perfetto::protos::TraceConfig_IncrementalStateConfig*>(
      &::perfetto::protos::_TraceConfig_IncrementalStateConfig_default_instance_);
}
inline ::perfetto::protos::TraceConfig_IncrementalStateConfig* TraceConfig::release_incremental_state_config() {
  // @@protoc_insertion_point(field_release:perfetto.protos.TraceConfig.incremental_state_config)
  _has_bits_[0] &= ~0x00000040u;
  ::perfetto::protos::TraceConfig_IncrementalStateConfig* temp = incremental_state_config_;
  incremental_state_config_ = nullptr;
  return temp;
}
inline ::perfetto::protos::TraceConfig_IncrementalStateConfig* TraceConfig::mutable_incremental_state_config() {
  _has_bits_[0] |= 0x00000040u;
  if (incremental_state_config_ == nullptr) {
    auto* p = CreateMaybeMessage<::perfetto::protos::TraceConfig_IncrementalStateConfig>(GetArenaNoVirtual());
    incremental_state_config_ = p;
  }
  // @@protoc_insertion_point(field_mutable:perfetto.protos.TraceConfig.incremental_state_config)
  return incremental_state_config_;
}
inline void TraceConfig::set_allocated_incremental_state_config(::perfetto::protos::TraceConfig_IncrementalStateConfig* incremental_state_config) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete incremental_state_config_;
  }
  if (incremental_state_config) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      incremental_state_config = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, incremental_state_config, submessage_arena);
    }
    _has_bits_[0] |= 0x00000040u;
  } else {
    _has_bits_[0] &= ~0x00000040u;
  }
  incremental_state_config_ = incremental_state_config;
  // @@protoc_insertion_point(field_set_allocated:perfetto.protos.TraceConfig.incremental_state_config)
}

// optional bool allow_user_build_tracing = 19;
inline bool TraceConfig::has_allow_user_build_tracing() const {
  return (_has_bits_[0] & 0x00080000u) != 0;
}
inline void TraceConfig::clear_allow_user_build_tracing() {
  allow_user_build_tracing_ = false;
  _has_bits_[0] &= ~0x00080000u;
}
inline bool TraceConfig::allow_user_build_tracing() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.TraceConfig.allow_user_build_tracing)
  return allow_user_build_tracing_;
}
inline void TraceConfig::set_allow_user_build_tracing(bool value) {
  _has_bits_[0] |= 0x00080000u;
  allow_user_build_tracing_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.TraceConfig.allow_user_build_tracing)
}

// optional string unique_session_name = 22;
inline bool TraceConfig::has_unique_session_name() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TraceConfig::clear_unique_session_name() {
  unique_session_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& TraceConfig::unique_session_name() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.TraceConfig.unique_session_name)
  return unique_session_name_.GetNoArena();
}
inline void TraceConfig::set_unique_session_name(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  unique_session_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:perfetto.protos.TraceConfig.unique_session_name)
}
inline void TraceConfig::set_unique_session_name(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  unique_session_name_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:perfetto.protos.TraceConfig.unique_session_name)
}
inline void TraceConfig::set_unique_session_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  unique_session_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:perfetto.protos.TraceConfig.unique_session_name)
}
inline void TraceConfig::set_unique_session_name(const char* value, size_t size) {
  _has_bits_[0] |= 0x00000001u;
  unique_session_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:perfetto.protos.TraceConfig.unique_session_name)
}
inline std::string* TraceConfig::mutable_unique_session_name() {
  _has_bits_[0] |= 0x00000001u;
  // @@protoc_insertion_point(field_mutable:perfetto.protos.TraceConfig.unique_session_name)
  return unique_session_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* TraceConfig::release_unique_session_name() {
  // @@protoc_insertion_point(field_release:perfetto.protos.TraceConfig.unique_session_name)
  if (!has_unique_session_name()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return unique_session_name_.ReleaseNonDefaultNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void TraceConfig::set_allocated_unique_session_name(std::string* unique_session_name) {
  if (unique_session_name != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  unique_session_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), unique_session_name);
  // @@protoc_insertion_point(field_set_allocated:perfetto.protos.TraceConfig.unique_session_name)
}

// optional .perfetto.protos.TraceConfig.CompressionType compression_type = 24;
inline bool TraceConfig::has_compression_type() const {
  return (_has_bits_[0] & 0x00400000u) != 0;
}
inline void TraceConfig::clear_compression_type() {
  compression_type_ = 0;
  _has_bits_[0] &= ~0x00400000u;
}
inline ::perfetto::protos::TraceConfig_CompressionType TraceConfig::compression_type() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.TraceConfig.compression_type)
  return static_cast< ::perfetto::protos::TraceConfig_CompressionType >(compression_type_);
}
inline void TraceConfig::set_compression_type(::perfetto::protos::TraceConfig_CompressionType value) {
  assert(::perfetto::protos::TraceConfig_CompressionType_IsValid(value));
  _has_bits_[0] |= 0x00400000u;
  compression_type_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.TraceConfig.compression_type)
}

// optional .perfetto.protos.TraceConfig.IncidentReportConfig incident_report_config = 25;
inline bool TraceConfig::has_incident_report_config() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void TraceConfig::clear_incident_report_config() {
  if (incident_report_config_ != nullptr) incident_report_config_->Clear();
  _has_bits_[0] &= ~0x00000080u;
}
inline const ::perfetto::protos::TraceConfig_IncidentReportConfig& TraceConfig::incident_report_config() const {
  const ::perfetto::protos::TraceConfig_IncidentReportConfig* p = incident_report_config_;
  // @@protoc_insertion_point(field_get:perfetto.protos.TraceConfig.incident_report_config)
  return p != nullptr ? *p : *reinterpret_cast<const ::perfetto::protos::TraceConfig_IncidentReportConfig*>(
      &::perfetto::protos::_TraceConfig_IncidentReportConfig_default_instance_);
}
inline ::perfetto::protos::TraceConfig_IncidentReportConfig* TraceConfig::release_incident_report_config() {
  // @@protoc_insertion_point(field_release:perfetto.protos.TraceConfig.incident_report_config)
  _has_bits_[0] &= ~0x00000080u;
  ::perfetto::protos::TraceConfig_IncidentReportConfig* temp = incident_report_config_;
  incident_report_config_ = nullptr;
  return temp;
}
inline ::perfetto::protos::TraceConfig_IncidentReportConfig* TraceConfig::mutable_incident_report_config() {
  _has_bits_[0] |= 0x00000080u;
  if (incident_report_config_ == nullptr) {
    auto* p = CreateMaybeMessage<::perfetto::protos::TraceConfig_IncidentReportConfig>(GetArenaNoVirtual());
    incident_report_config_ = p;
  }
  // @@protoc_insertion_point(field_mutable:perfetto.protos.TraceConfig.incident_report_config)
  return incident_report_config_;
}
inline void TraceConfig::set_allocated_incident_report_config(::perfetto::protos::TraceConfig_IncidentReportConfig* incident_report_config) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete incident_report_config_;
  }
  if (incident_report_config) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      incident_report_config = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, incident_report_config, submessage_arena);
    }
    _has_bits_[0] |= 0x00000080u;
  } else {
    _has_bits_[0] &= ~0x00000080u;
  }
  incident_report_config_ = incident_report_config;
  // @@protoc_insertion_point(field_set_allocated:perfetto.protos.TraceConfig.incident_report_config)
}

// optional .perfetto.protos.TraceConfig.StatsdLogging statsd_logging = 31;
inline bool TraceConfig::has_statsd_logging() const {
  return (_has_bits_[0] & 0x02000000u) != 0;
}
inline void TraceConfig::clear_statsd_logging() {
  statsd_logging_ = 0;
  _has_bits_[0] &= ~0x02000000u;
}
inline ::perfetto::protos::TraceConfig_StatsdLogging TraceConfig::statsd_logging() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.TraceConfig.statsd_logging)
  return static_cast< ::perfetto::protos::TraceConfig_StatsdLogging >(statsd_logging_);
}
inline void TraceConfig::set_statsd_logging(::perfetto::protos::TraceConfig_StatsdLogging value) {
  assert(::perfetto::protos::TraceConfig_StatsdLogging_IsValid(value));
  _has_bits_[0] |= 0x02000000u;
  statsd_logging_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.TraceConfig.statsd_logging)
}

// optional int64 trace_uuid_msb = 27;
inline bool TraceConfig::has_trace_uuid_msb() const {
  return (_has_bits_[0] & 0x00200000u) != 0;
}
inline void TraceConfig::clear_trace_uuid_msb() {
  trace_uuid_msb_ = PROTOBUF_LONGLONG(0);
  _has_bits_[0] &= ~0x00200000u;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 TraceConfig::trace_uuid_msb() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.TraceConfig.trace_uuid_msb)
  return trace_uuid_msb_;
}
inline void TraceConfig::set_trace_uuid_msb(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _has_bits_[0] |= 0x00200000u;
  trace_uuid_msb_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.TraceConfig.trace_uuid_msb)
}

// optional int64 trace_uuid_lsb = 28;
inline bool TraceConfig::has_trace_uuid_lsb() const {
  return (_has_bits_[0] & 0x01000000u) != 0;
}
inline void TraceConfig::clear_trace_uuid_lsb() {
  trace_uuid_lsb_ = PROTOBUF_LONGLONG(0);
  _has_bits_[0] &= ~0x01000000u;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 TraceConfig::trace_uuid_lsb() const {
  // @@protoc_insertion_point(field_get:perfetto.protos.TraceConfig.trace_uuid_lsb)
  return trace_uuid_lsb_;
}
inline void TraceConfig::set_trace_uuid_lsb(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _has_bits_[0] |= 0x01000000u;
  trace_uuid_lsb_ = value;
  // @@protoc_insertion_point(field_set:perfetto.protos.TraceConfig.trace_uuid_lsb)
}

// optional .perfetto.protos.TraceConfig.TraceFilter trace_filter = 33;
inline bool TraceConfig::has_trace_filter() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void TraceConfig::clear_trace_filter() {
  if (trace_filter_ != nullptr) trace_filter_->Clear();
  _has_bits_[0] &= ~0x00000100u;
}
inline const ::perfetto::protos::TraceConfig_TraceFilter& TraceConfig::trace_filter() const {
  const ::perfetto::protos::TraceConfig_TraceFilter* p = trace_filter_;
  // @@protoc_insertion_point(field_get:perfetto.protos.TraceConfig.trace_filter)
  return p != nullptr ? *p : *reinterpret_cast<const ::perfetto::protos::TraceConfig_TraceFilter*>(
      &::perfetto::protos::_TraceConfig_TraceFilter_default_instance_);
}
inline ::perfetto::protos::TraceConfig_TraceFilter* TraceConfig::release_trace_filter() {
  // @@protoc_insertion_point(field_release:perfetto.protos.TraceConfig.trace_filter)
  _has_bits_[0] &= ~0x00000100u;
  ::perfetto::protos::TraceConfig_TraceFilter* temp = trace_filter_;
  trace_filter_ = nullptr;
  return temp;
}
inline ::perfetto::protos::TraceConfig_TraceFilter* TraceConfig::mutable_trace_filter() {
  _has_bits_[0] |= 0x00000100u;
  if (trace_filter_ == nullptr) {
    auto* p = CreateMaybeMessage<::perfetto::protos::TraceConfig_TraceFilter>(GetArenaNoVirtual());
    trace_filter_ = p;
  }
  // @@protoc_insertion_point(field_mutable:perfetto.protos.TraceConfig.trace_filter)
  return trace_filter_;
}
inline void TraceConfig::set_allocated_trace_filter(::perfetto::protos::TraceConfig_TraceFilter* trace_filter) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete trace_filter_;
  }
  if (trace_filter) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      trace_filter = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, trace_filter, submessage_arena);
    }
    _has_bits_[0] |= 0x00000100u;
  } else {
    _has_bits_[0] &= ~0x00000100u;
  }
  trace_filter_ = trace_filter;
  // @@protoc_insertion_point(field_set_allocated:perfetto.protos.TraceConfig.trace_filter)
}

#ifdef __GNUC__
  #pragma GCC diagnostic pop
#endif  // __GNUC__
// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------


// @@protoc_insertion_point(namespace_scope)

}  // namespace protos
}  // namespace perfetto

PROTOBUF_NAMESPACE_OPEN

template <> struct is_proto_enum< ::perfetto::protos::TraceConfig_BufferConfig_FillPolicy> : ::std::true_type {};
template <> struct is_proto_enum< ::perfetto::protos::TraceConfig_TriggerConfig_TriggerMode> : ::std::true_type {};
template <> struct is_proto_enum< ::perfetto::protos::TraceConfig_LockdownModeOperation> : ::std::true_type {};
template <> struct is_proto_enum< ::perfetto::protos::TraceConfig_CompressionType> : ::std::true_type {};
template <> struct is_proto_enum< ::perfetto::protos::TraceConfig_StatsdLogging> : ::std::true_type {};

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

#include <google/protobuf/port_undef.inc>
#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_protos_2fperfetto_2fconfig_2ftrace_5fconfig_2eproto