1/* 2 * Copyright (C) 2017 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17/******************************************************************************* 18 * AUTOGENERATED - DO NOT EDIT 19 ******************************************************************************* 20 * This file has been generated from the protobuf message 21 * perfetto/config/trace_config.proto 22 * by 23 * ../../tools/proto_to_cpp/proto_to_cpp.cc. 24 * If you need to make changes here, change the .proto file and then run 25 * ./tools/gen_tracing_cpp_headers_from_protos.py 26 */ 27 28#include "perfetto/tracing/core/trace_config.h" 29 30#include "perfetto/config/data_source_config.pb.h" 31#include "perfetto/config/trace_config.pb.h" 32 33namespace perfetto { 34 35TraceConfig::TraceConfig() = default; 36TraceConfig::~TraceConfig() = default; 37TraceConfig::TraceConfig(const TraceConfig&) = default; 38TraceConfig& TraceConfig::operator=(const TraceConfig&) = default; 39TraceConfig::TraceConfig(TraceConfig&&) noexcept = default; 40TraceConfig& TraceConfig::operator=(TraceConfig&&) = default; 41 42void TraceConfig::FromProto(const perfetto::protos::TraceConfig& proto) { 43 buffers_.clear(); 44 for (const auto& field : proto.buffers()) { 45 buffers_.emplace_back(); 46 buffers_.back().FromProto(field); 47 } 48 49 data_sources_.clear(); 50 for (const auto& field : proto.data_sources()) { 51 data_sources_.emplace_back(); 52 data_sources_.back().FromProto(field); 53 } 54 55 static_assert(sizeof(duration_ms_) == sizeof(proto.duration_ms()), 56 "size mismatch"); 57 duration_ms_ = static_cast<decltype(duration_ms_)>(proto.duration_ms()); 58 59 static_assert(sizeof(enable_extra_guardrails_) == 60 sizeof(proto.enable_extra_guardrails()), 61 "size mismatch"); 62 enable_extra_guardrails_ = static_cast<decltype(enable_extra_guardrails_)>( 63 proto.enable_extra_guardrails()); 64 65 static_assert(sizeof(lockdown_mode_) == sizeof(proto.lockdown_mode()), 66 "size mismatch"); 67 lockdown_mode_ = static_cast<decltype(lockdown_mode_)>(proto.lockdown_mode()); 68 69 producers_.clear(); 70 for (const auto& field : proto.producers()) { 71 producers_.emplace_back(); 72 producers_.back().FromProto(field); 73 } 74 75 statsd_metadata_.FromProto(proto.statsd_metadata()); 76 77 static_assert(sizeof(write_into_file_) == sizeof(proto.write_into_file()), 78 "size mismatch"); 79 write_into_file_ = 80 static_cast<decltype(write_into_file_)>(proto.write_into_file()); 81 82 static_assert( 83 sizeof(file_write_period_ms_) == sizeof(proto.file_write_period_ms()), 84 "size mismatch"); 85 file_write_period_ms_ = static_cast<decltype(file_write_period_ms_)>( 86 proto.file_write_period_ms()); 87 88 static_assert( 89 sizeof(max_file_size_bytes_) == sizeof(proto.max_file_size_bytes()), 90 "size mismatch"); 91 max_file_size_bytes_ = 92 static_cast<decltype(max_file_size_bytes_)>(proto.max_file_size_bytes()); 93 94 guardrail_overrides_.FromProto(proto.guardrail_overrides()); 95 unknown_fields_ = proto.unknown_fields(); 96} 97 98void TraceConfig::ToProto(perfetto::protos::TraceConfig* proto) const { 99 proto->Clear(); 100 101 for (const auto& it : buffers_) { 102 auto* entry = proto->add_buffers(); 103 it.ToProto(entry); 104 } 105 106 for (const auto& it : data_sources_) { 107 auto* entry = proto->add_data_sources(); 108 it.ToProto(entry); 109 } 110 111 static_assert(sizeof(duration_ms_) == sizeof(proto->duration_ms()), 112 "size mismatch"); 113 proto->set_duration_ms( 114 static_cast<decltype(proto->duration_ms())>(duration_ms_)); 115 116 static_assert(sizeof(enable_extra_guardrails_) == 117 sizeof(proto->enable_extra_guardrails()), 118 "size mismatch"); 119 proto->set_enable_extra_guardrails( 120 static_cast<decltype(proto->enable_extra_guardrails())>( 121 enable_extra_guardrails_)); 122 123 static_assert(sizeof(lockdown_mode_) == sizeof(proto->lockdown_mode()), 124 "size mismatch"); 125 proto->set_lockdown_mode( 126 static_cast<decltype(proto->lockdown_mode())>(lockdown_mode_)); 127 128 for (const auto& it : producers_) { 129 auto* entry = proto->add_producers(); 130 it.ToProto(entry); 131 } 132 133 statsd_metadata_.ToProto(proto->mutable_statsd_metadata()); 134 135 static_assert(sizeof(write_into_file_) == sizeof(proto->write_into_file()), 136 "size mismatch"); 137 proto->set_write_into_file( 138 static_cast<decltype(proto->write_into_file())>(write_into_file_)); 139 140 static_assert( 141 sizeof(file_write_period_ms_) == sizeof(proto->file_write_period_ms()), 142 "size mismatch"); 143 proto->set_file_write_period_ms( 144 static_cast<decltype(proto->file_write_period_ms())>( 145 file_write_period_ms_)); 146 147 static_assert( 148 sizeof(max_file_size_bytes_) == sizeof(proto->max_file_size_bytes()), 149 "size mismatch"); 150 proto->set_max_file_size_bytes( 151 static_cast<decltype(proto->max_file_size_bytes())>( 152 max_file_size_bytes_)); 153 154 guardrail_overrides_.ToProto(proto->mutable_guardrail_overrides()); 155 *(proto->mutable_unknown_fields()) = unknown_fields_; 156} 157 158TraceConfig::BufferConfig::BufferConfig() = default; 159TraceConfig::BufferConfig::~BufferConfig() = default; 160TraceConfig::BufferConfig::BufferConfig(const TraceConfig::BufferConfig&) = 161 default; 162TraceConfig::BufferConfig& TraceConfig::BufferConfig::operator=( 163 const TraceConfig::BufferConfig&) = default; 164TraceConfig::BufferConfig::BufferConfig(TraceConfig::BufferConfig&&) noexcept = 165 default; 166TraceConfig::BufferConfig& TraceConfig::BufferConfig::operator=( 167 TraceConfig::BufferConfig&&) = default; 168 169void TraceConfig::BufferConfig::FromProto( 170 const perfetto::protos::TraceConfig_BufferConfig& proto) { 171 static_assert(sizeof(size_kb_) == sizeof(proto.size_kb()), "size mismatch"); 172 size_kb_ = static_cast<decltype(size_kb_)>(proto.size_kb()); 173 174 static_assert(sizeof(fill_policy_) == sizeof(proto.fill_policy()), 175 "size mismatch"); 176 fill_policy_ = static_cast<decltype(fill_policy_)>(proto.fill_policy()); 177 unknown_fields_ = proto.unknown_fields(); 178} 179 180void TraceConfig::BufferConfig::ToProto( 181 perfetto::protos::TraceConfig_BufferConfig* proto) const { 182 proto->Clear(); 183 184 static_assert(sizeof(size_kb_) == sizeof(proto->size_kb()), "size mismatch"); 185 proto->set_size_kb(static_cast<decltype(proto->size_kb())>(size_kb_)); 186 187 static_assert(sizeof(fill_policy_) == sizeof(proto->fill_policy()), 188 "size mismatch"); 189 proto->set_fill_policy( 190 static_cast<decltype(proto->fill_policy())>(fill_policy_)); 191 *(proto->mutable_unknown_fields()) = unknown_fields_; 192} 193 194TraceConfig::DataSource::DataSource() = default; 195TraceConfig::DataSource::~DataSource() = default; 196TraceConfig::DataSource::DataSource(const TraceConfig::DataSource&) = default; 197TraceConfig::DataSource& TraceConfig::DataSource::operator=( 198 const TraceConfig::DataSource&) = default; 199TraceConfig::DataSource::DataSource(TraceConfig::DataSource&&) noexcept = 200 default; 201TraceConfig::DataSource& TraceConfig::DataSource::operator=( 202 TraceConfig::DataSource&&) = default; 203 204void TraceConfig::DataSource::FromProto( 205 const perfetto::protos::TraceConfig_DataSource& proto) { 206 config_.FromProto(proto.config()); 207 208 producer_name_filter_.clear(); 209 for (const auto& field : proto.producer_name_filter()) { 210 producer_name_filter_.emplace_back(); 211 static_assert(sizeof(producer_name_filter_.back()) == 212 sizeof(proto.producer_name_filter(0)), 213 "size mismatch"); 214 producer_name_filter_.back() = 215 static_cast<decltype(producer_name_filter_)::value_type>(field); 216 } 217 unknown_fields_ = proto.unknown_fields(); 218} 219 220void TraceConfig::DataSource::ToProto( 221 perfetto::protos::TraceConfig_DataSource* proto) const { 222 proto->Clear(); 223 224 config_.ToProto(proto->mutable_config()); 225 226 for (const auto& it : producer_name_filter_) { 227 proto->add_producer_name_filter( 228 static_cast<decltype(proto->producer_name_filter(0))>(it)); 229 static_assert(sizeof(it) == sizeof(proto->producer_name_filter(0)), 230 "size mismatch"); 231 } 232 *(proto->mutable_unknown_fields()) = unknown_fields_; 233} 234 235TraceConfig::ProducerConfig::ProducerConfig() = default; 236TraceConfig::ProducerConfig::~ProducerConfig() = default; 237TraceConfig::ProducerConfig::ProducerConfig( 238 const TraceConfig::ProducerConfig&) = default; 239TraceConfig::ProducerConfig& TraceConfig::ProducerConfig::operator=( 240 const TraceConfig::ProducerConfig&) = default; 241TraceConfig::ProducerConfig::ProducerConfig( 242 TraceConfig::ProducerConfig&&) noexcept = default; 243TraceConfig::ProducerConfig& TraceConfig::ProducerConfig::operator=( 244 TraceConfig::ProducerConfig&&) = default; 245 246void TraceConfig::ProducerConfig::FromProto( 247 const perfetto::protos::TraceConfig_ProducerConfig& proto) { 248 static_assert(sizeof(producer_name_) == sizeof(proto.producer_name()), 249 "size mismatch"); 250 producer_name_ = static_cast<decltype(producer_name_)>(proto.producer_name()); 251 252 static_assert(sizeof(shm_size_kb_) == sizeof(proto.shm_size_kb()), 253 "size mismatch"); 254 shm_size_kb_ = static_cast<decltype(shm_size_kb_)>(proto.shm_size_kb()); 255 256 static_assert(sizeof(page_size_kb_) == sizeof(proto.page_size_kb()), 257 "size mismatch"); 258 page_size_kb_ = static_cast<decltype(page_size_kb_)>(proto.page_size_kb()); 259 unknown_fields_ = proto.unknown_fields(); 260} 261 262void TraceConfig::ProducerConfig::ToProto( 263 perfetto::protos::TraceConfig_ProducerConfig* proto) const { 264 proto->Clear(); 265 266 static_assert(sizeof(producer_name_) == sizeof(proto->producer_name()), 267 "size mismatch"); 268 proto->set_producer_name( 269 static_cast<decltype(proto->producer_name())>(producer_name_)); 270 271 static_assert(sizeof(shm_size_kb_) == sizeof(proto->shm_size_kb()), 272 "size mismatch"); 273 proto->set_shm_size_kb( 274 static_cast<decltype(proto->shm_size_kb())>(shm_size_kb_)); 275 276 static_assert(sizeof(page_size_kb_) == sizeof(proto->page_size_kb()), 277 "size mismatch"); 278 proto->set_page_size_kb( 279 static_cast<decltype(proto->page_size_kb())>(page_size_kb_)); 280 *(proto->mutable_unknown_fields()) = unknown_fields_; 281} 282 283TraceConfig::StatsdMetadata::StatsdMetadata() = default; 284TraceConfig::StatsdMetadata::~StatsdMetadata() = default; 285TraceConfig::StatsdMetadata::StatsdMetadata( 286 const TraceConfig::StatsdMetadata&) = default; 287TraceConfig::StatsdMetadata& TraceConfig::StatsdMetadata::operator=( 288 const TraceConfig::StatsdMetadata&) = default; 289TraceConfig::StatsdMetadata::StatsdMetadata( 290 TraceConfig::StatsdMetadata&&) noexcept = default; 291TraceConfig::StatsdMetadata& TraceConfig::StatsdMetadata::operator=( 292 TraceConfig::StatsdMetadata&&) = default; 293 294void TraceConfig::StatsdMetadata::FromProto( 295 const perfetto::protos::TraceConfig_StatsdMetadata& proto) { 296 static_assert( 297 sizeof(triggering_alert_id_) == sizeof(proto.triggering_alert_id()), 298 "size mismatch"); 299 triggering_alert_id_ = 300 static_cast<decltype(triggering_alert_id_)>(proto.triggering_alert_id()); 301 302 static_assert( 303 sizeof(triggering_config_uid_) == sizeof(proto.triggering_config_uid()), 304 "size mismatch"); 305 triggering_config_uid_ = static_cast<decltype(triggering_config_uid_)>( 306 proto.triggering_config_uid()); 307 308 static_assert( 309 sizeof(triggering_config_id_) == sizeof(proto.triggering_config_id()), 310 "size mismatch"); 311 triggering_config_id_ = static_cast<decltype(triggering_config_id_)>( 312 proto.triggering_config_id()); 313 unknown_fields_ = proto.unknown_fields(); 314} 315 316void TraceConfig::StatsdMetadata::ToProto( 317 perfetto::protos::TraceConfig_StatsdMetadata* proto) const { 318 proto->Clear(); 319 320 static_assert( 321 sizeof(triggering_alert_id_) == sizeof(proto->triggering_alert_id()), 322 "size mismatch"); 323 proto->set_triggering_alert_id( 324 static_cast<decltype(proto->triggering_alert_id())>( 325 triggering_alert_id_)); 326 327 static_assert( 328 sizeof(triggering_config_uid_) == sizeof(proto->triggering_config_uid()), 329 "size mismatch"); 330 proto->set_triggering_config_uid( 331 static_cast<decltype(proto->triggering_config_uid())>( 332 triggering_config_uid_)); 333 334 static_assert( 335 sizeof(triggering_config_id_) == sizeof(proto->triggering_config_id()), 336 "size mismatch"); 337 proto->set_triggering_config_id( 338 static_cast<decltype(proto->triggering_config_id())>( 339 triggering_config_id_)); 340 *(proto->mutable_unknown_fields()) = unknown_fields_; 341} 342 343TraceConfig::GuardrailOverrides::GuardrailOverrides() = default; 344TraceConfig::GuardrailOverrides::~GuardrailOverrides() = default; 345TraceConfig::GuardrailOverrides::GuardrailOverrides( 346 const TraceConfig::GuardrailOverrides&) = default; 347TraceConfig::GuardrailOverrides& TraceConfig::GuardrailOverrides::operator=( 348 const TraceConfig::GuardrailOverrides&) = default; 349TraceConfig::GuardrailOverrides::GuardrailOverrides( 350 TraceConfig::GuardrailOverrides&&) noexcept = default; 351TraceConfig::GuardrailOverrides& TraceConfig::GuardrailOverrides::operator=( 352 TraceConfig::GuardrailOverrides&&) = default; 353 354void TraceConfig::GuardrailOverrides::FromProto( 355 const perfetto::protos::TraceConfig_GuardrailOverrides& proto) { 356 static_assert(sizeof(max_upload_per_day_bytes_) == 357 sizeof(proto.max_upload_per_day_bytes()), 358 "size mismatch"); 359 max_upload_per_day_bytes_ = static_cast<decltype(max_upload_per_day_bytes_)>( 360 proto.max_upload_per_day_bytes()); 361 unknown_fields_ = proto.unknown_fields(); 362} 363 364void TraceConfig::GuardrailOverrides::ToProto( 365 perfetto::protos::TraceConfig_GuardrailOverrides* proto) const { 366 proto->Clear(); 367 368 static_assert(sizeof(max_upload_per_day_bytes_) == 369 sizeof(proto->max_upload_per_day_bytes()), 370 "size mismatch"); 371 proto->set_max_upload_per_day_bytes( 372 static_cast<decltype(proto->max_upload_per_day_bytes())>( 373 max_upload_per_day_bytes_)); 374 *(proto->mutable_unknown_fields()) = unknown_fields_; 375} 376 377} // namespace perfetto 378