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