1 #ifndef SRC_TRACE_PROCESSOR_TABLES_ANDROID_TABLES_PY_H_ 2 #define SRC_TRACE_PROCESSOR_TABLES_ANDROID_TABLES_PY_H_ 3 4 #include <array> 5 #include <cstddef> 6 #include <cstdint> 7 #include <memory> 8 #include <optional> 9 #include <type_traits> 10 #include <utility> 11 #include <vector> 12 13 #include "perfetto/base/logging.h" 14 #include "perfetto/trace_processor/basic_types.h" 15 #include "perfetto/trace_processor/ref_counted.h" 16 #include "src/trace_processor/containers/bit_vector.h" 17 #include "src/trace_processor/containers/row_map.h" 18 #include "src/trace_processor/containers/string_pool.h" 19 #include "src/trace_processor/db/column/arrangement_overlay.h" 20 #include "src/trace_processor/db/column/data_layer.h" 21 #include "src/trace_processor/db/column/dense_null_overlay.h" 22 #include "src/trace_processor/db/column/numeric_storage.h" 23 #include "src/trace_processor/db/column/id_storage.h" 24 #include "src/trace_processor/db/column/null_overlay.h" 25 #include "src/trace_processor/db/column/range_overlay.h" 26 #include "src/trace_processor/db/column/selector_overlay.h" 27 #include "src/trace_processor/db/column/set_id_storage.h" 28 #include "src/trace_processor/db/column/string_storage.h" 29 #include "src/trace_processor/db/column/types.h" 30 #include "src/trace_processor/db/column_storage.h" 31 #include "src/trace_processor/db/column.h" 32 #include "src/trace_processor/db/table.h" 33 #include "src/trace_processor/db/typed_column.h" 34 #include "src/trace_processor/db/typed_column_internal.h" 35 #include "src/trace_processor/tables/macros_internal.h" 36 37 #include "src/trace_processor/tables/metadata_tables_py.h" 38 39 namespace perfetto::trace_processor::tables { 40 41 class AndroidLogTable : public macros_internal::MacroTable { 42 public: 43 static constexpr uint32_t kColumnCount = 7; 44 45 struct Id : public BaseId { 46 Id() = default; IdId47 explicit constexpr Id(uint32_t v) : BaseId(v) {} 48 }; 49 static_assert(std::is_trivially_destructible_v<Id>, 50 "Inheritance used without trivial destruction"); 51 52 struct ColumnIndex { 53 static constexpr uint32_t id = 0; 54 static constexpr uint32_t type = 1; 55 static constexpr uint32_t ts = 2; 56 static constexpr uint32_t utid = 3; 57 static constexpr uint32_t prio = 4; 58 static constexpr uint32_t tag = 5; 59 static constexpr uint32_t msg = 6; 60 }; 61 struct ColumnType { 62 using id = IdColumn<AndroidLogTable::Id>; 63 using type = TypedColumn<StringPool::Id>; 64 using ts = TypedColumn<int64_t>; 65 using utid = TypedColumn<uint32_t>; 66 using prio = TypedColumn<uint32_t>; 67 using tag = TypedColumn<std::optional<StringPool::Id>>; 68 using msg = TypedColumn<StringPool::Id>; 69 }; 70 struct Row : public macros_internal::RootParentTable::Row { 71 Row(int64_t in_ts = {}, 72 uint32_t in_utid = {}, 73 uint32_t in_prio = {}, 74 std::optional<StringPool::Id> in_tag = {}, 75 StringPool::Id in_msg = {}, 76 std::nullptr_t = nullptr) RowRow77 : macros_internal::RootParentTable::Row(), 78 ts(in_ts), 79 utid(in_utid), 80 prio(in_prio), 81 tag(in_tag), 82 msg(in_msg) { 83 type_ = "__intrinsic_android_logs"; 84 } 85 int64_t ts; 86 uint32_t utid; 87 uint32_t prio; 88 std::optional<StringPool::Id> tag; 89 StringPool::Id msg; 90 91 bool operator==(const AndroidLogTable::Row& other) const { 92 return type() == other.type() && ColumnType::ts::Equals(ts, other.ts) && 93 ColumnType::utid::Equals(utid, other.utid) && 94 ColumnType::prio::Equals(prio, other.prio) && 95 ColumnType::tag::Equals(tag, other.tag) && 96 ColumnType::msg::Equals(msg, other.msg); 97 } 98 }; 99 struct ColumnFlag { 100 static constexpr uint32_t ts = ColumnType::ts::default_flags(); 101 static constexpr uint32_t utid = ColumnType::utid::default_flags(); 102 static constexpr uint32_t prio = ColumnType::prio::default_flags(); 103 static constexpr uint32_t tag = ColumnType::tag::default_flags(); 104 static constexpr uint32_t msg = ColumnType::msg::default_flags(); 105 }; 106 107 class RowNumber; 108 class ConstRowReference; 109 class RowReference; 110 111 class RowNumber : public macros_internal::AbstractRowNumber< 112 AndroidLogTable, ConstRowReference, RowReference> { 113 public: RowNumber(uint32_t row_number)114 explicit RowNumber(uint32_t row_number) 115 : AbstractRowNumber(row_number) {} 116 }; 117 static_assert(std::is_trivially_destructible_v<RowNumber>, 118 "Inheritance used without trivial destruction"); 119 120 class ConstRowReference : public macros_internal::AbstractConstRowReference< 121 AndroidLogTable, RowNumber> { 122 public: ConstRowReference(const AndroidLogTable * table,uint32_t row_number)123 ConstRowReference(const AndroidLogTable* table, uint32_t row_number) 124 : AbstractConstRowReference(table, row_number) {} 125 id()126 ColumnType::id::type id() const { 127 return table()->id()[row_number_]; 128 } type()129 ColumnType::type::type type() const { 130 return table()->type()[row_number_]; 131 } ts()132 ColumnType::ts::type ts() const { 133 return table()->ts()[row_number_]; 134 } utid()135 ColumnType::utid::type utid() const { 136 return table()->utid()[row_number_]; 137 } prio()138 ColumnType::prio::type prio() const { 139 return table()->prio()[row_number_]; 140 } tag()141 ColumnType::tag::type tag() const { 142 return table()->tag()[row_number_]; 143 } msg()144 ColumnType::msg::type msg() const { 145 return table()->msg()[row_number_]; 146 } 147 }; 148 static_assert(std::is_trivially_destructible_v<ConstRowReference>, 149 "Inheritance used without trivial destruction"); 150 class RowReference : public ConstRowReference { 151 public: RowReference(const AndroidLogTable * table,uint32_t row_number)152 RowReference(const AndroidLogTable* table, uint32_t row_number) 153 : ConstRowReference(table, row_number) {} 154 set_ts(ColumnType::ts::non_optional_type v)155 void set_ts( 156 ColumnType::ts::non_optional_type v) { 157 return mutable_table()->mutable_ts()->Set(row_number_, v); 158 } set_utid(ColumnType::utid::non_optional_type v)159 void set_utid( 160 ColumnType::utid::non_optional_type v) { 161 return mutable_table()->mutable_utid()->Set(row_number_, v); 162 } set_prio(ColumnType::prio::non_optional_type v)163 void set_prio( 164 ColumnType::prio::non_optional_type v) { 165 return mutable_table()->mutable_prio()->Set(row_number_, v); 166 } set_tag(ColumnType::tag::non_optional_type v)167 void set_tag( 168 ColumnType::tag::non_optional_type v) { 169 return mutable_table()->mutable_tag()->Set(row_number_, v); 170 } set_msg(ColumnType::msg::non_optional_type v)171 void set_msg( 172 ColumnType::msg::non_optional_type v) { 173 return mutable_table()->mutable_msg()->Set(row_number_, v); 174 } 175 176 private: mutable_table()177 AndroidLogTable* mutable_table() const { 178 return const_cast<AndroidLogTable*>(table()); 179 } 180 }; 181 static_assert(std::is_trivially_destructible_v<RowReference>, 182 "Inheritance used without trivial destruction"); 183 184 class ConstIterator; 185 class ConstIterator : public macros_internal::AbstractConstIterator< 186 ConstIterator, AndroidLogTable, RowNumber, ConstRowReference> { 187 public: id()188 ColumnType::id::type id() const { 189 const auto& col = table()->id(); 190 return col.GetAtIdx( 191 iterator_.StorageIndexForColumn(col.index_in_table())); 192 } type()193 ColumnType::type::type type() const { 194 const auto& col = table()->type(); 195 return col.GetAtIdx( 196 iterator_.StorageIndexForColumn(col.index_in_table())); 197 } ts()198 ColumnType::ts::type ts() const { 199 const auto& col = table()->ts(); 200 return col.GetAtIdx( 201 iterator_.StorageIndexForColumn(col.index_in_table())); 202 } utid()203 ColumnType::utid::type utid() const { 204 const auto& col = table()->utid(); 205 return col.GetAtIdx( 206 iterator_.StorageIndexForColumn(col.index_in_table())); 207 } prio()208 ColumnType::prio::type prio() const { 209 const auto& col = table()->prio(); 210 return col.GetAtIdx( 211 iterator_.StorageIndexForColumn(col.index_in_table())); 212 } tag()213 ColumnType::tag::type tag() const { 214 const auto& col = table()->tag(); 215 return col.GetAtIdx( 216 iterator_.StorageIndexForColumn(col.index_in_table())); 217 } msg()218 ColumnType::msg::type msg() const { 219 const auto& col = table()->msg(); 220 return col.GetAtIdx( 221 iterator_.StorageIndexForColumn(col.index_in_table())); 222 } 223 224 protected: ConstIterator(const AndroidLogTable * table,Table::Iterator iterator)225 explicit ConstIterator(const AndroidLogTable* table, 226 Table::Iterator iterator) 227 : AbstractConstIterator(table, std::move(iterator)) {} 228 CurrentRowNumber()229 uint32_t CurrentRowNumber() const { 230 return iterator_.StorageIndexForLastOverlay(); 231 } 232 233 private: 234 friend class AndroidLogTable; 235 friend class macros_internal::AbstractConstIterator< 236 ConstIterator, AndroidLogTable, RowNumber, ConstRowReference>; 237 }; 238 class Iterator : public ConstIterator { 239 public: row_reference()240 RowReference row_reference() const { 241 return {const_cast<AndroidLogTable*>(table()), CurrentRowNumber()}; 242 } 243 244 private: 245 friend class AndroidLogTable; 246 Iterator(AndroidLogTable * table,Table::Iterator iterator)247 explicit Iterator(AndroidLogTable* table, Table::Iterator iterator) 248 : ConstIterator(table, std::move(iterator)) {} 249 }; 250 251 struct IdAndRow { 252 Id id; 253 uint32_t row; 254 RowReference row_reference; 255 RowNumber row_number; 256 }; 257 GetColumns(AndroidLogTable * self,const macros_internal::MacroTable * parent)258 static std::vector<ColumnLegacy> GetColumns( 259 AndroidLogTable* self, 260 const macros_internal::MacroTable* parent) { 261 std::vector<ColumnLegacy> columns = 262 CopyColumnsFromParentOrAddRootColumns(self, parent); 263 uint32_t olay_idx = OverlayCount(parent); 264 AddColumnToVector(columns, "ts", &self->ts_, ColumnFlag::ts, 265 static_cast<uint32_t>(columns.size()), olay_idx); 266 AddColumnToVector(columns, "utid", &self->utid_, ColumnFlag::utid, 267 static_cast<uint32_t>(columns.size()), olay_idx); 268 AddColumnToVector(columns, "prio", &self->prio_, ColumnFlag::prio, 269 static_cast<uint32_t>(columns.size()), olay_idx); 270 AddColumnToVector(columns, "tag", &self->tag_, ColumnFlag::tag, 271 static_cast<uint32_t>(columns.size()), olay_idx); 272 AddColumnToVector(columns, "msg", &self->msg_, ColumnFlag::msg, 273 static_cast<uint32_t>(columns.size()), olay_idx); 274 return columns; 275 } 276 AndroidLogTable(StringPool * pool)277 PERFETTO_NO_INLINE explicit AndroidLogTable(StringPool* pool) 278 : macros_internal::MacroTable( 279 pool, 280 GetColumns(this, nullptr), 281 nullptr), 282 ts_(ColumnStorage<ColumnType::ts::stored_type>::Create<false>()), 283 utid_(ColumnStorage<ColumnType::utid::stored_type>::Create<false>()), 284 prio_(ColumnStorage<ColumnType::prio::stored_type>::Create<false>()), 285 tag_(ColumnStorage<ColumnType::tag::stored_type>::Create<false>()), 286 msg_(ColumnStorage<ColumnType::msg::stored_type>::Create<false>()) 287 , 288 id_storage_layer_(new column::IdStorage()), 289 type_storage_layer_( 290 new column::StringStorage(string_pool(), &type_.vector())), 291 ts_storage_layer_( 292 new column::NumericStorage<ColumnType::ts::non_optional_stored_type>( 293 &ts_.vector(), 294 ColumnTypeHelper<ColumnType::ts::stored_type>::ToColumnType(), 295 false)), 296 utid_storage_layer_( 297 new column::NumericStorage<ColumnType::utid::non_optional_stored_type>( 298 &utid_.vector(), 299 ColumnTypeHelper<ColumnType::utid::stored_type>::ToColumnType(), 300 false)), 301 prio_storage_layer_( 302 new column::NumericStorage<ColumnType::prio::non_optional_stored_type>( 303 &prio_.vector(), 304 ColumnTypeHelper<ColumnType::prio::stored_type>::ToColumnType(), 305 false)), 306 tag_storage_layer_( 307 new column::StringStorage(string_pool(), &tag_.vector())), 308 msg_storage_layer_( 309 new column::StringStorage(string_pool(), &msg_.vector())) 310 { 311 static_assert( 312 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::ts::stored_type>( 313 ColumnFlag::ts), 314 "Column type and flag combination is not valid"); 315 static_assert( 316 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::utid::stored_type>( 317 ColumnFlag::utid), 318 "Column type and flag combination is not valid"); 319 static_assert( 320 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::prio::stored_type>( 321 ColumnFlag::prio), 322 "Column type and flag combination is not valid"); 323 static_assert( 324 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::tag::stored_type>( 325 ColumnFlag::tag), 326 "Column type and flag combination is not valid"); 327 static_assert( 328 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::msg::stored_type>( 329 ColumnFlag::msg), 330 "Column type and flag combination is not valid"); 331 OnConstructionCompletedRegularConstructor( 332 {id_storage_layer_,type_storage_layer_,ts_storage_layer_,utid_storage_layer_,prio_storage_layer_,tag_storage_layer_,msg_storage_layer_}, 333 {{},{},{},{},{},{},{}}); 334 } 335 ~AndroidLogTable() override; 336 Name()337 static const char* Name() { return "__intrinsic_android_logs"; } 338 ComputeStaticSchema()339 static Table::Schema ComputeStaticSchema() { 340 Table::Schema schema; 341 schema.columns.emplace_back(Table::Schema::Column{ 342 "id", SqlValue::Type::kLong, true, true, false, false}); 343 schema.columns.emplace_back(Table::Schema::Column{ 344 "type", SqlValue::Type::kString, false, false, false, false}); 345 schema.columns.emplace_back(Table::Schema::Column{ 346 "ts", ColumnType::ts::SqlValueType(), false, 347 false, 348 false, 349 false}); 350 schema.columns.emplace_back(Table::Schema::Column{ 351 "utid", ColumnType::utid::SqlValueType(), false, 352 false, 353 false, 354 false}); 355 schema.columns.emplace_back(Table::Schema::Column{ 356 "prio", ColumnType::prio::SqlValueType(), false, 357 false, 358 false, 359 false}); 360 schema.columns.emplace_back(Table::Schema::Column{ 361 "tag", ColumnType::tag::SqlValueType(), false, 362 false, 363 false, 364 false}); 365 schema.columns.emplace_back(Table::Schema::Column{ 366 "msg", ColumnType::msg::SqlValueType(), false, 367 false, 368 false, 369 false}); 370 return schema; 371 } 372 IterateRows()373 ConstIterator IterateRows() const { 374 return ConstIterator(this, Table::IterateRows()); 375 } 376 IterateRows()377 Iterator IterateRows() { return Iterator(this, Table::IterateRows()); } 378 FilterToIterator(const Query & q)379 ConstIterator FilterToIterator(const Query& q) const { 380 return ConstIterator(this, QueryToIterator(q)); 381 } 382 FilterToIterator(const Query & q)383 Iterator FilterToIterator(const Query& q) { 384 return Iterator(this, QueryToIterator(q)); 385 } 386 ShrinkToFit()387 void ShrinkToFit() { 388 type_.ShrinkToFit(); 389 ts_.ShrinkToFit(); 390 utid_.ShrinkToFit(); 391 prio_.ShrinkToFit(); 392 tag_.ShrinkToFit(); 393 msg_.ShrinkToFit(); 394 } 395 396 ConstRowReference operator[](uint32_t r) const { 397 return ConstRowReference(this, r); 398 } 399 RowReference operator[](uint32_t r) { return RowReference(this, r); } 400 ConstRowReference operator[](RowNumber r) const { 401 return ConstRowReference(this, r.row_number()); 402 } 403 RowReference operator[](RowNumber r) { 404 return RowReference(this, r.row_number()); 405 } 406 FindById(Id find_id)407 std::optional<ConstRowReference> FindById(Id find_id) const { 408 std::optional<uint32_t> row = id().IndexOf(find_id); 409 return row ? std::make_optional(ConstRowReference(this, *row)) 410 : std::nullopt; 411 } 412 FindById(Id find_id)413 std::optional<RowReference> FindById(Id find_id) { 414 std::optional<uint32_t> row = id().IndexOf(find_id); 415 return row ? std::make_optional(RowReference(this, *row)) : std::nullopt; 416 } 417 Insert(const Row & row)418 IdAndRow Insert(const Row& row) { 419 uint32_t row_number = row_count(); 420 Id id = Id{row_number}; 421 type_.Append(string_pool()->InternString(row.type())); 422 mutable_ts()->Append(row.ts); 423 mutable_utid()->Append(row.utid); 424 mutable_prio()->Append(row.prio); 425 mutable_tag()->Append(row.tag); 426 mutable_msg()->Append(row.msg); 427 UpdateSelfOverlayAfterInsert(); 428 return IdAndRow{id, row_number, RowReference(this, row_number), 429 RowNumber(row_number)}; 430 } 431 432 433 id()434 const IdColumn<AndroidLogTable::Id>& id() const { 435 return static_cast<const ColumnType::id&>(columns()[ColumnIndex::id]); 436 } type()437 const TypedColumn<StringPool::Id>& type() const { 438 return static_cast<const ColumnType::type&>(columns()[ColumnIndex::type]); 439 } ts()440 const TypedColumn<int64_t>& ts() const { 441 return static_cast<const ColumnType::ts&>(columns()[ColumnIndex::ts]); 442 } utid()443 const TypedColumn<uint32_t>& utid() const { 444 return static_cast<const ColumnType::utid&>(columns()[ColumnIndex::utid]); 445 } prio()446 const TypedColumn<uint32_t>& prio() const { 447 return static_cast<const ColumnType::prio&>(columns()[ColumnIndex::prio]); 448 } tag()449 const TypedColumn<std::optional<StringPool::Id>>& tag() const { 450 return static_cast<const ColumnType::tag&>(columns()[ColumnIndex::tag]); 451 } msg()452 const TypedColumn<StringPool::Id>& msg() const { 453 return static_cast<const ColumnType::msg&>(columns()[ColumnIndex::msg]); 454 } 455 mutable_ts()456 TypedColumn<int64_t>* mutable_ts() { 457 return static_cast<ColumnType::ts*>( 458 GetColumn(ColumnIndex::ts)); 459 } mutable_utid()460 TypedColumn<uint32_t>* mutable_utid() { 461 return static_cast<ColumnType::utid*>( 462 GetColumn(ColumnIndex::utid)); 463 } mutable_prio()464 TypedColumn<uint32_t>* mutable_prio() { 465 return static_cast<ColumnType::prio*>( 466 GetColumn(ColumnIndex::prio)); 467 } mutable_tag()468 TypedColumn<std::optional<StringPool::Id>>* mutable_tag() { 469 return static_cast<ColumnType::tag*>( 470 GetColumn(ColumnIndex::tag)); 471 } mutable_msg()472 TypedColumn<StringPool::Id>* mutable_msg() { 473 return static_cast<ColumnType::msg*>( 474 GetColumn(ColumnIndex::msg)); 475 } 476 477 private: 478 479 480 ColumnStorage<ColumnType::ts::stored_type> ts_; 481 ColumnStorage<ColumnType::utid::stored_type> utid_; 482 ColumnStorage<ColumnType::prio::stored_type> prio_; 483 ColumnStorage<ColumnType::tag::stored_type> tag_; 484 ColumnStorage<ColumnType::msg::stored_type> msg_; 485 486 RefPtr<column::StorageLayer> id_storage_layer_; 487 RefPtr<column::StorageLayer> type_storage_layer_; 488 RefPtr<column::StorageLayer> ts_storage_layer_; 489 RefPtr<column::StorageLayer> utid_storage_layer_; 490 RefPtr<column::StorageLayer> prio_storage_layer_; 491 RefPtr<column::StorageLayer> tag_storage_layer_; 492 RefPtr<column::StorageLayer> msg_storage_layer_; 493 494 495 }; 496 497 498 class AndroidDumpstateTable : public macros_internal::MacroTable { 499 public: 500 static constexpr uint32_t kColumnCount = 5; 501 502 struct Id : public BaseId { 503 Id() = default; IdId504 explicit constexpr Id(uint32_t v) : BaseId(v) {} 505 }; 506 static_assert(std::is_trivially_destructible_v<Id>, 507 "Inheritance used without trivial destruction"); 508 509 struct ColumnIndex { 510 static constexpr uint32_t id = 0; 511 static constexpr uint32_t type = 1; 512 static constexpr uint32_t section = 2; 513 static constexpr uint32_t service = 3; 514 static constexpr uint32_t line = 4; 515 }; 516 struct ColumnType { 517 using id = IdColumn<AndroidDumpstateTable::Id>; 518 using type = TypedColumn<StringPool::Id>; 519 using section = TypedColumn<std::optional<StringPool::Id>>; 520 using service = TypedColumn<std::optional<StringPool::Id>>; 521 using line = TypedColumn<StringPool::Id>; 522 }; 523 struct Row : public macros_internal::RootParentTable::Row { 524 Row(std::optional<StringPool::Id> in_section = {}, 525 std::optional<StringPool::Id> in_service = {}, 526 StringPool::Id in_line = {}, 527 std::nullptr_t = nullptr) RowRow528 : macros_internal::RootParentTable::Row(), 529 section(in_section), 530 service(in_service), 531 line(in_line) { 532 type_ = "android_dumpstate"; 533 } 534 std::optional<StringPool::Id> section; 535 std::optional<StringPool::Id> service; 536 StringPool::Id line; 537 538 bool operator==(const AndroidDumpstateTable::Row& other) const { 539 return type() == other.type() && ColumnType::section::Equals(section, other.section) && 540 ColumnType::service::Equals(service, other.service) && 541 ColumnType::line::Equals(line, other.line); 542 } 543 }; 544 struct ColumnFlag { 545 static constexpr uint32_t section = ColumnType::section::default_flags(); 546 static constexpr uint32_t service = ColumnType::service::default_flags(); 547 static constexpr uint32_t line = ColumnType::line::default_flags(); 548 }; 549 550 class RowNumber; 551 class ConstRowReference; 552 class RowReference; 553 554 class RowNumber : public macros_internal::AbstractRowNumber< 555 AndroidDumpstateTable, ConstRowReference, RowReference> { 556 public: RowNumber(uint32_t row_number)557 explicit RowNumber(uint32_t row_number) 558 : AbstractRowNumber(row_number) {} 559 }; 560 static_assert(std::is_trivially_destructible_v<RowNumber>, 561 "Inheritance used without trivial destruction"); 562 563 class ConstRowReference : public macros_internal::AbstractConstRowReference< 564 AndroidDumpstateTable, RowNumber> { 565 public: ConstRowReference(const AndroidDumpstateTable * table,uint32_t row_number)566 ConstRowReference(const AndroidDumpstateTable* table, uint32_t row_number) 567 : AbstractConstRowReference(table, row_number) {} 568 id()569 ColumnType::id::type id() const { 570 return table()->id()[row_number_]; 571 } type()572 ColumnType::type::type type() const { 573 return table()->type()[row_number_]; 574 } section()575 ColumnType::section::type section() const { 576 return table()->section()[row_number_]; 577 } service()578 ColumnType::service::type service() const { 579 return table()->service()[row_number_]; 580 } line()581 ColumnType::line::type line() const { 582 return table()->line()[row_number_]; 583 } 584 }; 585 static_assert(std::is_trivially_destructible_v<ConstRowReference>, 586 "Inheritance used without trivial destruction"); 587 class RowReference : public ConstRowReference { 588 public: RowReference(const AndroidDumpstateTable * table,uint32_t row_number)589 RowReference(const AndroidDumpstateTable* table, uint32_t row_number) 590 : ConstRowReference(table, row_number) {} 591 set_section(ColumnType::section::non_optional_type v)592 void set_section( 593 ColumnType::section::non_optional_type v) { 594 return mutable_table()->mutable_section()->Set(row_number_, v); 595 } set_service(ColumnType::service::non_optional_type v)596 void set_service( 597 ColumnType::service::non_optional_type v) { 598 return mutable_table()->mutable_service()->Set(row_number_, v); 599 } set_line(ColumnType::line::non_optional_type v)600 void set_line( 601 ColumnType::line::non_optional_type v) { 602 return mutable_table()->mutable_line()->Set(row_number_, v); 603 } 604 605 private: mutable_table()606 AndroidDumpstateTable* mutable_table() const { 607 return const_cast<AndroidDumpstateTable*>(table()); 608 } 609 }; 610 static_assert(std::is_trivially_destructible_v<RowReference>, 611 "Inheritance used without trivial destruction"); 612 613 class ConstIterator; 614 class ConstIterator : public macros_internal::AbstractConstIterator< 615 ConstIterator, AndroidDumpstateTable, RowNumber, ConstRowReference> { 616 public: id()617 ColumnType::id::type id() const { 618 const auto& col = table()->id(); 619 return col.GetAtIdx( 620 iterator_.StorageIndexForColumn(col.index_in_table())); 621 } type()622 ColumnType::type::type type() const { 623 const auto& col = table()->type(); 624 return col.GetAtIdx( 625 iterator_.StorageIndexForColumn(col.index_in_table())); 626 } section()627 ColumnType::section::type section() const { 628 const auto& col = table()->section(); 629 return col.GetAtIdx( 630 iterator_.StorageIndexForColumn(col.index_in_table())); 631 } service()632 ColumnType::service::type service() const { 633 const auto& col = table()->service(); 634 return col.GetAtIdx( 635 iterator_.StorageIndexForColumn(col.index_in_table())); 636 } line()637 ColumnType::line::type line() const { 638 const auto& col = table()->line(); 639 return col.GetAtIdx( 640 iterator_.StorageIndexForColumn(col.index_in_table())); 641 } 642 643 protected: ConstIterator(const AndroidDumpstateTable * table,Table::Iterator iterator)644 explicit ConstIterator(const AndroidDumpstateTable* table, 645 Table::Iterator iterator) 646 : AbstractConstIterator(table, std::move(iterator)) {} 647 CurrentRowNumber()648 uint32_t CurrentRowNumber() const { 649 return iterator_.StorageIndexForLastOverlay(); 650 } 651 652 private: 653 friend class AndroidDumpstateTable; 654 friend class macros_internal::AbstractConstIterator< 655 ConstIterator, AndroidDumpstateTable, RowNumber, ConstRowReference>; 656 }; 657 class Iterator : public ConstIterator { 658 public: row_reference()659 RowReference row_reference() const { 660 return {const_cast<AndroidDumpstateTable*>(table()), CurrentRowNumber()}; 661 } 662 663 private: 664 friend class AndroidDumpstateTable; 665 Iterator(AndroidDumpstateTable * table,Table::Iterator iterator)666 explicit Iterator(AndroidDumpstateTable* table, Table::Iterator iterator) 667 : ConstIterator(table, std::move(iterator)) {} 668 }; 669 670 struct IdAndRow { 671 Id id; 672 uint32_t row; 673 RowReference row_reference; 674 RowNumber row_number; 675 }; 676 GetColumns(AndroidDumpstateTable * self,const macros_internal::MacroTable * parent)677 static std::vector<ColumnLegacy> GetColumns( 678 AndroidDumpstateTable* self, 679 const macros_internal::MacroTable* parent) { 680 std::vector<ColumnLegacy> columns = 681 CopyColumnsFromParentOrAddRootColumns(self, parent); 682 uint32_t olay_idx = OverlayCount(parent); 683 AddColumnToVector(columns, "section", &self->section_, ColumnFlag::section, 684 static_cast<uint32_t>(columns.size()), olay_idx); 685 AddColumnToVector(columns, "service", &self->service_, ColumnFlag::service, 686 static_cast<uint32_t>(columns.size()), olay_idx); 687 AddColumnToVector(columns, "line", &self->line_, ColumnFlag::line, 688 static_cast<uint32_t>(columns.size()), olay_idx); 689 return columns; 690 } 691 AndroidDumpstateTable(StringPool * pool)692 PERFETTO_NO_INLINE explicit AndroidDumpstateTable(StringPool* pool) 693 : macros_internal::MacroTable( 694 pool, 695 GetColumns(this, nullptr), 696 nullptr), 697 section_(ColumnStorage<ColumnType::section::stored_type>::Create<false>()), 698 service_(ColumnStorage<ColumnType::service::stored_type>::Create<false>()), 699 line_(ColumnStorage<ColumnType::line::stored_type>::Create<false>()) 700 , 701 id_storage_layer_(new column::IdStorage()), 702 type_storage_layer_( 703 new column::StringStorage(string_pool(), &type_.vector())), 704 section_storage_layer_( 705 new column::StringStorage(string_pool(), §ion_.vector())), 706 service_storage_layer_( 707 new column::StringStorage(string_pool(), &service_.vector())), 708 line_storage_layer_( 709 new column::StringStorage(string_pool(), &line_.vector())) 710 { 711 static_assert( 712 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::section::stored_type>( 713 ColumnFlag::section), 714 "Column type and flag combination is not valid"); 715 static_assert( 716 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::service::stored_type>( 717 ColumnFlag::service), 718 "Column type and flag combination is not valid"); 719 static_assert( 720 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::line::stored_type>( 721 ColumnFlag::line), 722 "Column type and flag combination is not valid"); 723 OnConstructionCompletedRegularConstructor( 724 {id_storage_layer_,type_storage_layer_,section_storage_layer_,service_storage_layer_,line_storage_layer_}, 725 {{},{},{},{},{}}); 726 } 727 ~AndroidDumpstateTable() override; 728 Name()729 static const char* Name() { return "android_dumpstate"; } 730 ComputeStaticSchema()731 static Table::Schema ComputeStaticSchema() { 732 Table::Schema schema; 733 schema.columns.emplace_back(Table::Schema::Column{ 734 "id", SqlValue::Type::kLong, true, true, false, false}); 735 schema.columns.emplace_back(Table::Schema::Column{ 736 "type", SqlValue::Type::kString, false, false, false, false}); 737 schema.columns.emplace_back(Table::Schema::Column{ 738 "section", ColumnType::section::SqlValueType(), false, 739 false, 740 false, 741 false}); 742 schema.columns.emplace_back(Table::Schema::Column{ 743 "service", ColumnType::service::SqlValueType(), false, 744 false, 745 false, 746 false}); 747 schema.columns.emplace_back(Table::Schema::Column{ 748 "line", ColumnType::line::SqlValueType(), false, 749 false, 750 false, 751 false}); 752 return schema; 753 } 754 IterateRows()755 ConstIterator IterateRows() const { 756 return ConstIterator(this, Table::IterateRows()); 757 } 758 IterateRows()759 Iterator IterateRows() { return Iterator(this, Table::IterateRows()); } 760 FilterToIterator(const Query & q)761 ConstIterator FilterToIterator(const Query& q) const { 762 return ConstIterator(this, QueryToIterator(q)); 763 } 764 FilterToIterator(const Query & q)765 Iterator FilterToIterator(const Query& q) { 766 return Iterator(this, QueryToIterator(q)); 767 } 768 ShrinkToFit()769 void ShrinkToFit() { 770 type_.ShrinkToFit(); 771 section_.ShrinkToFit(); 772 service_.ShrinkToFit(); 773 line_.ShrinkToFit(); 774 } 775 776 ConstRowReference operator[](uint32_t r) const { 777 return ConstRowReference(this, r); 778 } 779 RowReference operator[](uint32_t r) { return RowReference(this, r); } 780 ConstRowReference operator[](RowNumber r) const { 781 return ConstRowReference(this, r.row_number()); 782 } 783 RowReference operator[](RowNumber r) { 784 return RowReference(this, r.row_number()); 785 } 786 FindById(Id find_id)787 std::optional<ConstRowReference> FindById(Id find_id) const { 788 std::optional<uint32_t> row = id().IndexOf(find_id); 789 return row ? std::make_optional(ConstRowReference(this, *row)) 790 : std::nullopt; 791 } 792 FindById(Id find_id)793 std::optional<RowReference> FindById(Id find_id) { 794 std::optional<uint32_t> row = id().IndexOf(find_id); 795 return row ? std::make_optional(RowReference(this, *row)) : std::nullopt; 796 } 797 Insert(const Row & row)798 IdAndRow Insert(const Row& row) { 799 uint32_t row_number = row_count(); 800 Id id = Id{row_number}; 801 type_.Append(string_pool()->InternString(row.type())); 802 mutable_section()->Append(row.section); 803 mutable_service()->Append(row.service); 804 mutable_line()->Append(row.line); 805 UpdateSelfOverlayAfterInsert(); 806 return IdAndRow{id, row_number, RowReference(this, row_number), 807 RowNumber(row_number)}; 808 } 809 810 811 id()812 const IdColumn<AndroidDumpstateTable::Id>& id() const { 813 return static_cast<const ColumnType::id&>(columns()[ColumnIndex::id]); 814 } type()815 const TypedColumn<StringPool::Id>& type() const { 816 return static_cast<const ColumnType::type&>(columns()[ColumnIndex::type]); 817 } section()818 const TypedColumn<std::optional<StringPool::Id>>& section() const { 819 return static_cast<const ColumnType::section&>(columns()[ColumnIndex::section]); 820 } service()821 const TypedColumn<std::optional<StringPool::Id>>& service() const { 822 return static_cast<const ColumnType::service&>(columns()[ColumnIndex::service]); 823 } line()824 const TypedColumn<StringPool::Id>& line() const { 825 return static_cast<const ColumnType::line&>(columns()[ColumnIndex::line]); 826 } 827 mutable_section()828 TypedColumn<std::optional<StringPool::Id>>* mutable_section() { 829 return static_cast<ColumnType::section*>( 830 GetColumn(ColumnIndex::section)); 831 } mutable_service()832 TypedColumn<std::optional<StringPool::Id>>* mutable_service() { 833 return static_cast<ColumnType::service*>( 834 GetColumn(ColumnIndex::service)); 835 } mutable_line()836 TypedColumn<StringPool::Id>* mutable_line() { 837 return static_cast<ColumnType::line*>( 838 GetColumn(ColumnIndex::line)); 839 } 840 841 private: 842 843 844 ColumnStorage<ColumnType::section::stored_type> section_; 845 ColumnStorage<ColumnType::service::stored_type> service_; 846 ColumnStorage<ColumnType::line::stored_type> line_; 847 848 RefPtr<column::StorageLayer> id_storage_layer_; 849 RefPtr<column::StorageLayer> type_storage_layer_; 850 RefPtr<column::StorageLayer> section_storage_layer_; 851 RefPtr<column::StorageLayer> service_storage_layer_; 852 RefPtr<column::StorageLayer> line_storage_layer_; 853 854 855 }; 856 857 858 class AndroidGameInterventionListTable : public macros_internal::MacroTable { 859 public: 860 static constexpr uint32_t kColumnCount = 17; 861 862 struct Id : public BaseId { 863 Id() = default; IdId864 explicit constexpr Id(uint32_t v) : BaseId(v) {} 865 }; 866 static_assert(std::is_trivially_destructible_v<Id>, 867 "Inheritance used without trivial destruction"); 868 869 struct ColumnIndex { 870 static constexpr uint32_t id = 0; 871 static constexpr uint32_t type = 1; 872 static constexpr uint32_t package_name = 2; 873 static constexpr uint32_t uid = 3; 874 static constexpr uint32_t current_mode = 4; 875 static constexpr uint32_t standard_mode_supported = 5; 876 static constexpr uint32_t standard_mode_downscale = 6; 877 static constexpr uint32_t standard_mode_use_angle = 7; 878 static constexpr uint32_t standard_mode_fps = 8; 879 static constexpr uint32_t perf_mode_supported = 9; 880 static constexpr uint32_t perf_mode_downscale = 10; 881 static constexpr uint32_t perf_mode_use_angle = 11; 882 static constexpr uint32_t perf_mode_fps = 12; 883 static constexpr uint32_t battery_mode_supported = 13; 884 static constexpr uint32_t battery_mode_downscale = 14; 885 static constexpr uint32_t battery_mode_use_angle = 15; 886 static constexpr uint32_t battery_mode_fps = 16; 887 }; 888 struct ColumnType { 889 using id = IdColumn<AndroidGameInterventionListTable::Id>; 890 using type = TypedColumn<StringPool::Id>; 891 using package_name = TypedColumn<StringPool::Id>; 892 using uid = TypedColumn<int64_t>; 893 using current_mode = TypedColumn<int32_t>; 894 using standard_mode_supported = TypedColumn<int32_t>; 895 using standard_mode_downscale = TypedColumn<std::optional<double>>; 896 using standard_mode_use_angle = TypedColumn<std::optional<int32_t>>; 897 using standard_mode_fps = TypedColumn<std::optional<double>>; 898 using perf_mode_supported = TypedColumn<int32_t>; 899 using perf_mode_downscale = TypedColumn<std::optional<double>>; 900 using perf_mode_use_angle = TypedColumn<std::optional<int32_t>>; 901 using perf_mode_fps = TypedColumn<std::optional<double>>; 902 using battery_mode_supported = TypedColumn<int32_t>; 903 using battery_mode_downscale = TypedColumn<std::optional<double>>; 904 using battery_mode_use_angle = TypedColumn<std::optional<int32_t>>; 905 using battery_mode_fps = TypedColumn<std::optional<double>>; 906 }; 907 struct Row : public macros_internal::RootParentTable::Row { 908 Row(StringPool::Id in_package_name = {}, 909 int64_t in_uid = {}, 910 int32_t in_current_mode = {}, 911 int32_t in_standard_mode_supported = {}, 912 std::optional<double> in_standard_mode_downscale = {}, 913 std::optional<int32_t> in_standard_mode_use_angle = {}, 914 std::optional<double> in_standard_mode_fps = {}, 915 int32_t in_perf_mode_supported = {}, 916 std::optional<double> in_perf_mode_downscale = {}, 917 std::optional<int32_t> in_perf_mode_use_angle = {}, 918 std::optional<double> in_perf_mode_fps = {}, 919 int32_t in_battery_mode_supported = {}, 920 std::optional<double> in_battery_mode_downscale = {}, 921 std::optional<int32_t> in_battery_mode_use_angle = {}, 922 std::optional<double> in_battery_mode_fps = {}, 923 std::nullptr_t = nullptr) RowRow924 : macros_internal::RootParentTable::Row(), 925 package_name(in_package_name), 926 uid(in_uid), 927 current_mode(in_current_mode), 928 standard_mode_supported(in_standard_mode_supported), 929 standard_mode_downscale(in_standard_mode_downscale), 930 standard_mode_use_angle(in_standard_mode_use_angle), 931 standard_mode_fps(in_standard_mode_fps), 932 perf_mode_supported(in_perf_mode_supported), 933 perf_mode_downscale(in_perf_mode_downscale), 934 perf_mode_use_angle(in_perf_mode_use_angle), 935 perf_mode_fps(in_perf_mode_fps), 936 battery_mode_supported(in_battery_mode_supported), 937 battery_mode_downscale(in_battery_mode_downscale), 938 battery_mode_use_angle(in_battery_mode_use_angle), 939 battery_mode_fps(in_battery_mode_fps) { 940 type_ = "android_game_intervention_list"; 941 } 942 StringPool::Id package_name; 943 int64_t uid; 944 int32_t current_mode; 945 int32_t standard_mode_supported; 946 std::optional<double> standard_mode_downscale; 947 std::optional<int32_t> standard_mode_use_angle; 948 std::optional<double> standard_mode_fps; 949 int32_t perf_mode_supported; 950 std::optional<double> perf_mode_downscale; 951 std::optional<int32_t> perf_mode_use_angle; 952 std::optional<double> perf_mode_fps; 953 int32_t battery_mode_supported; 954 std::optional<double> battery_mode_downscale; 955 std::optional<int32_t> battery_mode_use_angle; 956 std::optional<double> battery_mode_fps; 957 958 bool operator==(const AndroidGameInterventionListTable::Row& other) const { 959 return type() == other.type() && ColumnType::package_name::Equals(package_name, other.package_name) && 960 ColumnType::uid::Equals(uid, other.uid) && 961 ColumnType::current_mode::Equals(current_mode, other.current_mode) && 962 ColumnType::standard_mode_supported::Equals(standard_mode_supported, other.standard_mode_supported) && 963 ColumnType::standard_mode_downscale::Equals(standard_mode_downscale, other.standard_mode_downscale) && 964 ColumnType::standard_mode_use_angle::Equals(standard_mode_use_angle, other.standard_mode_use_angle) && 965 ColumnType::standard_mode_fps::Equals(standard_mode_fps, other.standard_mode_fps) && 966 ColumnType::perf_mode_supported::Equals(perf_mode_supported, other.perf_mode_supported) && 967 ColumnType::perf_mode_downscale::Equals(perf_mode_downscale, other.perf_mode_downscale) && 968 ColumnType::perf_mode_use_angle::Equals(perf_mode_use_angle, other.perf_mode_use_angle) && 969 ColumnType::perf_mode_fps::Equals(perf_mode_fps, other.perf_mode_fps) && 970 ColumnType::battery_mode_supported::Equals(battery_mode_supported, other.battery_mode_supported) && 971 ColumnType::battery_mode_downscale::Equals(battery_mode_downscale, other.battery_mode_downscale) && 972 ColumnType::battery_mode_use_angle::Equals(battery_mode_use_angle, other.battery_mode_use_angle) && 973 ColumnType::battery_mode_fps::Equals(battery_mode_fps, other.battery_mode_fps); 974 } 975 }; 976 struct ColumnFlag { 977 static constexpr uint32_t package_name = ColumnType::package_name::default_flags(); 978 static constexpr uint32_t uid = ColumnType::uid::default_flags(); 979 static constexpr uint32_t current_mode = ColumnType::current_mode::default_flags(); 980 static constexpr uint32_t standard_mode_supported = ColumnType::standard_mode_supported::default_flags(); 981 static constexpr uint32_t standard_mode_downscale = ColumnType::standard_mode_downscale::default_flags(); 982 static constexpr uint32_t standard_mode_use_angle = ColumnType::standard_mode_use_angle::default_flags(); 983 static constexpr uint32_t standard_mode_fps = ColumnType::standard_mode_fps::default_flags(); 984 static constexpr uint32_t perf_mode_supported = ColumnType::perf_mode_supported::default_flags(); 985 static constexpr uint32_t perf_mode_downscale = ColumnType::perf_mode_downscale::default_flags(); 986 static constexpr uint32_t perf_mode_use_angle = ColumnType::perf_mode_use_angle::default_flags(); 987 static constexpr uint32_t perf_mode_fps = ColumnType::perf_mode_fps::default_flags(); 988 static constexpr uint32_t battery_mode_supported = ColumnType::battery_mode_supported::default_flags(); 989 static constexpr uint32_t battery_mode_downscale = ColumnType::battery_mode_downscale::default_flags(); 990 static constexpr uint32_t battery_mode_use_angle = ColumnType::battery_mode_use_angle::default_flags(); 991 static constexpr uint32_t battery_mode_fps = ColumnType::battery_mode_fps::default_flags(); 992 }; 993 994 class RowNumber; 995 class ConstRowReference; 996 class RowReference; 997 998 class RowNumber : public macros_internal::AbstractRowNumber< 999 AndroidGameInterventionListTable, ConstRowReference, RowReference> { 1000 public: RowNumber(uint32_t row_number)1001 explicit RowNumber(uint32_t row_number) 1002 : AbstractRowNumber(row_number) {} 1003 }; 1004 static_assert(std::is_trivially_destructible_v<RowNumber>, 1005 "Inheritance used without trivial destruction"); 1006 1007 class ConstRowReference : public macros_internal::AbstractConstRowReference< 1008 AndroidGameInterventionListTable, RowNumber> { 1009 public: ConstRowReference(const AndroidGameInterventionListTable * table,uint32_t row_number)1010 ConstRowReference(const AndroidGameInterventionListTable* table, uint32_t row_number) 1011 : AbstractConstRowReference(table, row_number) {} 1012 id()1013 ColumnType::id::type id() const { 1014 return table()->id()[row_number_]; 1015 } type()1016 ColumnType::type::type type() const { 1017 return table()->type()[row_number_]; 1018 } package_name()1019 ColumnType::package_name::type package_name() const { 1020 return table()->package_name()[row_number_]; 1021 } uid()1022 ColumnType::uid::type uid() const { 1023 return table()->uid()[row_number_]; 1024 } current_mode()1025 ColumnType::current_mode::type current_mode() const { 1026 return table()->current_mode()[row_number_]; 1027 } standard_mode_supported()1028 ColumnType::standard_mode_supported::type standard_mode_supported() const { 1029 return table()->standard_mode_supported()[row_number_]; 1030 } standard_mode_downscale()1031 ColumnType::standard_mode_downscale::type standard_mode_downscale() const { 1032 return table()->standard_mode_downscale()[row_number_]; 1033 } standard_mode_use_angle()1034 ColumnType::standard_mode_use_angle::type standard_mode_use_angle() const { 1035 return table()->standard_mode_use_angle()[row_number_]; 1036 } standard_mode_fps()1037 ColumnType::standard_mode_fps::type standard_mode_fps() const { 1038 return table()->standard_mode_fps()[row_number_]; 1039 } perf_mode_supported()1040 ColumnType::perf_mode_supported::type perf_mode_supported() const { 1041 return table()->perf_mode_supported()[row_number_]; 1042 } perf_mode_downscale()1043 ColumnType::perf_mode_downscale::type perf_mode_downscale() const { 1044 return table()->perf_mode_downscale()[row_number_]; 1045 } perf_mode_use_angle()1046 ColumnType::perf_mode_use_angle::type perf_mode_use_angle() const { 1047 return table()->perf_mode_use_angle()[row_number_]; 1048 } perf_mode_fps()1049 ColumnType::perf_mode_fps::type perf_mode_fps() const { 1050 return table()->perf_mode_fps()[row_number_]; 1051 } battery_mode_supported()1052 ColumnType::battery_mode_supported::type battery_mode_supported() const { 1053 return table()->battery_mode_supported()[row_number_]; 1054 } battery_mode_downscale()1055 ColumnType::battery_mode_downscale::type battery_mode_downscale() const { 1056 return table()->battery_mode_downscale()[row_number_]; 1057 } battery_mode_use_angle()1058 ColumnType::battery_mode_use_angle::type battery_mode_use_angle() const { 1059 return table()->battery_mode_use_angle()[row_number_]; 1060 } battery_mode_fps()1061 ColumnType::battery_mode_fps::type battery_mode_fps() const { 1062 return table()->battery_mode_fps()[row_number_]; 1063 } 1064 }; 1065 static_assert(std::is_trivially_destructible_v<ConstRowReference>, 1066 "Inheritance used without trivial destruction"); 1067 class RowReference : public ConstRowReference { 1068 public: RowReference(const AndroidGameInterventionListTable * table,uint32_t row_number)1069 RowReference(const AndroidGameInterventionListTable* table, uint32_t row_number) 1070 : ConstRowReference(table, row_number) {} 1071 set_package_name(ColumnType::package_name::non_optional_type v)1072 void set_package_name( 1073 ColumnType::package_name::non_optional_type v) { 1074 return mutable_table()->mutable_package_name()->Set(row_number_, v); 1075 } set_uid(ColumnType::uid::non_optional_type v)1076 void set_uid( 1077 ColumnType::uid::non_optional_type v) { 1078 return mutable_table()->mutable_uid()->Set(row_number_, v); 1079 } set_current_mode(ColumnType::current_mode::non_optional_type v)1080 void set_current_mode( 1081 ColumnType::current_mode::non_optional_type v) { 1082 return mutable_table()->mutable_current_mode()->Set(row_number_, v); 1083 } set_standard_mode_supported(ColumnType::standard_mode_supported::non_optional_type v)1084 void set_standard_mode_supported( 1085 ColumnType::standard_mode_supported::non_optional_type v) { 1086 return mutable_table()->mutable_standard_mode_supported()->Set(row_number_, v); 1087 } set_standard_mode_downscale(ColumnType::standard_mode_downscale::non_optional_type v)1088 void set_standard_mode_downscale( 1089 ColumnType::standard_mode_downscale::non_optional_type v) { 1090 return mutable_table()->mutable_standard_mode_downscale()->Set(row_number_, v); 1091 } set_standard_mode_use_angle(ColumnType::standard_mode_use_angle::non_optional_type v)1092 void set_standard_mode_use_angle( 1093 ColumnType::standard_mode_use_angle::non_optional_type v) { 1094 return mutable_table()->mutable_standard_mode_use_angle()->Set(row_number_, v); 1095 } set_standard_mode_fps(ColumnType::standard_mode_fps::non_optional_type v)1096 void set_standard_mode_fps( 1097 ColumnType::standard_mode_fps::non_optional_type v) { 1098 return mutable_table()->mutable_standard_mode_fps()->Set(row_number_, v); 1099 } set_perf_mode_supported(ColumnType::perf_mode_supported::non_optional_type v)1100 void set_perf_mode_supported( 1101 ColumnType::perf_mode_supported::non_optional_type v) { 1102 return mutable_table()->mutable_perf_mode_supported()->Set(row_number_, v); 1103 } set_perf_mode_downscale(ColumnType::perf_mode_downscale::non_optional_type v)1104 void set_perf_mode_downscale( 1105 ColumnType::perf_mode_downscale::non_optional_type v) { 1106 return mutable_table()->mutable_perf_mode_downscale()->Set(row_number_, v); 1107 } set_perf_mode_use_angle(ColumnType::perf_mode_use_angle::non_optional_type v)1108 void set_perf_mode_use_angle( 1109 ColumnType::perf_mode_use_angle::non_optional_type v) { 1110 return mutable_table()->mutable_perf_mode_use_angle()->Set(row_number_, v); 1111 } set_perf_mode_fps(ColumnType::perf_mode_fps::non_optional_type v)1112 void set_perf_mode_fps( 1113 ColumnType::perf_mode_fps::non_optional_type v) { 1114 return mutable_table()->mutable_perf_mode_fps()->Set(row_number_, v); 1115 } set_battery_mode_supported(ColumnType::battery_mode_supported::non_optional_type v)1116 void set_battery_mode_supported( 1117 ColumnType::battery_mode_supported::non_optional_type v) { 1118 return mutable_table()->mutable_battery_mode_supported()->Set(row_number_, v); 1119 } set_battery_mode_downscale(ColumnType::battery_mode_downscale::non_optional_type v)1120 void set_battery_mode_downscale( 1121 ColumnType::battery_mode_downscale::non_optional_type v) { 1122 return mutable_table()->mutable_battery_mode_downscale()->Set(row_number_, v); 1123 } set_battery_mode_use_angle(ColumnType::battery_mode_use_angle::non_optional_type v)1124 void set_battery_mode_use_angle( 1125 ColumnType::battery_mode_use_angle::non_optional_type v) { 1126 return mutable_table()->mutable_battery_mode_use_angle()->Set(row_number_, v); 1127 } set_battery_mode_fps(ColumnType::battery_mode_fps::non_optional_type v)1128 void set_battery_mode_fps( 1129 ColumnType::battery_mode_fps::non_optional_type v) { 1130 return mutable_table()->mutable_battery_mode_fps()->Set(row_number_, v); 1131 } 1132 1133 private: mutable_table()1134 AndroidGameInterventionListTable* mutable_table() const { 1135 return const_cast<AndroidGameInterventionListTable*>(table()); 1136 } 1137 }; 1138 static_assert(std::is_trivially_destructible_v<RowReference>, 1139 "Inheritance used without trivial destruction"); 1140 1141 class ConstIterator; 1142 class ConstIterator : public macros_internal::AbstractConstIterator< 1143 ConstIterator, AndroidGameInterventionListTable, RowNumber, ConstRowReference> { 1144 public: id()1145 ColumnType::id::type id() const { 1146 const auto& col = table()->id(); 1147 return col.GetAtIdx( 1148 iterator_.StorageIndexForColumn(col.index_in_table())); 1149 } type()1150 ColumnType::type::type type() const { 1151 const auto& col = table()->type(); 1152 return col.GetAtIdx( 1153 iterator_.StorageIndexForColumn(col.index_in_table())); 1154 } package_name()1155 ColumnType::package_name::type package_name() const { 1156 const auto& col = table()->package_name(); 1157 return col.GetAtIdx( 1158 iterator_.StorageIndexForColumn(col.index_in_table())); 1159 } uid()1160 ColumnType::uid::type uid() const { 1161 const auto& col = table()->uid(); 1162 return col.GetAtIdx( 1163 iterator_.StorageIndexForColumn(col.index_in_table())); 1164 } current_mode()1165 ColumnType::current_mode::type current_mode() const { 1166 const auto& col = table()->current_mode(); 1167 return col.GetAtIdx( 1168 iterator_.StorageIndexForColumn(col.index_in_table())); 1169 } standard_mode_supported()1170 ColumnType::standard_mode_supported::type standard_mode_supported() const { 1171 const auto& col = table()->standard_mode_supported(); 1172 return col.GetAtIdx( 1173 iterator_.StorageIndexForColumn(col.index_in_table())); 1174 } standard_mode_downscale()1175 ColumnType::standard_mode_downscale::type standard_mode_downscale() const { 1176 const auto& col = table()->standard_mode_downscale(); 1177 return col.GetAtIdx( 1178 iterator_.StorageIndexForColumn(col.index_in_table())); 1179 } standard_mode_use_angle()1180 ColumnType::standard_mode_use_angle::type standard_mode_use_angle() const { 1181 const auto& col = table()->standard_mode_use_angle(); 1182 return col.GetAtIdx( 1183 iterator_.StorageIndexForColumn(col.index_in_table())); 1184 } standard_mode_fps()1185 ColumnType::standard_mode_fps::type standard_mode_fps() const { 1186 const auto& col = table()->standard_mode_fps(); 1187 return col.GetAtIdx( 1188 iterator_.StorageIndexForColumn(col.index_in_table())); 1189 } perf_mode_supported()1190 ColumnType::perf_mode_supported::type perf_mode_supported() const { 1191 const auto& col = table()->perf_mode_supported(); 1192 return col.GetAtIdx( 1193 iterator_.StorageIndexForColumn(col.index_in_table())); 1194 } perf_mode_downscale()1195 ColumnType::perf_mode_downscale::type perf_mode_downscale() const { 1196 const auto& col = table()->perf_mode_downscale(); 1197 return col.GetAtIdx( 1198 iterator_.StorageIndexForColumn(col.index_in_table())); 1199 } perf_mode_use_angle()1200 ColumnType::perf_mode_use_angle::type perf_mode_use_angle() const { 1201 const auto& col = table()->perf_mode_use_angle(); 1202 return col.GetAtIdx( 1203 iterator_.StorageIndexForColumn(col.index_in_table())); 1204 } perf_mode_fps()1205 ColumnType::perf_mode_fps::type perf_mode_fps() const { 1206 const auto& col = table()->perf_mode_fps(); 1207 return col.GetAtIdx( 1208 iterator_.StorageIndexForColumn(col.index_in_table())); 1209 } battery_mode_supported()1210 ColumnType::battery_mode_supported::type battery_mode_supported() const { 1211 const auto& col = table()->battery_mode_supported(); 1212 return col.GetAtIdx( 1213 iterator_.StorageIndexForColumn(col.index_in_table())); 1214 } battery_mode_downscale()1215 ColumnType::battery_mode_downscale::type battery_mode_downscale() const { 1216 const auto& col = table()->battery_mode_downscale(); 1217 return col.GetAtIdx( 1218 iterator_.StorageIndexForColumn(col.index_in_table())); 1219 } battery_mode_use_angle()1220 ColumnType::battery_mode_use_angle::type battery_mode_use_angle() const { 1221 const auto& col = table()->battery_mode_use_angle(); 1222 return col.GetAtIdx( 1223 iterator_.StorageIndexForColumn(col.index_in_table())); 1224 } battery_mode_fps()1225 ColumnType::battery_mode_fps::type battery_mode_fps() const { 1226 const auto& col = table()->battery_mode_fps(); 1227 return col.GetAtIdx( 1228 iterator_.StorageIndexForColumn(col.index_in_table())); 1229 } 1230 1231 protected: ConstIterator(const AndroidGameInterventionListTable * table,Table::Iterator iterator)1232 explicit ConstIterator(const AndroidGameInterventionListTable* table, 1233 Table::Iterator iterator) 1234 : AbstractConstIterator(table, std::move(iterator)) {} 1235 CurrentRowNumber()1236 uint32_t CurrentRowNumber() const { 1237 return iterator_.StorageIndexForLastOverlay(); 1238 } 1239 1240 private: 1241 friend class AndroidGameInterventionListTable; 1242 friend class macros_internal::AbstractConstIterator< 1243 ConstIterator, AndroidGameInterventionListTable, RowNumber, ConstRowReference>; 1244 }; 1245 class Iterator : public ConstIterator { 1246 public: row_reference()1247 RowReference row_reference() const { 1248 return {const_cast<AndroidGameInterventionListTable*>(table()), CurrentRowNumber()}; 1249 } 1250 1251 private: 1252 friend class AndroidGameInterventionListTable; 1253 Iterator(AndroidGameInterventionListTable * table,Table::Iterator iterator)1254 explicit Iterator(AndroidGameInterventionListTable* table, Table::Iterator iterator) 1255 : ConstIterator(table, std::move(iterator)) {} 1256 }; 1257 1258 struct IdAndRow { 1259 Id id; 1260 uint32_t row; 1261 RowReference row_reference; 1262 RowNumber row_number; 1263 }; 1264 GetColumns(AndroidGameInterventionListTable * self,const macros_internal::MacroTable * parent)1265 static std::vector<ColumnLegacy> GetColumns( 1266 AndroidGameInterventionListTable* self, 1267 const macros_internal::MacroTable* parent) { 1268 std::vector<ColumnLegacy> columns = 1269 CopyColumnsFromParentOrAddRootColumns(self, parent); 1270 uint32_t olay_idx = OverlayCount(parent); 1271 AddColumnToVector(columns, "package_name", &self->package_name_, ColumnFlag::package_name, 1272 static_cast<uint32_t>(columns.size()), olay_idx); 1273 AddColumnToVector(columns, "uid", &self->uid_, ColumnFlag::uid, 1274 static_cast<uint32_t>(columns.size()), olay_idx); 1275 AddColumnToVector(columns, "current_mode", &self->current_mode_, ColumnFlag::current_mode, 1276 static_cast<uint32_t>(columns.size()), olay_idx); 1277 AddColumnToVector(columns, "standard_mode_supported", &self->standard_mode_supported_, ColumnFlag::standard_mode_supported, 1278 static_cast<uint32_t>(columns.size()), olay_idx); 1279 AddColumnToVector(columns, "standard_mode_downscale", &self->standard_mode_downscale_, ColumnFlag::standard_mode_downscale, 1280 static_cast<uint32_t>(columns.size()), olay_idx); 1281 AddColumnToVector(columns, "standard_mode_use_angle", &self->standard_mode_use_angle_, ColumnFlag::standard_mode_use_angle, 1282 static_cast<uint32_t>(columns.size()), olay_idx); 1283 AddColumnToVector(columns, "standard_mode_fps", &self->standard_mode_fps_, ColumnFlag::standard_mode_fps, 1284 static_cast<uint32_t>(columns.size()), olay_idx); 1285 AddColumnToVector(columns, "perf_mode_supported", &self->perf_mode_supported_, ColumnFlag::perf_mode_supported, 1286 static_cast<uint32_t>(columns.size()), olay_idx); 1287 AddColumnToVector(columns, "perf_mode_downscale", &self->perf_mode_downscale_, ColumnFlag::perf_mode_downscale, 1288 static_cast<uint32_t>(columns.size()), olay_idx); 1289 AddColumnToVector(columns, "perf_mode_use_angle", &self->perf_mode_use_angle_, ColumnFlag::perf_mode_use_angle, 1290 static_cast<uint32_t>(columns.size()), olay_idx); 1291 AddColumnToVector(columns, "perf_mode_fps", &self->perf_mode_fps_, ColumnFlag::perf_mode_fps, 1292 static_cast<uint32_t>(columns.size()), olay_idx); 1293 AddColumnToVector(columns, "battery_mode_supported", &self->battery_mode_supported_, ColumnFlag::battery_mode_supported, 1294 static_cast<uint32_t>(columns.size()), olay_idx); 1295 AddColumnToVector(columns, "battery_mode_downscale", &self->battery_mode_downscale_, ColumnFlag::battery_mode_downscale, 1296 static_cast<uint32_t>(columns.size()), olay_idx); 1297 AddColumnToVector(columns, "battery_mode_use_angle", &self->battery_mode_use_angle_, ColumnFlag::battery_mode_use_angle, 1298 static_cast<uint32_t>(columns.size()), olay_idx); 1299 AddColumnToVector(columns, "battery_mode_fps", &self->battery_mode_fps_, ColumnFlag::battery_mode_fps, 1300 static_cast<uint32_t>(columns.size()), olay_idx); 1301 return columns; 1302 } 1303 AndroidGameInterventionListTable(StringPool * pool)1304 PERFETTO_NO_INLINE explicit AndroidGameInterventionListTable(StringPool* pool) 1305 : macros_internal::MacroTable( 1306 pool, 1307 GetColumns(this, nullptr), 1308 nullptr), 1309 package_name_(ColumnStorage<ColumnType::package_name::stored_type>::Create<false>()), 1310 uid_(ColumnStorage<ColumnType::uid::stored_type>::Create<false>()), 1311 current_mode_(ColumnStorage<ColumnType::current_mode::stored_type>::Create<false>()), 1312 standard_mode_supported_(ColumnStorage<ColumnType::standard_mode_supported::stored_type>::Create<false>()), 1313 standard_mode_downscale_(ColumnStorage<ColumnType::standard_mode_downscale::stored_type>::Create<false>()), 1314 standard_mode_use_angle_(ColumnStorage<ColumnType::standard_mode_use_angle::stored_type>::Create<false>()), 1315 standard_mode_fps_(ColumnStorage<ColumnType::standard_mode_fps::stored_type>::Create<false>()), 1316 perf_mode_supported_(ColumnStorage<ColumnType::perf_mode_supported::stored_type>::Create<false>()), 1317 perf_mode_downscale_(ColumnStorage<ColumnType::perf_mode_downscale::stored_type>::Create<false>()), 1318 perf_mode_use_angle_(ColumnStorage<ColumnType::perf_mode_use_angle::stored_type>::Create<false>()), 1319 perf_mode_fps_(ColumnStorage<ColumnType::perf_mode_fps::stored_type>::Create<false>()), 1320 battery_mode_supported_(ColumnStorage<ColumnType::battery_mode_supported::stored_type>::Create<false>()), 1321 battery_mode_downscale_(ColumnStorage<ColumnType::battery_mode_downscale::stored_type>::Create<false>()), 1322 battery_mode_use_angle_(ColumnStorage<ColumnType::battery_mode_use_angle::stored_type>::Create<false>()), 1323 battery_mode_fps_(ColumnStorage<ColumnType::battery_mode_fps::stored_type>::Create<false>()) 1324 , 1325 id_storage_layer_(new column::IdStorage()), 1326 type_storage_layer_( 1327 new column::StringStorage(string_pool(), &type_.vector())), 1328 package_name_storage_layer_( 1329 new column::StringStorage(string_pool(), &package_name_.vector())), 1330 uid_storage_layer_( 1331 new column::NumericStorage<ColumnType::uid::non_optional_stored_type>( 1332 &uid_.vector(), 1333 ColumnTypeHelper<ColumnType::uid::stored_type>::ToColumnType(), 1334 false)), 1335 current_mode_storage_layer_( 1336 new column::NumericStorage<ColumnType::current_mode::non_optional_stored_type>( 1337 ¤t_mode_.vector(), 1338 ColumnTypeHelper<ColumnType::current_mode::stored_type>::ToColumnType(), 1339 false)), 1340 standard_mode_supported_storage_layer_( 1341 new column::NumericStorage<ColumnType::standard_mode_supported::non_optional_stored_type>( 1342 &standard_mode_supported_.vector(), 1343 ColumnTypeHelper<ColumnType::standard_mode_supported::stored_type>::ToColumnType(), 1344 false)), 1345 standard_mode_downscale_storage_layer_( 1346 new column::NumericStorage<ColumnType::standard_mode_downscale::non_optional_stored_type>( 1347 &standard_mode_downscale_.non_null_vector(), 1348 ColumnTypeHelper<ColumnType::standard_mode_downscale::stored_type>::ToColumnType(), 1349 false)), 1350 standard_mode_use_angle_storage_layer_( 1351 new column::NumericStorage<ColumnType::standard_mode_use_angle::non_optional_stored_type>( 1352 &standard_mode_use_angle_.non_null_vector(), 1353 ColumnTypeHelper<ColumnType::standard_mode_use_angle::stored_type>::ToColumnType(), 1354 false)), 1355 standard_mode_fps_storage_layer_( 1356 new column::NumericStorage<ColumnType::standard_mode_fps::non_optional_stored_type>( 1357 &standard_mode_fps_.non_null_vector(), 1358 ColumnTypeHelper<ColumnType::standard_mode_fps::stored_type>::ToColumnType(), 1359 false)), 1360 perf_mode_supported_storage_layer_( 1361 new column::NumericStorage<ColumnType::perf_mode_supported::non_optional_stored_type>( 1362 &perf_mode_supported_.vector(), 1363 ColumnTypeHelper<ColumnType::perf_mode_supported::stored_type>::ToColumnType(), 1364 false)), 1365 perf_mode_downscale_storage_layer_( 1366 new column::NumericStorage<ColumnType::perf_mode_downscale::non_optional_stored_type>( 1367 &perf_mode_downscale_.non_null_vector(), 1368 ColumnTypeHelper<ColumnType::perf_mode_downscale::stored_type>::ToColumnType(), 1369 false)), 1370 perf_mode_use_angle_storage_layer_( 1371 new column::NumericStorage<ColumnType::perf_mode_use_angle::non_optional_stored_type>( 1372 &perf_mode_use_angle_.non_null_vector(), 1373 ColumnTypeHelper<ColumnType::perf_mode_use_angle::stored_type>::ToColumnType(), 1374 false)), 1375 perf_mode_fps_storage_layer_( 1376 new column::NumericStorage<ColumnType::perf_mode_fps::non_optional_stored_type>( 1377 &perf_mode_fps_.non_null_vector(), 1378 ColumnTypeHelper<ColumnType::perf_mode_fps::stored_type>::ToColumnType(), 1379 false)), 1380 battery_mode_supported_storage_layer_( 1381 new column::NumericStorage<ColumnType::battery_mode_supported::non_optional_stored_type>( 1382 &battery_mode_supported_.vector(), 1383 ColumnTypeHelper<ColumnType::battery_mode_supported::stored_type>::ToColumnType(), 1384 false)), 1385 battery_mode_downscale_storage_layer_( 1386 new column::NumericStorage<ColumnType::battery_mode_downscale::non_optional_stored_type>( 1387 &battery_mode_downscale_.non_null_vector(), 1388 ColumnTypeHelper<ColumnType::battery_mode_downscale::stored_type>::ToColumnType(), 1389 false)), 1390 battery_mode_use_angle_storage_layer_( 1391 new column::NumericStorage<ColumnType::battery_mode_use_angle::non_optional_stored_type>( 1392 &battery_mode_use_angle_.non_null_vector(), 1393 ColumnTypeHelper<ColumnType::battery_mode_use_angle::stored_type>::ToColumnType(), 1394 false)), 1395 battery_mode_fps_storage_layer_( 1396 new column::NumericStorage<ColumnType::battery_mode_fps::non_optional_stored_type>( 1397 &battery_mode_fps_.non_null_vector(), 1398 ColumnTypeHelper<ColumnType::battery_mode_fps::stored_type>::ToColumnType(), 1399 false)) 1400 , 1401 standard_mode_downscale_null_layer_(new column::NullOverlay(standard_mode_downscale_.bv())), 1402 standard_mode_use_angle_null_layer_(new column::NullOverlay(standard_mode_use_angle_.bv())), 1403 standard_mode_fps_null_layer_(new column::NullOverlay(standard_mode_fps_.bv())), 1404 perf_mode_downscale_null_layer_(new column::NullOverlay(perf_mode_downscale_.bv())), 1405 perf_mode_use_angle_null_layer_(new column::NullOverlay(perf_mode_use_angle_.bv())), 1406 perf_mode_fps_null_layer_(new column::NullOverlay(perf_mode_fps_.bv())), 1407 battery_mode_downscale_null_layer_(new column::NullOverlay(battery_mode_downscale_.bv())), 1408 battery_mode_use_angle_null_layer_(new column::NullOverlay(battery_mode_use_angle_.bv())), 1409 battery_mode_fps_null_layer_(new column::NullOverlay(battery_mode_fps_.bv())) { 1410 static_assert( 1411 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::package_name::stored_type>( 1412 ColumnFlag::package_name), 1413 "Column type and flag combination is not valid"); 1414 static_assert( 1415 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::uid::stored_type>( 1416 ColumnFlag::uid), 1417 "Column type and flag combination is not valid"); 1418 static_assert( 1419 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::current_mode::stored_type>( 1420 ColumnFlag::current_mode), 1421 "Column type and flag combination is not valid"); 1422 static_assert( 1423 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::standard_mode_supported::stored_type>( 1424 ColumnFlag::standard_mode_supported), 1425 "Column type and flag combination is not valid"); 1426 static_assert( 1427 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::standard_mode_downscale::stored_type>( 1428 ColumnFlag::standard_mode_downscale), 1429 "Column type and flag combination is not valid"); 1430 static_assert( 1431 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::standard_mode_use_angle::stored_type>( 1432 ColumnFlag::standard_mode_use_angle), 1433 "Column type and flag combination is not valid"); 1434 static_assert( 1435 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::standard_mode_fps::stored_type>( 1436 ColumnFlag::standard_mode_fps), 1437 "Column type and flag combination is not valid"); 1438 static_assert( 1439 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::perf_mode_supported::stored_type>( 1440 ColumnFlag::perf_mode_supported), 1441 "Column type and flag combination is not valid"); 1442 static_assert( 1443 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::perf_mode_downscale::stored_type>( 1444 ColumnFlag::perf_mode_downscale), 1445 "Column type and flag combination is not valid"); 1446 static_assert( 1447 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::perf_mode_use_angle::stored_type>( 1448 ColumnFlag::perf_mode_use_angle), 1449 "Column type and flag combination is not valid"); 1450 static_assert( 1451 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::perf_mode_fps::stored_type>( 1452 ColumnFlag::perf_mode_fps), 1453 "Column type and flag combination is not valid"); 1454 static_assert( 1455 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::battery_mode_supported::stored_type>( 1456 ColumnFlag::battery_mode_supported), 1457 "Column type and flag combination is not valid"); 1458 static_assert( 1459 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::battery_mode_downscale::stored_type>( 1460 ColumnFlag::battery_mode_downscale), 1461 "Column type and flag combination is not valid"); 1462 static_assert( 1463 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::battery_mode_use_angle::stored_type>( 1464 ColumnFlag::battery_mode_use_angle), 1465 "Column type and flag combination is not valid"); 1466 static_assert( 1467 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::battery_mode_fps::stored_type>( 1468 ColumnFlag::battery_mode_fps), 1469 "Column type and flag combination is not valid"); 1470 OnConstructionCompletedRegularConstructor( 1471 {id_storage_layer_,type_storage_layer_,package_name_storage_layer_,uid_storage_layer_,current_mode_storage_layer_,standard_mode_supported_storage_layer_,standard_mode_downscale_storage_layer_,standard_mode_use_angle_storage_layer_,standard_mode_fps_storage_layer_,perf_mode_supported_storage_layer_,perf_mode_downscale_storage_layer_,perf_mode_use_angle_storage_layer_,perf_mode_fps_storage_layer_,battery_mode_supported_storage_layer_,battery_mode_downscale_storage_layer_,battery_mode_use_angle_storage_layer_,battery_mode_fps_storage_layer_}, 1472 {{},{},{},{},{},{},standard_mode_downscale_null_layer_,standard_mode_use_angle_null_layer_,standard_mode_fps_null_layer_,{},perf_mode_downscale_null_layer_,perf_mode_use_angle_null_layer_,perf_mode_fps_null_layer_,{},battery_mode_downscale_null_layer_,battery_mode_use_angle_null_layer_,battery_mode_fps_null_layer_}); 1473 } 1474 ~AndroidGameInterventionListTable() override; 1475 Name()1476 static const char* Name() { return "android_game_intervention_list"; } 1477 ComputeStaticSchema()1478 static Table::Schema ComputeStaticSchema() { 1479 Table::Schema schema; 1480 schema.columns.emplace_back(Table::Schema::Column{ 1481 "id", SqlValue::Type::kLong, true, true, false, false}); 1482 schema.columns.emplace_back(Table::Schema::Column{ 1483 "type", SqlValue::Type::kString, false, false, false, false}); 1484 schema.columns.emplace_back(Table::Schema::Column{ 1485 "package_name", ColumnType::package_name::SqlValueType(), false, 1486 false, 1487 false, 1488 false}); 1489 schema.columns.emplace_back(Table::Schema::Column{ 1490 "uid", ColumnType::uid::SqlValueType(), false, 1491 false, 1492 false, 1493 false}); 1494 schema.columns.emplace_back(Table::Schema::Column{ 1495 "current_mode", ColumnType::current_mode::SqlValueType(), false, 1496 false, 1497 false, 1498 false}); 1499 schema.columns.emplace_back(Table::Schema::Column{ 1500 "standard_mode_supported", ColumnType::standard_mode_supported::SqlValueType(), false, 1501 false, 1502 false, 1503 false}); 1504 schema.columns.emplace_back(Table::Schema::Column{ 1505 "standard_mode_downscale", ColumnType::standard_mode_downscale::SqlValueType(), false, 1506 false, 1507 false, 1508 false}); 1509 schema.columns.emplace_back(Table::Schema::Column{ 1510 "standard_mode_use_angle", ColumnType::standard_mode_use_angle::SqlValueType(), false, 1511 false, 1512 false, 1513 false}); 1514 schema.columns.emplace_back(Table::Schema::Column{ 1515 "standard_mode_fps", ColumnType::standard_mode_fps::SqlValueType(), false, 1516 false, 1517 false, 1518 false}); 1519 schema.columns.emplace_back(Table::Schema::Column{ 1520 "perf_mode_supported", ColumnType::perf_mode_supported::SqlValueType(), false, 1521 false, 1522 false, 1523 false}); 1524 schema.columns.emplace_back(Table::Schema::Column{ 1525 "perf_mode_downscale", ColumnType::perf_mode_downscale::SqlValueType(), false, 1526 false, 1527 false, 1528 false}); 1529 schema.columns.emplace_back(Table::Schema::Column{ 1530 "perf_mode_use_angle", ColumnType::perf_mode_use_angle::SqlValueType(), false, 1531 false, 1532 false, 1533 false}); 1534 schema.columns.emplace_back(Table::Schema::Column{ 1535 "perf_mode_fps", ColumnType::perf_mode_fps::SqlValueType(), false, 1536 false, 1537 false, 1538 false}); 1539 schema.columns.emplace_back(Table::Schema::Column{ 1540 "battery_mode_supported", ColumnType::battery_mode_supported::SqlValueType(), false, 1541 false, 1542 false, 1543 false}); 1544 schema.columns.emplace_back(Table::Schema::Column{ 1545 "battery_mode_downscale", ColumnType::battery_mode_downscale::SqlValueType(), false, 1546 false, 1547 false, 1548 false}); 1549 schema.columns.emplace_back(Table::Schema::Column{ 1550 "battery_mode_use_angle", ColumnType::battery_mode_use_angle::SqlValueType(), false, 1551 false, 1552 false, 1553 false}); 1554 schema.columns.emplace_back(Table::Schema::Column{ 1555 "battery_mode_fps", ColumnType::battery_mode_fps::SqlValueType(), false, 1556 false, 1557 false, 1558 false}); 1559 return schema; 1560 } 1561 IterateRows()1562 ConstIterator IterateRows() const { 1563 return ConstIterator(this, Table::IterateRows()); 1564 } 1565 IterateRows()1566 Iterator IterateRows() { return Iterator(this, Table::IterateRows()); } 1567 FilterToIterator(const Query & q)1568 ConstIterator FilterToIterator(const Query& q) const { 1569 return ConstIterator(this, QueryToIterator(q)); 1570 } 1571 FilterToIterator(const Query & q)1572 Iterator FilterToIterator(const Query& q) { 1573 return Iterator(this, QueryToIterator(q)); 1574 } 1575 ShrinkToFit()1576 void ShrinkToFit() { 1577 type_.ShrinkToFit(); 1578 package_name_.ShrinkToFit(); 1579 uid_.ShrinkToFit(); 1580 current_mode_.ShrinkToFit(); 1581 standard_mode_supported_.ShrinkToFit(); 1582 standard_mode_downscale_.ShrinkToFit(); 1583 standard_mode_use_angle_.ShrinkToFit(); 1584 standard_mode_fps_.ShrinkToFit(); 1585 perf_mode_supported_.ShrinkToFit(); 1586 perf_mode_downscale_.ShrinkToFit(); 1587 perf_mode_use_angle_.ShrinkToFit(); 1588 perf_mode_fps_.ShrinkToFit(); 1589 battery_mode_supported_.ShrinkToFit(); 1590 battery_mode_downscale_.ShrinkToFit(); 1591 battery_mode_use_angle_.ShrinkToFit(); 1592 battery_mode_fps_.ShrinkToFit(); 1593 } 1594 1595 ConstRowReference operator[](uint32_t r) const { 1596 return ConstRowReference(this, r); 1597 } 1598 RowReference operator[](uint32_t r) { return RowReference(this, r); } 1599 ConstRowReference operator[](RowNumber r) const { 1600 return ConstRowReference(this, r.row_number()); 1601 } 1602 RowReference operator[](RowNumber r) { 1603 return RowReference(this, r.row_number()); 1604 } 1605 FindById(Id find_id)1606 std::optional<ConstRowReference> FindById(Id find_id) const { 1607 std::optional<uint32_t> row = id().IndexOf(find_id); 1608 return row ? std::make_optional(ConstRowReference(this, *row)) 1609 : std::nullopt; 1610 } 1611 FindById(Id find_id)1612 std::optional<RowReference> FindById(Id find_id) { 1613 std::optional<uint32_t> row = id().IndexOf(find_id); 1614 return row ? std::make_optional(RowReference(this, *row)) : std::nullopt; 1615 } 1616 Insert(const Row & row)1617 IdAndRow Insert(const Row& row) { 1618 uint32_t row_number = row_count(); 1619 Id id = Id{row_number}; 1620 type_.Append(string_pool()->InternString(row.type())); 1621 mutable_package_name()->Append(row.package_name); 1622 mutable_uid()->Append(row.uid); 1623 mutable_current_mode()->Append(row.current_mode); 1624 mutable_standard_mode_supported()->Append(row.standard_mode_supported); 1625 mutable_standard_mode_downscale()->Append(row.standard_mode_downscale); 1626 mutable_standard_mode_use_angle()->Append(row.standard_mode_use_angle); 1627 mutable_standard_mode_fps()->Append(row.standard_mode_fps); 1628 mutable_perf_mode_supported()->Append(row.perf_mode_supported); 1629 mutable_perf_mode_downscale()->Append(row.perf_mode_downscale); 1630 mutable_perf_mode_use_angle()->Append(row.perf_mode_use_angle); 1631 mutable_perf_mode_fps()->Append(row.perf_mode_fps); 1632 mutable_battery_mode_supported()->Append(row.battery_mode_supported); 1633 mutable_battery_mode_downscale()->Append(row.battery_mode_downscale); 1634 mutable_battery_mode_use_angle()->Append(row.battery_mode_use_angle); 1635 mutable_battery_mode_fps()->Append(row.battery_mode_fps); 1636 UpdateSelfOverlayAfterInsert(); 1637 return IdAndRow{id, row_number, RowReference(this, row_number), 1638 RowNumber(row_number)}; 1639 } 1640 1641 1642 id()1643 const IdColumn<AndroidGameInterventionListTable::Id>& id() const { 1644 return static_cast<const ColumnType::id&>(columns()[ColumnIndex::id]); 1645 } type()1646 const TypedColumn<StringPool::Id>& type() const { 1647 return static_cast<const ColumnType::type&>(columns()[ColumnIndex::type]); 1648 } package_name()1649 const TypedColumn<StringPool::Id>& package_name() const { 1650 return static_cast<const ColumnType::package_name&>(columns()[ColumnIndex::package_name]); 1651 } uid()1652 const TypedColumn<int64_t>& uid() const { 1653 return static_cast<const ColumnType::uid&>(columns()[ColumnIndex::uid]); 1654 } current_mode()1655 const TypedColumn<int32_t>& current_mode() const { 1656 return static_cast<const ColumnType::current_mode&>(columns()[ColumnIndex::current_mode]); 1657 } standard_mode_supported()1658 const TypedColumn<int32_t>& standard_mode_supported() const { 1659 return static_cast<const ColumnType::standard_mode_supported&>(columns()[ColumnIndex::standard_mode_supported]); 1660 } standard_mode_downscale()1661 const TypedColumn<std::optional<double>>& standard_mode_downscale() const { 1662 return static_cast<const ColumnType::standard_mode_downscale&>(columns()[ColumnIndex::standard_mode_downscale]); 1663 } standard_mode_use_angle()1664 const TypedColumn<std::optional<int32_t>>& standard_mode_use_angle() const { 1665 return static_cast<const ColumnType::standard_mode_use_angle&>(columns()[ColumnIndex::standard_mode_use_angle]); 1666 } standard_mode_fps()1667 const TypedColumn<std::optional<double>>& standard_mode_fps() const { 1668 return static_cast<const ColumnType::standard_mode_fps&>(columns()[ColumnIndex::standard_mode_fps]); 1669 } perf_mode_supported()1670 const TypedColumn<int32_t>& perf_mode_supported() const { 1671 return static_cast<const ColumnType::perf_mode_supported&>(columns()[ColumnIndex::perf_mode_supported]); 1672 } perf_mode_downscale()1673 const TypedColumn<std::optional<double>>& perf_mode_downscale() const { 1674 return static_cast<const ColumnType::perf_mode_downscale&>(columns()[ColumnIndex::perf_mode_downscale]); 1675 } perf_mode_use_angle()1676 const TypedColumn<std::optional<int32_t>>& perf_mode_use_angle() const { 1677 return static_cast<const ColumnType::perf_mode_use_angle&>(columns()[ColumnIndex::perf_mode_use_angle]); 1678 } perf_mode_fps()1679 const TypedColumn<std::optional<double>>& perf_mode_fps() const { 1680 return static_cast<const ColumnType::perf_mode_fps&>(columns()[ColumnIndex::perf_mode_fps]); 1681 } battery_mode_supported()1682 const TypedColumn<int32_t>& battery_mode_supported() const { 1683 return static_cast<const ColumnType::battery_mode_supported&>(columns()[ColumnIndex::battery_mode_supported]); 1684 } battery_mode_downscale()1685 const TypedColumn<std::optional<double>>& battery_mode_downscale() const { 1686 return static_cast<const ColumnType::battery_mode_downscale&>(columns()[ColumnIndex::battery_mode_downscale]); 1687 } battery_mode_use_angle()1688 const TypedColumn<std::optional<int32_t>>& battery_mode_use_angle() const { 1689 return static_cast<const ColumnType::battery_mode_use_angle&>(columns()[ColumnIndex::battery_mode_use_angle]); 1690 } battery_mode_fps()1691 const TypedColumn<std::optional<double>>& battery_mode_fps() const { 1692 return static_cast<const ColumnType::battery_mode_fps&>(columns()[ColumnIndex::battery_mode_fps]); 1693 } 1694 mutable_package_name()1695 TypedColumn<StringPool::Id>* mutable_package_name() { 1696 return static_cast<ColumnType::package_name*>( 1697 GetColumn(ColumnIndex::package_name)); 1698 } mutable_uid()1699 TypedColumn<int64_t>* mutable_uid() { 1700 return static_cast<ColumnType::uid*>( 1701 GetColumn(ColumnIndex::uid)); 1702 } mutable_current_mode()1703 TypedColumn<int32_t>* mutable_current_mode() { 1704 return static_cast<ColumnType::current_mode*>( 1705 GetColumn(ColumnIndex::current_mode)); 1706 } mutable_standard_mode_supported()1707 TypedColumn<int32_t>* mutable_standard_mode_supported() { 1708 return static_cast<ColumnType::standard_mode_supported*>( 1709 GetColumn(ColumnIndex::standard_mode_supported)); 1710 } mutable_standard_mode_downscale()1711 TypedColumn<std::optional<double>>* mutable_standard_mode_downscale() { 1712 return static_cast<ColumnType::standard_mode_downscale*>( 1713 GetColumn(ColumnIndex::standard_mode_downscale)); 1714 } mutable_standard_mode_use_angle()1715 TypedColumn<std::optional<int32_t>>* mutable_standard_mode_use_angle() { 1716 return static_cast<ColumnType::standard_mode_use_angle*>( 1717 GetColumn(ColumnIndex::standard_mode_use_angle)); 1718 } mutable_standard_mode_fps()1719 TypedColumn<std::optional<double>>* mutable_standard_mode_fps() { 1720 return static_cast<ColumnType::standard_mode_fps*>( 1721 GetColumn(ColumnIndex::standard_mode_fps)); 1722 } mutable_perf_mode_supported()1723 TypedColumn<int32_t>* mutable_perf_mode_supported() { 1724 return static_cast<ColumnType::perf_mode_supported*>( 1725 GetColumn(ColumnIndex::perf_mode_supported)); 1726 } mutable_perf_mode_downscale()1727 TypedColumn<std::optional<double>>* mutable_perf_mode_downscale() { 1728 return static_cast<ColumnType::perf_mode_downscale*>( 1729 GetColumn(ColumnIndex::perf_mode_downscale)); 1730 } mutable_perf_mode_use_angle()1731 TypedColumn<std::optional<int32_t>>* mutable_perf_mode_use_angle() { 1732 return static_cast<ColumnType::perf_mode_use_angle*>( 1733 GetColumn(ColumnIndex::perf_mode_use_angle)); 1734 } mutable_perf_mode_fps()1735 TypedColumn<std::optional<double>>* mutable_perf_mode_fps() { 1736 return static_cast<ColumnType::perf_mode_fps*>( 1737 GetColumn(ColumnIndex::perf_mode_fps)); 1738 } mutable_battery_mode_supported()1739 TypedColumn<int32_t>* mutable_battery_mode_supported() { 1740 return static_cast<ColumnType::battery_mode_supported*>( 1741 GetColumn(ColumnIndex::battery_mode_supported)); 1742 } mutable_battery_mode_downscale()1743 TypedColumn<std::optional<double>>* mutable_battery_mode_downscale() { 1744 return static_cast<ColumnType::battery_mode_downscale*>( 1745 GetColumn(ColumnIndex::battery_mode_downscale)); 1746 } mutable_battery_mode_use_angle()1747 TypedColumn<std::optional<int32_t>>* mutable_battery_mode_use_angle() { 1748 return static_cast<ColumnType::battery_mode_use_angle*>( 1749 GetColumn(ColumnIndex::battery_mode_use_angle)); 1750 } mutable_battery_mode_fps()1751 TypedColumn<std::optional<double>>* mutable_battery_mode_fps() { 1752 return static_cast<ColumnType::battery_mode_fps*>( 1753 GetColumn(ColumnIndex::battery_mode_fps)); 1754 } 1755 1756 private: 1757 1758 1759 ColumnStorage<ColumnType::package_name::stored_type> package_name_; 1760 ColumnStorage<ColumnType::uid::stored_type> uid_; 1761 ColumnStorage<ColumnType::current_mode::stored_type> current_mode_; 1762 ColumnStorage<ColumnType::standard_mode_supported::stored_type> standard_mode_supported_; 1763 ColumnStorage<ColumnType::standard_mode_downscale::stored_type> standard_mode_downscale_; 1764 ColumnStorage<ColumnType::standard_mode_use_angle::stored_type> standard_mode_use_angle_; 1765 ColumnStorage<ColumnType::standard_mode_fps::stored_type> standard_mode_fps_; 1766 ColumnStorage<ColumnType::perf_mode_supported::stored_type> perf_mode_supported_; 1767 ColumnStorage<ColumnType::perf_mode_downscale::stored_type> perf_mode_downscale_; 1768 ColumnStorage<ColumnType::perf_mode_use_angle::stored_type> perf_mode_use_angle_; 1769 ColumnStorage<ColumnType::perf_mode_fps::stored_type> perf_mode_fps_; 1770 ColumnStorage<ColumnType::battery_mode_supported::stored_type> battery_mode_supported_; 1771 ColumnStorage<ColumnType::battery_mode_downscale::stored_type> battery_mode_downscale_; 1772 ColumnStorage<ColumnType::battery_mode_use_angle::stored_type> battery_mode_use_angle_; 1773 ColumnStorage<ColumnType::battery_mode_fps::stored_type> battery_mode_fps_; 1774 1775 RefPtr<column::StorageLayer> id_storage_layer_; 1776 RefPtr<column::StorageLayer> type_storage_layer_; 1777 RefPtr<column::StorageLayer> package_name_storage_layer_; 1778 RefPtr<column::StorageLayer> uid_storage_layer_; 1779 RefPtr<column::StorageLayer> current_mode_storage_layer_; 1780 RefPtr<column::StorageLayer> standard_mode_supported_storage_layer_; 1781 RefPtr<column::StorageLayer> standard_mode_downscale_storage_layer_; 1782 RefPtr<column::StorageLayer> standard_mode_use_angle_storage_layer_; 1783 RefPtr<column::StorageLayer> standard_mode_fps_storage_layer_; 1784 RefPtr<column::StorageLayer> perf_mode_supported_storage_layer_; 1785 RefPtr<column::StorageLayer> perf_mode_downscale_storage_layer_; 1786 RefPtr<column::StorageLayer> perf_mode_use_angle_storage_layer_; 1787 RefPtr<column::StorageLayer> perf_mode_fps_storage_layer_; 1788 RefPtr<column::StorageLayer> battery_mode_supported_storage_layer_; 1789 RefPtr<column::StorageLayer> battery_mode_downscale_storage_layer_; 1790 RefPtr<column::StorageLayer> battery_mode_use_angle_storage_layer_; 1791 RefPtr<column::StorageLayer> battery_mode_fps_storage_layer_; 1792 1793 RefPtr<column::OverlayLayer> standard_mode_downscale_null_layer_; 1794 RefPtr<column::OverlayLayer> standard_mode_use_angle_null_layer_; 1795 RefPtr<column::OverlayLayer> standard_mode_fps_null_layer_; 1796 RefPtr<column::OverlayLayer> perf_mode_downscale_null_layer_; 1797 RefPtr<column::OverlayLayer> perf_mode_use_angle_null_layer_; 1798 RefPtr<column::OverlayLayer> perf_mode_fps_null_layer_; 1799 RefPtr<column::OverlayLayer> battery_mode_downscale_null_layer_; 1800 RefPtr<column::OverlayLayer> battery_mode_use_angle_null_layer_; 1801 RefPtr<column::OverlayLayer> battery_mode_fps_null_layer_; 1802 }; 1803 1804 1805 class AndroidKeyEventsTable : public macros_internal::MacroTable { 1806 public: 1807 static constexpr uint32_t kColumnCount = 7; 1808 1809 struct Id : public BaseId { 1810 Id() = default; IdId1811 explicit constexpr Id(uint32_t v) : BaseId(v) {} 1812 }; 1813 static_assert(std::is_trivially_destructible_v<Id>, 1814 "Inheritance used without trivial destruction"); 1815 1816 struct ColumnIndex { 1817 static constexpr uint32_t id = 0; 1818 static constexpr uint32_t type = 1; 1819 static constexpr uint32_t event_id = 2; 1820 static constexpr uint32_t ts = 3; 1821 static constexpr uint32_t arg_set_id = 4; 1822 static constexpr uint32_t base64_proto = 5; 1823 static constexpr uint32_t base64_proto_id = 6; 1824 }; 1825 struct ColumnType { 1826 using id = IdColumn<AndroidKeyEventsTable::Id>; 1827 using type = TypedColumn<StringPool::Id>; 1828 using event_id = TypedColumn<uint32_t>; 1829 using ts = TypedColumn<int64_t>; 1830 using arg_set_id = TypedColumn<uint32_t>; 1831 using base64_proto = TypedColumn<StringPool::Id>; 1832 using base64_proto_id = TypedColumn<std::optional<uint32_t>>; 1833 }; 1834 struct Row : public macros_internal::RootParentTable::Row { 1835 Row(uint32_t in_event_id = {}, 1836 int64_t in_ts = {}, 1837 uint32_t in_arg_set_id = {}, 1838 StringPool::Id in_base64_proto = {}, 1839 std::optional<uint32_t> in_base64_proto_id = {}, 1840 std::nullptr_t = nullptr) RowRow1841 : macros_internal::RootParentTable::Row(), 1842 event_id(in_event_id), 1843 ts(in_ts), 1844 arg_set_id(in_arg_set_id), 1845 base64_proto(in_base64_proto), 1846 base64_proto_id(in_base64_proto_id) { 1847 type_ = "__intrinsic_android_key_events"; 1848 } 1849 uint32_t event_id; 1850 int64_t ts; 1851 uint32_t arg_set_id; 1852 StringPool::Id base64_proto; 1853 std::optional<uint32_t> base64_proto_id; 1854 1855 bool operator==(const AndroidKeyEventsTable::Row& other) const { 1856 return type() == other.type() && ColumnType::event_id::Equals(event_id, other.event_id) && 1857 ColumnType::ts::Equals(ts, other.ts) && 1858 ColumnType::arg_set_id::Equals(arg_set_id, other.arg_set_id) && 1859 ColumnType::base64_proto::Equals(base64_proto, other.base64_proto) && 1860 ColumnType::base64_proto_id::Equals(base64_proto_id, other.base64_proto_id); 1861 } 1862 }; 1863 struct ColumnFlag { 1864 static constexpr uint32_t event_id = ColumnType::event_id::default_flags(); 1865 static constexpr uint32_t ts = ColumnType::ts::default_flags(); 1866 static constexpr uint32_t arg_set_id = ColumnType::arg_set_id::default_flags(); 1867 static constexpr uint32_t base64_proto = ColumnType::base64_proto::default_flags(); 1868 static constexpr uint32_t base64_proto_id = ColumnType::base64_proto_id::default_flags(); 1869 }; 1870 1871 class RowNumber; 1872 class ConstRowReference; 1873 class RowReference; 1874 1875 class RowNumber : public macros_internal::AbstractRowNumber< 1876 AndroidKeyEventsTable, ConstRowReference, RowReference> { 1877 public: RowNumber(uint32_t row_number)1878 explicit RowNumber(uint32_t row_number) 1879 : AbstractRowNumber(row_number) {} 1880 }; 1881 static_assert(std::is_trivially_destructible_v<RowNumber>, 1882 "Inheritance used without trivial destruction"); 1883 1884 class ConstRowReference : public macros_internal::AbstractConstRowReference< 1885 AndroidKeyEventsTable, RowNumber> { 1886 public: ConstRowReference(const AndroidKeyEventsTable * table,uint32_t row_number)1887 ConstRowReference(const AndroidKeyEventsTable* table, uint32_t row_number) 1888 : AbstractConstRowReference(table, row_number) {} 1889 id()1890 ColumnType::id::type id() const { 1891 return table()->id()[row_number_]; 1892 } type()1893 ColumnType::type::type type() const { 1894 return table()->type()[row_number_]; 1895 } event_id()1896 ColumnType::event_id::type event_id() const { 1897 return table()->event_id()[row_number_]; 1898 } ts()1899 ColumnType::ts::type ts() const { 1900 return table()->ts()[row_number_]; 1901 } arg_set_id()1902 ColumnType::arg_set_id::type arg_set_id() const { 1903 return table()->arg_set_id()[row_number_]; 1904 } base64_proto()1905 ColumnType::base64_proto::type base64_proto() const { 1906 return table()->base64_proto()[row_number_]; 1907 } base64_proto_id()1908 ColumnType::base64_proto_id::type base64_proto_id() const { 1909 return table()->base64_proto_id()[row_number_]; 1910 } 1911 }; 1912 static_assert(std::is_trivially_destructible_v<ConstRowReference>, 1913 "Inheritance used without trivial destruction"); 1914 class RowReference : public ConstRowReference { 1915 public: RowReference(const AndroidKeyEventsTable * table,uint32_t row_number)1916 RowReference(const AndroidKeyEventsTable* table, uint32_t row_number) 1917 : ConstRowReference(table, row_number) {} 1918 set_event_id(ColumnType::event_id::non_optional_type v)1919 void set_event_id( 1920 ColumnType::event_id::non_optional_type v) { 1921 return mutable_table()->mutable_event_id()->Set(row_number_, v); 1922 } set_ts(ColumnType::ts::non_optional_type v)1923 void set_ts( 1924 ColumnType::ts::non_optional_type v) { 1925 return mutable_table()->mutable_ts()->Set(row_number_, v); 1926 } set_arg_set_id(ColumnType::arg_set_id::non_optional_type v)1927 void set_arg_set_id( 1928 ColumnType::arg_set_id::non_optional_type v) { 1929 return mutable_table()->mutable_arg_set_id()->Set(row_number_, v); 1930 } set_base64_proto(ColumnType::base64_proto::non_optional_type v)1931 void set_base64_proto( 1932 ColumnType::base64_proto::non_optional_type v) { 1933 return mutable_table()->mutable_base64_proto()->Set(row_number_, v); 1934 } set_base64_proto_id(ColumnType::base64_proto_id::non_optional_type v)1935 void set_base64_proto_id( 1936 ColumnType::base64_proto_id::non_optional_type v) { 1937 return mutable_table()->mutable_base64_proto_id()->Set(row_number_, v); 1938 } 1939 1940 private: mutable_table()1941 AndroidKeyEventsTable* mutable_table() const { 1942 return const_cast<AndroidKeyEventsTable*>(table()); 1943 } 1944 }; 1945 static_assert(std::is_trivially_destructible_v<RowReference>, 1946 "Inheritance used without trivial destruction"); 1947 1948 class ConstIterator; 1949 class ConstIterator : public macros_internal::AbstractConstIterator< 1950 ConstIterator, AndroidKeyEventsTable, RowNumber, ConstRowReference> { 1951 public: id()1952 ColumnType::id::type id() const { 1953 const auto& col = table()->id(); 1954 return col.GetAtIdx( 1955 iterator_.StorageIndexForColumn(col.index_in_table())); 1956 } type()1957 ColumnType::type::type type() const { 1958 const auto& col = table()->type(); 1959 return col.GetAtIdx( 1960 iterator_.StorageIndexForColumn(col.index_in_table())); 1961 } event_id()1962 ColumnType::event_id::type event_id() const { 1963 const auto& col = table()->event_id(); 1964 return col.GetAtIdx( 1965 iterator_.StorageIndexForColumn(col.index_in_table())); 1966 } ts()1967 ColumnType::ts::type ts() const { 1968 const auto& col = table()->ts(); 1969 return col.GetAtIdx( 1970 iterator_.StorageIndexForColumn(col.index_in_table())); 1971 } arg_set_id()1972 ColumnType::arg_set_id::type arg_set_id() const { 1973 const auto& col = table()->arg_set_id(); 1974 return col.GetAtIdx( 1975 iterator_.StorageIndexForColumn(col.index_in_table())); 1976 } base64_proto()1977 ColumnType::base64_proto::type base64_proto() const { 1978 const auto& col = table()->base64_proto(); 1979 return col.GetAtIdx( 1980 iterator_.StorageIndexForColumn(col.index_in_table())); 1981 } base64_proto_id()1982 ColumnType::base64_proto_id::type base64_proto_id() const { 1983 const auto& col = table()->base64_proto_id(); 1984 return col.GetAtIdx( 1985 iterator_.StorageIndexForColumn(col.index_in_table())); 1986 } 1987 1988 protected: ConstIterator(const AndroidKeyEventsTable * table,Table::Iterator iterator)1989 explicit ConstIterator(const AndroidKeyEventsTable* table, 1990 Table::Iterator iterator) 1991 : AbstractConstIterator(table, std::move(iterator)) {} 1992 CurrentRowNumber()1993 uint32_t CurrentRowNumber() const { 1994 return iterator_.StorageIndexForLastOverlay(); 1995 } 1996 1997 private: 1998 friend class AndroidKeyEventsTable; 1999 friend class macros_internal::AbstractConstIterator< 2000 ConstIterator, AndroidKeyEventsTable, RowNumber, ConstRowReference>; 2001 }; 2002 class Iterator : public ConstIterator { 2003 public: row_reference()2004 RowReference row_reference() const { 2005 return {const_cast<AndroidKeyEventsTable*>(table()), CurrentRowNumber()}; 2006 } 2007 2008 private: 2009 friend class AndroidKeyEventsTable; 2010 Iterator(AndroidKeyEventsTable * table,Table::Iterator iterator)2011 explicit Iterator(AndroidKeyEventsTable* table, Table::Iterator iterator) 2012 : ConstIterator(table, std::move(iterator)) {} 2013 }; 2014 2015 struct IdAndRow { 2016 Id id; 2017 uint32_t row; 2018 RowReference row_reference; 2019 RowNumber row_number; 2020 }; 2021 GetColumns(AndroidKeyEventsTable * self,const macros_internal::MacroTable * parent)2022 static std::vector<ColumnLegacy> GetColumns( 2023 AndroidKeyEventsTable* self, 2024 const macros_internal::MacroTable* parent) { 2025 std::vector<ColumnLegacy> columns = 2026 CopyColumnsFromParentOrAddRootColumns(self, parent); 2027 uint32_t olay_idx = OverlayCount(parent); 2028 AddColumnToVector(columns, "event_id", &self->event_id_, ColumnFlag::event_id, 2029 static_cast<uint32_t>(columns.size()), olay_idx); 2030 AddColumnToVector(columns, "ts", &self->ts_, ColumnFlag::ts, 2031 static_cast<uint32_t>(columns.size()), olay_idx); 2032 AddColumnToVector(columns, "arg_set_id", &self->arg_set_id_, ColumnFlag::arg_set_id, 2033 static_cast<uint32_t>(columns.size()), olay_idx); 2034 AddColumnToVector(columns, "base64_proto", &self->base64_proto_, ColumnFlag::base64_proto, 2035 static_cast<uint32_t>(columns.size()), olay_idx); 2036 AddColumnToVector(columns, "base64_proto_id", &self->base64_proto_id_, ColumnFlag::base64_proto_id, 2037 static_cast<uint32_t>(columns.size()), olay_idx); 2038 return columns; 2039 } 2040 AndroidKeyEventsTable(StringPool * pool)2041 PERFETTO_NO_INLINE explicit AndroidKeyEventsTable(StringPool* pool) 2042 : macros_internal::MacroTable( 2043 pool, 2044 GetColumns(this, nullptr), 2045 nullptr), 2046 event_id_(ColumnStorage<ColumnType::event_id::stored_type>::Create<false>()), 2047 ts_(ColumnStorage<ColumnType::ts::stored_type>::Create<false>()), 2048 arg_set_id_(ColumnStorage<ColumnType::arg_set_id::stored_type>::Create<false>()), 2049 base64_proto_(ColumnStorage<ColumnType::base64_proto::stored_type>::Create<false>()), 2050 base64_proto_id_(ColumnStorage<ColumnType::base64_proto_id::stored_type>::Create<false>()) 2051 , 2052 id_storage_layer_(new column::IdStorage()), 2053 type_storage_layer_( 2054 new column::StringStorage(string_pool(), &type_.vector())), 2055 event_id_storage_layer_( 2056 new column::NumericStorage<ColumnType::event_id::non_optional_stored_type>( 2057 &event_id_.vector(), 2058 ColumnTypeHelper<ColumnType::event_id::stored_type>::ToColumnType(), 2059 false)), 2060 ts_storage_layer_( 2061 new column::NumericStorage<ColumnType::ts::non_optional_stored_type>( 2062 &ts_.vector(), 2063 ColumnTypeHelper<ColumnType::ts::stored_type>::ToColumnType(), 2064 false)), 2065 arg_set_id_storage_layer_( 2066 new column::NumericStorage<ColumnType::arg_set_id::non_optional_stored_type>( 2067 &arg_set_id_.vector(), 2068 ColumnTypeHelper<ColumnType::arg_set_id::stored_type>::ToColumnType(), 2069 false)), 2070 base64_proto_storage_layer_( 2071 new column::StringStorage(string_pool(), &base64_proto_.vector())), 2072 base64_proto_id_storage_layer_( 2073 new column::NumericStorage<ColumnType::base64_proto_id::non_optional_stored_type>( 2074 &base64_proto_id_.non_null_vector(), 2075 ColumnTypeHelper<ColumnType::base64_proto_id::stored_type>::ToColumnType(), 2076 false)) 2077 , 2078 base64_proto_id_null_layer_(new column::NullOverlay(base64_proto_id_.bv())) { 2079 static_assert( 2080 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::event_id::stored_type>( 2081 ColumnFlag::event_id), 2082 "Column type and flag combination is not valid"); 2083 static_assert( 2084 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::ts::stored_type>( 2085 ColumnFlag::ts), 2086 "Column type and flag combination is not valid"); 2087 static_assert( 2088 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::arg_set_id::stored_type>( 2089 ColumnFlag::arg_set_id), 2090 "Column type and flag combination is not valid"); 2091 static_assert( 2092 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::base64_proto::stored_type>( 2093 ColumnFlag::base64_proto), 2094 "Column type and flag combination is not valid"); 2095 static_assert( 2096 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::base64_proto_id::stored_type>( 2097 ColumnFlag::base64_proto_id), 2098 "Column type and flag combination is not valid"); 2099 OnConstructionCompletedRegularConstructor( 2100 {id_storage_layer_,type_storage_layer_,event_id_storage_layer_,ts_storage_layer_,arg_set_id_storage_layer_,base64_proto_storage_layer_,base64_proto_id_storage_layer_}, 2101 {{},{},{},{},{},{},base64_proto_id_null_layer_}); 2102 } 2103 ~AndroidKeyEventsTable() override; 2104 Name()2105 static const char* Name() { return "__intrinsic_android_key_events"; } 2106 ComputeStaticSchema()2107 static Table::Schema ComputeStaticSchema() { 2108 Table::Schema schema; 2109 schema.columns.emplace_back(Table::Schema::Column{ 2110 "id", SqlValue::Type::kLong, true, true, false, false}); 2111 schema.columns.emplace_back(Table::Schema::Column{ 2112 "type", SqlValue::Type::kString, false, false, false, false}); 2113 schema.columns.emplace_back(Table::Schema::Column{ 2114 "event_id", ColumnType::event_id::SqlValueType(), false, 2115 false, 2116 false, 2117 false}); 2118 schema.columns.emplace_back(Table::Schema::Column{ 2119 "ts", ColumnType::ts::SqlValueType(), false, 2120 false, 2121 false, 2122 false}); 2123 schema.columns.emplace_back(Table::Schema::Column{ 2124 "arg_set_id", ColumnType::arg_set_id::SqlValueType(), false, 2125 false, 2126 false, 2127 false}); 2128 schema.columns.emplace_back(Table::Schema::Column{ 2129 "base64_proto", ColumnType::base64_proto::SqlValueType(), false, 2130 false, 2131 false, 2132 false}); 2133 schema.columns.emplace_back(Table::Schema::Column{ 2134 "base64_proto_id", ColumnType::base64_proto_id::SqlValueType(), false, 2135 false, 2136 false, 2137 false}); 2138 return schema; 2139 } 2140 IterateRows()2141 ConstIterator IterateRows() const { 2142 return ConstIterator(this, Table::IterateRows()); 2143 } 2144 IterateRows()2145 Iterator IterateRows() { return Iterator(this, Table::IterateRows()); } 2146 FilterToIterator(const Query & q)2147 ConstIterator FilterToIterator(const Query& q) const { 2148 return ConstIterator(this, QueryToIterator(q)); 2149 } 2150 FilterToIterator(const Query & q)2151 Iterator FilterToIterator(const Query& q) { 2152 return Iterator(this, QueryToIterator(q)); 2153 } 2154 ShrinkToFit()2155 void ShrinkToFit() { 2156 type_.ShrinkToFit(); 2157 event_id_.ShrinkToFit(); 2158 ts_.ShrinkToFit(); 2159 arg_set_id_.ShrinkToFit(); 2160 base64_proto_.ShrinkToFit(); 2161 base64_proto_id_.ShrinkToFit(); 2162 } 2163 2164 ConstRowReference operator[](uint32_t r) const { 2165 return ConstRowReference(this, r); 2166 } 2167 RowReference operator[](uint32_t r) { return RowReference(this, r); } 2168 ConstRowReference operator[](RowNumber r) const { 2169 return ConstRowReference(this, r.row_number()); 2170 } 2171 RowReference operator[](RowNumber r) { 2172 return RowReference(this, r.row_number()); 2173 } 2174 FindById(Id find_id)2175 std::optional<ConstRowReference> FindById(Id find_id) const { 2176 std::optional<uint32_t> row = id().IndexOf(find_id); 2177 return row ? std::make_optional(ConstRowReference(this, *row)) 2178 : std::nullopt; 2179 } 2180 FindById(Id find_id)2181 std::optional<RowReference> FindById(Id find_id) { 2182 std::optional<uint32_t> row = id().IndexOf(find_id); 2183 return row ? std::make_optional(RowReference(this, *row)) : std::nullopt; 2184 } 2185 Insert(const Row & row)2186 IdAndRow Insert(const Row& row) { 2187 uint32_t row_number = row_count(); 2188 Id id = Id{row_number}; 2189 type_.Append(string_pool()->InternString(row.type())); 2190 mutable_event_id()->Append(row.event_id); 2191 mutable_ts()->Append(row.ts); 2192 mutable_arg_set_id()->Append(row.arg_set_id); 2193 mutable_base64_proto()->Append(row.base64_proto); 2194 mutable_base64_proto_id()->Append(row.base64_proto_id); 2195 UpdateSelfOverlayAfterInsert(); 2196 return IdAndRow{id, row_number, RowReference(this, row_number), 2197 RowNumber(row_number)}; 2198 } 2199 2200 2201 id()2202 const IdColumn<AndroidKeyEventsTable::Id>& id() const { 2203 return static_cast<const ColumnType::id&>(columns()[ColumnIndex::id]); 2204 } type()2205 const TypedColumn<StringPool::Id>& type() const { 2206 return static_cast<const ColumnType::type&>(columns()[ColumnIndex::type]); 2207 } event_id()2208 const TypedColumn<uint32_t>& event_id() const { 2209 return static_cast<const ColumnType::event_id&>(columns()[ColumnIndex::event_id]); 2210 } ts()2211 const TypedColumn<int64_t>& ts() const { 2212 return static_cast<const ColumnType::ts&>(columns()[ColumnIndex::ts]); 2213 } arg_set_id()2214 const TypedColumn<uint32_t>& arg_set_id() const { 2215 return static_cast<const ColumnType::arg_set_id&>(columns()[ColumnIndex::arg_set_id]); 2216 } base64_proto()2217 const TypedColumn<StringPool::Id>& base64_proto() const { 2218 return static_cast<const ColumnType::base64_proto&>(columns()[ColumnIndex::base64_proto]); 2219 } base64_proto_id()2220 const TypedColumn<std::optional<uint32_t>>& base64_proto_id() const { 2221 return static_cast<const ColumnType::base64_proto_id&>(columns()[ColumnIndex::base64_proto_id]); 2222 } 2223 mutable_event_id()2224 TypedColumn<uint32_t>* mutable_event_id() { 2225 return static_cast<ColumnType::event_id*>( 2226 GetColumn(ColumnIndex::event_id)); 2227 } mutable_ts()2228 TypedColumn<int64_t>* mutable_ts() { 2229 return static_cast<ColumnType::ts*>( 2230 GetColumn(ColumnIndex::ts)); 2231 } mutable_arg_set_id()2232 TypedColumn<uint32_t>* mutable_arg_set_id() { 2233 return static_cast<ColumnType::arg_set_id*>( 2234 GetColumn(ColumnIndex::arg_set_id)); 2235 } mutable_base64_proto()2236 TypedColumn<StringPool::Id>* mutable_base64_proto() { 2237 return static_cast<ColumnType::base64_proto*>( 2238 GetColumn(ColumnIndex::base64_proto)); 2239 } mutable_base64_proto_id()2240 TypedColumn<std::optional<uint32_t>>* mutable_base64_proto_id() { 2241 return static_cast<ColumnType::base64_proto_id*>( 2242 GetColumn(ColumnIndex::base64_proto_id)); 2243 } 2244 2245 private: 2246 2247 2248 ColumnStorage<ColumnType::event_id::stored_type> event_id_; 2249 ColumnStorage<ColumnType::ts::stored_type> ts_; 2250 ColumnStorage<ColumnType::arg_set_id::stored_type> arg_set_id_; 2251 ColumnStorage<ColumnType::base64_proto::stored_type> base64_proto_; 2252 ColumnStorage<ColumnType::base64_proto_id::stored_type> base64_proto_id_; 2253 2254 RefPtr<column::StorageLayer> id_storage_layer_; 2255 RefPtr<column::StorageLayer> type_storage_layer_; 2256 RefPtr<column::StorageLayer> event_id_storage_layer_; 2257 RefPtr<column::StorageLayer> ts_storage_layer_; 2258 RefPtr<column::StorageLayer> arg_set_id_storage_layer_; 2259 RefPtr<column::StorageLayer> base64_proto_storage_layer_; 2260 RefPtr<column::StorageLayer> base64_proto_id_storage_layer_; 2261 2262 RefPtr<column::OverlayLayer> base64_proto_id_null_layer_; 2263 }; 2264 2265 2266 class AndroidMotionEventsTable : public macros_internal::MacroTable { 2267 public: 2268 static constexpr uint32_t kColumnCount = 7; 2269 2270 struct Id : public BaseId { 2271 Id() = default; IdId2272 explicit constexpr Id(uint32_t v) : BaseId(v) {} 2273 }; 2274 static_assert(std::is_trivially_destructible_v<Id>, 2275 "Inheritance used without trivial destruction"); 2276 2277 struct ColumnIndex { 2278 static constexpr uint32_t id = 0; 2279 static constexpr uint32_t type = 1; 2280 static constexpr uint32_t event_id = 2; 2281 static constexpr uint32_t ts = 3; 2282 static constexpr uint32_t arg_set_id = 4; 2283 static constexpr uint32_t base64_proto = 5; 2284 static constexpr uint32_t base64_proto_id = 6; 2285 }; 2286 struct ColumnType { 2287 using id = IdColumn<AndroidMotionEventsTable::Id>; 2288 using type = TypedColumn<StringPool::Id>; 2289 using event_id = TypedColumn<uint32_t>; 2290 using ts = TypedColumn<int64_t>; 2291 using arg_set_id = TypedColumn<uint32_t>; 2292 using base64_proto = TypedColumn<StringPool::Id>; 2293 using base64_proto_id = TypedColumn<std::optional<uint32_t>>; 2294 }; 2295 struct Row : public macros_internal::RootParentTable::Row { 2296 Row(uint32_t in_event_id = {}, 2297 int64_t in_ts = {}, 2298 uint32_t in_arg_set_id = {}, 2299 StringPool::Id in_base64_proto = {}, 2300 std::optional<uint32_t> in_base64_proto_id = {}, 2301 std::nullptr_t = nullptr) RowRow2302 : macros_internal::RootParentTable::Row(), 2303 event_id(in_event_id), 2304 ts(in_ts), 2305 arg_set_id(in_arg_set_id), 2306 base64_proto(in_base64_proto), 2307 base64_proto_id(in_base64_proto_id) { 2308 type_ = "__intrinsic_android_motion_events"; 2309 } 2310 uint32_t event_id; 2311 int64_t ts; 2312 uint32_t arg_set_id; 2313 StringPool::Id base64_proto; 2314 std::optional<uint32_t> base64_proto_id; 2315 2316 bool operator==(const AndroidMotionEventsTable::Row& other) const { 2317 return type() == other.type() && ColumnType::event_id::Equals(event_id, other.event_id) && 2318 ColumnType::ts::Equals(ts, other.ts) && 2319 ColumnType::arg_set_id::Equals(arg_set_id, other.arg_set_id) && 2320 ColumnType::base64_proto::Equals(base64_proto, other.base64_proto) && 2321 ColumnType::base64_proto_id::Equals(base64_proto_id, other.base64_proto_id); 2322 } 2323 }; 2324 struct ColumnFlag { 2325 static constexpr uint32_t event_id = ColumnType::event_id::default_flags(); 2326 static constexpr uint32_t ts = ColumnType::ts::default_flags(); 2327 static constexpr uint32_t arg_set_id = ColumnType::arg_set_id::default_flags(); 2328 static constexpr uint32_t base64_proto = ColumnType::base64_proto::default_flags(); 2329 static constexpr uint32_t base64_proto_id = ColumnType::base64_proto_id::default_flags(); 2330 }; 2331 2332 class RowNumber; 2333 class ConstRowReference; 2334 class RowReference; 2335 2336 class RowNumber : public macros_internal::AbstractRowNumber< 2337 AndroidMotionEventsTable, ConstRowReference, RowReference> { 2338 public: RowNumber(uint32_t row_number)2339 explicit RowNumber(uint32_t row_number) 2340 : AbstractRowNumber(row_number) {} 2341 }; 2342 static_assert(std::is_trivially_destructible_v<RowNumber>, 2343 "Inheritance used without trivial destruction"); 2344 2345 class ConstRowReference : public macros_internal::AbstractConstRowReference< 2346 AndroidMotionEventsTable, RowNumber> { 2347 public: ConstRowReference(const AndroidMotionEventsTable * table,uint32_t row_number)2348 ConstRowReference(const AndroidMotionEventsTable* table, uint32_t row_number) 2349 : AbstractConstRowReference(table, row_number) {} 2350 id()2351 ColumnType::id::type id() const { 2352 return table()->id()[row_number_]; 2353 } type()2354 ColumnType::type::type type() const { 2355 return table()->type()[row_number_]; 2356 } event_id()2357 ColumnType::event_id::type event_id() const { 2358 return table()->event_id()[row_number_]; 2359 } ts()2360 ColumnType::ts::type ts() const { 2361 return table()->ts()[row_number_]; 2362 } arg_set_id()2363 ColumnType::arg_set_id::type arg_set_id() const { 2364 return table()->arg_set_id()[row_number_]; 2365 } base64_proto()2366 ColumnType::base64_proto::type base64_proto() const { 2367 return table()->base64_proto()[row_number_]; 2368 } base64_proto_id()2369 ColumnType::base64_proto_id::type base64_proto_id() const { 2370 return table()->base64_proto_id()[row_number_]; 2371 } 2372 }; 2373 static_assert(std::is_trivially_destructible_v<ConstRowReference>, 2374 "Inheritance used without trivial destruction"); 2375 class RowReference : public ConstRowReference { 2376 public: RowReference(const AndroidMotionEventsTable * table,uint32_t row_number)2377 RowReference(const AndroidMotionEventsTable* table, uint32_t row_number) 2378 : ConstRowReference(table, row_number) {} 2379 set_event_id(ColumnType::event_id::non_optional_type v)2380 void set_event_id( 2381 ColumnType::event_id::non_optional_type v) { 2382 return mutable_table()->mutable_event_id()->Set(row_number_, v); 2383 } set_ts(ColumnType::ts::non_optional_type v)2384 void set_ts( 2385 ColumnType::ts::non_optional_type v) { 2386 return mutable_table()->mutable_ts()->Set(row_number_, v); 2387 } set_arg_set_id(ColumnType::arg_set_id::non_optional_type v)2388 void set_arg_set_id( 2389 ColumnType::arg_set_id::non_optional_type v) { 2390 return mutable_table()->mutable_arg_set_id()->Set(row_number_, v); 2391 } set_base64_proto(ColumnType::base64_proto::non_optional_type v)2392 void set_base64_proto( 2393 ColumnType::base64_proto::non_optional_type v) { 2394 return mutable_table()->mutable_base64_proto()->Set(row_number_, v); 2395 } set_base64_proto_id(ColumnType::base64_proto_id::non_optional_type v)2396 void set_base64_proto_id( 2397 ColumnType::base64_proto_id::non_optional_type v) { 2398 return mutable_table()->mutable_base64_proto_id()->Set(row_number_, v); 2399 } 2400 2401 private: mutable_table()2402 AndroidMotionEventsTable* mutable_table() const { 2403 return const_cast<AndroidMotionEventsTable*>(table()); 2404 } 2405 }; 2406 static_assert(std::is_trivially_destructible_v<RowReference>, 2407 "Inheritance used without trivial destruction"); 2408 2409 class ConstIterator; 2410 class ConstIterator : public macros_internal::AbstractConstIterator< 2411 ConstIterator, AndroidMotionEventsTable, RowNumber, ConstRowReference> { 2412 public: id()2413 ColumnType::id::type id() const { 2414 const auto& col = table()->id(); 2415 return col.GetAtIdx( 2416 iterator_.StorageIndexForColumn(col.index_in_table())); 2417 } type()2418 ColumnType::type::type type() const { 2419 const auto& col = table()->type(); 2420 return col.GetAtIdx( 2421 iterator_.StorageIndexForColumn(col.index_in_table())); 2422 } event_id()2423 ColumnType::event_id::type event_id() const { 2424 const auto& col = table()->event_id(); 2425 return col.GetAtIdx( 2426 iterator_.StorageIndexForColumn(col.index_in_table())); 2427 } ts()2428 ColumnType::ts::type ts() const { 2429 const auto& col = table()->ts(); 2430 return col.GetAtIdx( 2431 iterator_.StorageIndexForColumn(col.index_in_table())); 2432 } arg_set_id()2433 ColumnType::arg_set_id::type arg_set_id() const { 2434 const auto& col = table()->arg_set_id(); 2435 return col.GetAtIdx( 2436 iterator_.StorageIndexForColumn(col.index_in_table())); 2437 } base64_proto()2438 ColumnType::base64_proto::type base64_proto() const { 2439 const auto& col = table()->base64_proto(); 2440 return col.GetAtIdx( 2441 iterator_.StorageIndexForColumn(col.index_in_table())); 2442 } base64_proto_id()2443 ColumnType::base64_proto_id::type base64_proto_id() const { 2444 const auto& col = table()->base64_proto_id(); 2445 return col.GetAtIdx( 2446 iterator_.StorageIndexForColumn(col.index_in_table())); 2447 } 2448 2449 protected: ConstIterator(const AndroidMotionEventsTable * table,Table::Iterator iterator)2450 explicit ConstIterator(const AndroidMotionEventsTable* table, 2451 Table::Iterator iterator) 2452 : AbstractConstIterator(table, std::move(iterator)) {} 2453 CurrentRowNumber()2454 uint32_t CurrentRowNumber() const { 2455 return iterator_.StorageIndexForLastOverlay(); 2456 } 2457 2458 private: 2459 friend class AndroidMotionEventsTable; 2460 friend class macros_internal::AbstractConstIterator< 2461 ConstIterator, AndroidMotionEventsTable, RowNumber, ConstRowReference>; 2462 }; 2463 class Iterator : public ConstIterator { 2464 public: row_reference()2465 RowReference row_reference() const { 2466 return {const_cast<AndroidMotionEventsTable*>(table()), CurrentRowNumber()}; 2467 } 2468 2469 private: 2470 friend class AndroidMotionEventsTable; 2471 Iterator(AndroidMotionEventsTable * table,Table::Iterator iterator)2472 explicit Iterator(AndroidMotionEventsTable* table, Table::Iterator iterator) 2473 : ConstIterator(table, std::move(iterator)) {} 2474 }; 2475 2476 struct IdAndRow { 2477 Id id; 2478 uint32_t row; 2479 RowReference row_reference; 2480 RowNumber row_number; 2481 }; 2482 GetColumns(AndroidMotionEventsTable * self,const macros_internal::MacroTable * parent)2483 static std::vector<ColumnLegacy> GetColumns( 2484 AndroidMotionEventsTable* self, 2485 const macros_internal::MacroTable* parent) { 2486 std::vector<ColumnLegacy> columns = 2487 CopyColumnsFromParentOrAddRootColumns(self, parent); 2488 uint32_t olay_idx = OverlayCount(parent); 2489 AddColumnToVector(columns, "event_id", &self->event_id_, ColumnFlag::event_id, 2490 static_cast<uint32_t>(columns.size()), olay_idx); 2491 AddColumnToVector(columns, "ts", &self->ts_, ColumnFlag::ts, 2492 static_cast<uint32_t>(columns.size()), olay_idx); 2493 AddColumnToVector(columns, "arg_set_id", &self->arg_set_id_, ColumnFlag::arg_set_id, 2494 static_cast<uint32_t>(columns.size()), olay_idx); 2495 AddColumnToVector(columns, "base64_proto", &self->base64_proto_, ColumnFlag::base64_proto, 2496 static_cast<uint32_t>(columns.size()), olay_idx); 2497 AddColumnToVector(columns, "base64_proto_id", &self->base64_proto_id_, ColumnFlag::base64_proto_id, 2498 static_cast<uint32_t>(columns.size()), olay_idx); 2499 return columns; 2500 } 2501 AndroidMotionEventsTable(StringPool * pool)2502 PERFETTO_NO_INLINE explicit AndroidMotionEventsTable(StringPool* pool) 2503 : macros_internal::MacroTable( 2504 pool, 2505 GetColumns(this, nullptr), 2506 nullptr), 2507 event_id_(ColumnStorage<ColumnType::event_id::stored_type>::Create<false>()), 2508 ts_(ColumnStorage<ColumnType::ts::stored_type>::Create<false>()), 2509 arg_set_id_(ColumnStorage<ColumnType::arg_set_id::stored_type>::Create<false>()), 2510 base64_proto_(ColumnStorage<ColumnType::base64_proto::stored_type>::Create<false>()), 2511 base64_proto_id_(ColumnStorage<ColumnType::base64_proto_id::stored_type>::Create<false>()) 2512 , 2513 id_storage_layer_(new column::IdStorage()), 2514 type_storage_layer_( 2515 new column::StringStorage(string_pool(), &type_.vector())), 2516 event_id_storage_layer_( 2517 new column::NumericStorage<ColumnType::event_id::non_optional_stored_type>( 2518 &event_id_.vector(), 2519 ColumnTypeHelper<ColumnType::event_id::stored_type>::ToColumnType(), 2520 false)), 2521 ts_storage_layer_( 2522 new column::NumericStorage<ColumnType::ts::non_optional_stored_type>( 2523 &ts_.vector(), 2524 ColumnTypeHelper<ColumnType::ts::stored_type>::ToColumnType(), 2525 false)), 2526 arg_set_id_storage_layer_( 2527 new column::NumericStorage<ColumnType::arg_set_id::non_optional_stored_type>( 2528 &arg_set_id_.vector(), 2529 ColumnTypeHelper<ColumnType::arg_set_id::stored_type>::ToColumnType(), 2530 false)), 2531 base64_proto_storage_layer_( 2532 new column::StringStorage(string_pool(), &base64_proto_.vector())), 2533 base64_proto_id_storage_layer_( 2534 new column::NumericStorage<ColumnType::base64_proto_id::non_optional_stored_type>( 2535 &base64_proto_id_.non_null_vector(), 2536 ColumnTypeHelper<ColumnType::base64_proto_id::stored_type>::ToColumnType(), 2537 false)) 2538 , 2539 base64_proto_id_null_layer_(new column::NullOverlay(base64_proto_id_.bv())) { 2540 static_assert( 2541 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::event_id::stored_type>( 2542 ColumnFlag::event_id), 2543 "Column type and flag combination is not valid"); 2544 static_assert( 2545 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::ts::stored_type>( 2546 ColumnFlag::ts), 2547 "Column type and flag combination is not valid"); 2548 static_assert( 2549 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::arg_set_id::stored_type>( 2550 ColumnFlag::arg_set_id), 2551 "Column type and flag combination is not valid"); 2552 static_assert( 2553 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::base64_proto::stored_type>( 2554 ColumnFlag::base64_proto), 2555 "Column type and flag combination is not valid"); 2556 static_assert( 2557 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::base64_proto_id::stored_type>( 2558 ColumnFlag::base64_proto_id), 2559 "Column type and flag combination is not valid"); 2560 OnConstructionCompletedRegularConstructor( 2561 {id_storage_layer_,type_storage_layer_,event_id_storage_layer_,ts_storage_layer_,arg_set_id_storage_layer_,base64_proto_storage_layer_,base64_proto_id_storage_layer_}, 2562 {{},{},{},{},{},{},base64_proto_id_null_layer_}); 2563 } 2564 ~AndroidMotionEventsTable() override; 2565 Name()2566 static const char* Name() { return "__intrinsic_android_motion_events"; } 2567 ComputeStaticSchema()2568 static Table::Schema ComputeStaticSchema() { 2569 Table::Schema schema; 2570 schema.columns.emplace_back(Table::Schema::Column{ 2571 "id", SqlValue::Type::kLong, true, true, false, false}); 2572 schema.columns.emplace_back(Table::Schema::Column{ 2573 "type", SqlValue::Type::kString, false, false, false, false}); 2574 schema.columns.emplace_back(Table::Schema::Column{ 2575 "event_id", ColumnType::event_id::SqlValueType(), false, 2576 false, 2577 false, 2578 false}); 2579 schema.columns.emplace_back(Table::Schema::Column{ 2580 "ts", ColumnType::ts::SqlValueType(), false, 2581 false, 2582 false, 2583 false}); 2584 schema.columns.emplace_back(Table::Schema::Column{ 2585 "arg_set_id", ColumnType::arg_set_id::SqlValueType(), false, 2586 false, 2587 false, 2588 false}); 2589 schema.columns.emplace_back(Table::Schema::Column{ 2590 "base64_proto", ColumnType::base64_proto::SqlValueType(), false, 2591 false, 2592 false, 2593 false}); 2594 schema.columns.emplace_back(Table::Schema::Column{ 2595 "base64_proto_id", ColumnType::base64_proto_id::SqlValueType(), false, 2596 false, 2597 false, 2598 false}); 2599 return schema; 2600 } 2601 IterateRows()2602 ConstIterator IterateRows() const { 2603 return ConstIterator(this, Table::IterateRows()); 2604 } 2605 IterateRows()2606 Iterator IterateRows() { return Iterator(this, Table::IterateRows()); } 2607 FilterToIterator(const Query & q)2608 ConstIterator FilterToIterator(const Query& q) const { 2609 return ConstIterator(this, QueryToIterator(q)); 2610 } 2611 FilterToIterator(const Query & q)2612 Iterator FilterToIterator(const Query& q) { 2613 return Iterator(this, QueryToIterator(q)); 2614 } 2615 ShrinkToFit()2616 void ShrinkToFit() { 2617 type_.ShrinkToFit(); 2618 event_id_.ShrinkToFit(); 2619 ts_.ShrinkToFit(); 2620 arg_set_id_.ShrinkToFit(); 2621 base64_proto_.ShrinkToFit(); 2622 base64_proto_id_.ShrinkToFit(); 2623 } 2624 2625 ConstRowReference operator[](uint32_t r) const { 2626 return ConstRowReference(this, r); 2627 } 2628 RowReference operator[](uint32_t r) { return RowReference(this, r); } 2629 ConstRowReference operator[](RowNumber r) const { 2630 return ConstRowReference(this, r.row_number()); 2631 } 2632 RowReference operator[](RowNumber r) { 2633 return RowReference(this, r.row_number()); 2634 } 2635 FindById(Id find_id)2636 std::optional<ConstRowReference> FindById(Id find_id) const { 2637 std::optional<uint32_t> row = id().IndexOf(find_id); 2638 return row ? std::make_optional(ConstRowReference(this, *row)) 2639 : std::nullopt; 2640 } 2641 FindById(Id find_id)2642 std::optional<RowReference> FindById(Id find_id) { 2643 std::optional<uint32_t> row = id().IndexOf(find_id); 2644 return row ? std::make_optional(RowReference(this, *row)) : std::nullopt; 2645 } 2646 Insert(const Row & row)2647 IdAndRow Insert(const Row& row) { 2648 uint32_t row_number = row_count(); 2649 Id id = Id{row_number}; 2650 type_.Append(string_pool()->InternString(row.type())); 2651 mutable_event_id()->Append(row.event_id); 2652 mutable_ts()->Append(row.ts); 2653 mutable_arg_set_id()->Append(row.arg_set_id); 2654 mutable_base64_proto()->Append(row.base64_proto); 2655 mutable_base64_proto_id()->Append(row.base64_proto_id); 2656 UpdateSelfOverlayAfterInsert(); 2657 return IdAndRow{id, row_number, RowReference(this, row_number), 2658 RowNumber(row_number)}; 2659 } 2660 2661 2662 id()2663 const IdColumn<AndroidMotionEventsTable::Id>& id() const { 2664 return static_cast<const ColumnType::id&>(columns()[ColumnIndex::id]); 2665 } type()2666 const TypedColumn<StringPool::Id>& type() const { 2667 return static_cast<const ColumnType::type&>(columns()[ColumnIndex::type]); 2668 } event_id()2669 const TypedColumn<uint32_t>& event_id() const { 2670 return static_cast<const ColumnType::event_id&>(columns()[ColumnIndex::event_id]); 2671 } ts()2672 const TypedColumn<int64_t>& ts() const { 2673 return static_cast<const ColumnType::ts&>(columns()[ColumnIndex::ts]); 2674 } arg_set_id()2675 const TypedColumn<uint32_t>& arg_set_id() const { 2676 return static_cast<const ColumnType::arg_set_id&>(columns()[ColumnIndex::arg_set_id]); 2677 } base64_proto()2678 const TypedColumn<StringPool::Id>& base64_proto() const { 2679 return static_cast<const ColumnType::base64_proto&>(columns()[ColumnIndex::base64_proto]); 2680 } base64_proto_id()2681 const TypedColumn<std::optional<uint32_t>>& base64_proto_id() const { 2682 return static_cast<const ColumnType::base64_proto_id&>(columns()[ColumnIndex::base64_proto_id]); 2683 } 2684 mutable_event_id()2685 TypedColumn<uint32_t>* mutable_event_id() { 2686 return static_cast<ColumnType::event_id*>( 2687 GetColumn(ColumnIndex::event_id)); 2688 } mutable_ts()2689 TypedColumn<int64_t>* mutable_ts() { 2690 return static_cast<ColumnType::ts*>( 2691 GetColumn(ColumnIndex::ts)); 2692 } mutable_arg_set_id()2693 TypedColumn<uint32_t>* mutable_arg_set_id() { 2694 return static_cast<ColumnType::arg_set_id*>( 2695 GetColumn(ColumnIndex::arg_set_id)); 2696 } mutable_base64_proto()2697 TypedColumn<StringPool::Id>* mutable_base64_proto() { 2698 return static_cast<ColumnType::base64_proto*>( 2699 GetColumn(ColumnIndex::base64_proto)); 2700 } mutable_base64_proto_id()2701 TypedColumn<std::optional<uint32_t>>* mutable_base64_proto_id() { 2702 return static_cast<ColumnType::base64_proto_id*>( 2703 GetColumn(ColumnIndex::base64_proto_id)); 2704 } 2705 2706 private: 2707 2708 2709 ColumnStorage<ColumnType::event_id::stored_type> event_id_; 2710 ColumnStorage<ColumnType::ts::stored_type> ts_; 2711 ColumnStorage<ColumnType::arg_set_id::stored_type> arg_set_id_; 2712 ColumnStorage<ColumnType::base64_proto::stored_type> base64_proto_; 2713 ColumnStorage<ColumnType::base64_proto_id::stored_type> base64_proto_id_; 2714 2715 RefPtr<column::StorageLayer> id_storage_layer_; 2716 RefPtr<column::StorageLayer> type_storage_layer_; 2717 RefPtr<column::StorageLayer> event_id_storage_layer_; 2718 RefPtr<column::StorageLayer> ts_storage_layer_; 2719 RefPtr<column::StorageLayer> arg_set_id_storage_layer_; 2720 RefPtr<column::StorageLayer> base64_proto_storage_layer_; 2721 RefPtr<column::StorageLayer> base64_proto_id_storage_layer_; 2722 2723 RefPtr<column::OverlayLayer> base64_proto_id_null_layer_; 2724 }; 2725 2726 2727 class AndroidInputEventDispatchTable : public macros_internal::MacroTable { 2728 public: 2729 static constexpr uint32_t kColumnCount = 8; 2730 2731 struct Id : public BaseId { 2732 Id() = default; IdId2733 explicit constexpr Id(uint32_t v) : BaseId(v) {} 2734 }; 2735 static_assert(std::is_trivially_destructible_v<Id>, 2736 "Inheritance used without trivial destruction"); 2737 2738 struct ColumnIndex { 2739 static constexpr uint32_t id = 0; 2740 static constexpr uint32_t type = 1; 2741 static constexpr uint32_t event_id = 2; 2742 static constexpr uint32_t arg_set_id = 3; 2743 static constexpr uint32_t vsync_id = 4; 2744 static constexpr uint32_t window_id = 5; 2745 static constexpr uint32_t base64_proto = 6; 2746 static constexpr uint32_t base64_proto_id = 7; 2747 }; 2748 struct ColumnType { 2749 using id = IdColumn<AndroidInputEventDispatchTable::Id>; 2750 using type = TypedColumn<StringPool::Id>; 2751 using event_id = TypedColumn<uint32_t>; 2752 using arg_set_id = TypedColumn<uint32_t>; 2753 using vsync_id = TypedColumn<int64_t>; 2754 using window_id = TypedColumn<int32_t>; 2755 using base64_proto = TypedColumn<StringPool::Id>; 2756 using base64_proto_id = TypedColumn<std::optional<uint32_t>>; 2757 }; 2758 struct Row : public macros_internal::RootParentTable::Row { 2759 Row(uint32_t in_event_id = {}, 2760 uint32_t in_arg_set_id = {}, 2761 int64_t in_vsync_id = {}, 2762 int32_t in_window_id = {}, 2763 StringPool::Id in_base64_proto = {}, 2764 std::optional<uint32_t> in_base64_proto_id = {}, 2765 std::nullptr_t = nullptr) RowRow2766 : macros_internal::RootParentTable::Row(), 2767 event_id(in_event_id), 2768 arg_set_id(in_arg_set_id), 2769 vsync_id(in_vsync_id), 2770 window_id(in_window_id), 2771 base64_proto(in_base64_proto), 2772 base64_proto_id(in_base64_proto_id) { 2773 type_ = "__intrinsic_android_input_event_dispatch"; 2774 } 2775 uint32_t event_id; 2776 uint32_t arg_set_id; 2777 int64_t vsync_id; 2778 int32_t window_id; 2779 StringPool::Id base64_proto; 2780 std::optional<uint32_t> base64_proto_id; 2781 2782 bool operator==(const AndroidInputEventDispatchTable::Row& other) const { 2783 return type() == other.type() && ColumnType::event_id::Equals(event_id, other.event_id) && 2784 ColumnType::arg_set_id::Equals(arg_set_id, other.arg_set_id) && 2785 ColumnType::vsync_id::Equals(vsync_id, other.vsync_id) && 2786 ColumnType::window_id::Equals(window_id, other.window_id) && 2787 ColumnType::base64_proto::Equals(base64_proto, other.base64_proto) && 2788 ColumnType::base64_proto_id::Equals(base64_proto_id, other.base64_proto_id); 2789 } 2790 }; 2791 struct ColumnFlag { 2792 static constexpr uint32_t event_id = ColumnType::event_id::default_flags(); 2793 static constexpr uint32_t arg_set_id = ColumnType::arg_set_id::default_flags(); 2794 static constexpr uint32_t vsync_id = ColumnType::vsync_id::default_flags(); 2795 static constexpr uint32_t window_id = ColumnType::window_id::default_flags(); 2796 static constexpr uint32_t base64_proto = ColumnType::base64_proto::default_flags(); 2797 static constexpr uint32_t base64_proto_id = ColumnType::base64_proto_id::default_flags(); 2798 }; 2799 2800 class RowNumber; 2801 class ConstRowReference; 2802 class RowReference; 2803 2804 class RowNumber : public macros_internal::AbstractRowNumber< 2805 AndroidInputEventDispatchTable, ConstRowReference, RowReference> { 2806 public: RowNumber(uint32_t row_number)2807 explicit RowNumber(uint32_t row_number) 2808 : AbstractRowNumber(row_number) {} 2809 }; 2810 static_assert(std::is_trivially_destructible_v<RowNumber>, 2811 "Inheritance used without trivial destruction"); 2812 2813 class ConstRowReference : public macros_internal::AbstractConstRowReference< 2814 AndroidInputEventDispatchTable, RowNumber> { 2815 public: ConstRowReference(const AndroidInputEventDispatchTable * table,uint32_t row_number)2816 ConstRowReference(const AndroidInputEventDispatchTable* table, uint32_t row_number) 2817 : AbstractConstRowReference(table, row_number) {} 2818 id()2819 ColumnType::id::type id() const { 2820 return table()->id()[row_number_]; 2821 } type()2822 ColumnType::type::type type() const { 2823 return table()->type()[row_number_]; 2824 } event_id()2825 ColumnType::event_id::type event_id() const { 2826 return table()->event_id()[row_number_]; 2827 } arg_set_id()2828 ColumnType::arg_set_id::type arg_set_id() const { 2829 return table()->arg_set_id()[row_number_]; 2830 } vsync_id()2831 ColumnType::vsync_id::type vsync_id() const { 2832 return table()->vsync_id()[row_number_]; 2833 } window_id()2834 ColumnType::window_id::type window_id() const { 2835 return table()->window_id()[row_number_]; 2836 } base64_proto()2837 ColumnType::base64_proto::type base64_proto() const { 2838 return table()->base64_proto()[row_number_]; 2839 } base64_proto_id()2840 ColumnType::base64_proto_id::type base64_proto_id() const { 2841 return table()->base64_proto_id()[row_number_]; 2842 } 2843 }; 2844 static_assert(std::is_trivially_destructible_v<ConstRowReference>, 2845 "Inheritance used without trivial destruction"); 2846 class RowReference : public ConstRowReference { 2847 public: RowReference(const AndroidInputEventDispatchTable * table,uint32_t row_number)2848 RowReference(const AndroidInputEventDispatchTable* table, uint32_t row_number) 2849 : ConstRowReference(table, row_number) {} 2850 set_event_id(ColumnType::event_id::non_optional_type v)2851 void set_event_id( 2852 ColumnType::event_id::non_optional_type v) { 2853 return mutable_table()->mutable_event_id()->Set(row_number_, v); 2854 } set_arg_set_id(ColumnType::arg_set_id::non_optional_type v)2855 void set_arg_set_id( 2856 ColumnType::arg_set_id::non_optional_type v) { 2857 return mutable_table()->mutable_arg_set_id()->Set(row_number_, v); 2858 } set_vsync_id(ColumnType::vsync_id::non_optional_type v)2859 void set_vsync_id( 2860 ColumnType::vsync_id::non_optional_type v) { 2861 return mutable_table()->mutable_vsync_id()->Set(row_number_, v); 2862 } set_window_id(ColumnType::window_id::non_optional_type v)2863 void set_window_id( 2864 ColumnType::window_id::non_optional_type v) { 2865 return mutable_table()->mutable_window_id()->Set(row_number_, v); 2866 } set_base64_proto(ColumnType::base64_proto::non_optional_type v)2867 void set_base64_proto( 2868 ColumnType::base64_proto::non_optional_type v) { 2869 return mutable_table()->mutable_base64_proto()->Set(row_number_, v); 2870 } set_base64_proto_id(ColumnType::base64_proto_id::non_optional_type v)2871 void set_base64_proto_id( 2872 ColumnType::base64_proto_id::non_optional_type v) { 2873 return mutable_table()->mutable_base64_proto_id()->Set(row_number_, v); 2874 } 2875 2876 private: mutable_table()2877 AndroidInputEventDispatchTable* mutable_table() const { 2878 return const_cast<AndroidInputEventDispatchTable*>(table()); 2879 } 2880 }; 2881 static_assert(std::is_trivially_destructible_v<RowReference>, 2882 "Inheritance used without trivial destruction"); 2883 2884 class ConstIterator; 2885 class ConstIterator : public macros_internal::AbstractConstIterator< 2886 ConstIterator, AndroidInputEventDispatchTable, RowNumber, ConstRowReference> { 2887 public: id()2888 ColumnType::id::type id() const { 2889 const auto& col = table()->id(); 2890 return col.GetAtIdx( 2891 iterator_.StorageIndexForColumn(col.index_in_table())); 2892 } type()2893 ColumnType::type::type type() const { 2894 const auto& col = table()->type(); 2895 return col.GetAtIdx( 2896 iterator_.StorageIndexForColumn(col.index_in_table())); 2897 } event_id()2898 ColumnType::event_id::type event_id() const { 2899 const auto& col = table()->event_id(); 2900 return col.GetAtIdx( 2901 iterator_.StorageIndexForColumn(col.index_in_table())); 2902 } arg_set_id()2903 ColumnType::arg_set_id::type arg_set_id() const { 2904 const auto& col = table()->arg_set_id(); 2905 return col.GetAtIdx( 2906 iterator_.StorageIndexForColumn(col.index_in_table())); 2907 } vsync_id()2908 ColumnType::vsync_id::type vsync_id() const { 2909 const auto& col = table()->vsync_id(); 2910 return col.GetAtIdx( 2911 iterator_.StorageIndexForColumn(col.index_in_table())); 2912 } window_id()2913 ColumnType::window_id::type window_id() const { 2914 const auto& col = table()->window_id(); 2915 return col.GetAtIdx( 2916 iterator_.StorageIndexForColumn(col.index_in_table())); 2917 } base64_proto()2918 ColumnType::base64_proto::type base64_proto() const { 2919 const auto& col = table()->base64_proto(); 2920 return col.GetAtIdx( 2921 iterator_.StorageIndexForColumn(col.index_in_table())); 2922 } base64_proto_id()2923 ColumnType::base64_proto_id::type base64_proto_id() const { 2924 const auto& col = table()->base64_proto_id(); 2925 return col.GetAtIdx( 2926 iterator_.StorageIndexForColumn(col.index_in_table())); 2927 } 2928 2929 protected: ConstIterator(const AndroidInputEventDispatchTable * table,Table::Iterator iterator)2930 explicit ConstIterator(const AndroidInputEventDispatchTable* table, 2931 Table::Iterator iterator) 2932 : AbstractConstIterator(table, std::move(iterator)) {} 2933 CurrentRowNumber()2934 uint32_t CurrentRowNumber() const { 2935 return iterator_.StorageIndexForLastOverlay(); 2936 } 2937 2938 private: 2939 friend class AndroidInputEventDispatchTable; 2940 friend class macros_internal::AbstractConstIterator< 2941 ConstIterator, AndroidInputEventDispatchTable, RowNumber, ConstRowReference>; 2942 }; 2943 class Iterator : public ConstIterator { 2944 public: row_reference()2945 RowReference row_reference() const { 2946 return {const_cast<AndroidInputEventDispatchTable*>(table()), CurrentRowNumber()}; 2947 } 2948 2949 private: 2950 friend class AndroidInputEventDispatchTable; 2951 Iterator(AndroidInputEventDispatchTable * table,Table::Iterator iterator)2952 explicit Iterator(AndroidInputEventDispatchTable* table, Table::Iterator iterator) 2953 : ConstIterator(table, std::move(iterator)) {} 2954 }; 2955 2956 struct IdAndRow { 2957 Id id; 2958 uint32_t row; 2959 RowReference row_reference; 2960 RowNumber row_number; 2961 }; 2962 GetColumns(AndroidInputEventDispatchTable * self,const macros_internal::MacroTable * parent)2963 static std::vector<ColumnLegacy> GetColumns( 2964 AndroidInputEventDispatchTable* self, 2965 const macros_internal::MacroTable* parent) { 2966 std::vector<ColumnLegacy> columns = 2967 CopyColumnsFromParentOrAddRootColumns(self, parent); 2968 uint32_t olay_idx = OverlayCount(parent); 2969 AddColumnToVector(columns, "event_id", &self->event_id_, ColumnFlag::event_id, 2970 static_cast<uint32_t>(columns.size()), olay_idx); 2971 AddColumnToVector(columns, "arg_set_id", &self->arg_set_id_, ColumnFlag::arg_set_id, 2972 static_cast<uint32_t>(columns.size()), olay_idx); 2973 AddColumnToVector(columns, "vsync_id", &self->vsync_id_, ColumnFlag::vsync_id, 2974 static_cast<uint32_t>(columns.size()), olay_idx); 2975 AddColumnToVector(columns, "window_id", &self->window_id_, ColumnFlag::window_id, 2976 static_cast<uint32_t>(columns.size()), olay_idx); 2977 AddColumnToVector(columns, "base64_proto", &self->base64_proto_, ColumnFlag::base64_proto, 2978 static_cast<uint32_t>(columns.size()), olay_idx); 2979 AddColumnToVector(columns, "base64_proto_id", &self->base64_proto_id_, ColumnFlag::base64_proto_id, 2980 static_cast<uint32_t>(columns.size()), olay_idx); 2981 return columns; 2982 } 2983 AndroidInputEventDispatchTable(StringPool * pool)2984 PERFETTO_NO_INLINE explicit AndroidInputEventDispatchTable(StringPool* pool) 2985 : macros_internal::MacroTable( 2986 pool, 2987 GetColumns(this, nullptr), 2988 nullptr), 2989 event_id_(ColumnStorage<ColumnType::event_id::stored_type>::Create<false>()), 2990 arg_set_id_(ColumnStorage<ColumnType::arg_set_id::stored_type>::Create<false>()), 2991 vsync_id_(ColumnStorage<ColumnType::vsync_id::stored_type>::Create<false>()), 2992 window_id_(ColumnStorage<ColumnType::window_id::stored_type>::Create<false>()), 2993 base64_proto_(ColumnStorage<ColumnType::base64_proto::stored_type>::Create<false>()), 2994 base64_proto_id_(ColumnStorage<ColumnType::base64_proto_id::stored_type>::Create<false>()) 2995 , 2996 id_storage_layer_(new column::IdStorage()), 2997 type_storage_layer_( 2998 new column::StringStorage(string_pool(), &type_.vector())), 2999 event_id_storage_layer_( 3000 new column::NumericStorage<ColumnType::event_id::non_optional_stored_type>( 3001 &event_id_.vector(), 3002 ColumnTypeHelper<ColumnType::event_id::stored_type>::ToColumnType(), 3003 false)), 3004 arg_set_id_storage_layer_( 3005 new column::NumericStorage<ColumnType::arg_set_id::non_optional_stored_type>( 3006 &arg_set_id_.vector(), 3007 ColumnTypeHelper<ColumnType::arg_set_id::stored_type>::ToColumnType(), 3008 false)), 3009 vsync_id_storage_layer_( 3010 new column::NumericStorage<ColumnType::vsync_id::non_optional_stored_type>( 3011 &vsync_id_.vector(), 3012 ColumnTypeHelper<ColumnType::vsync_id::stored_type>::ToColumnType(), 3013 false)), 3014 window_id_storage_layer_( 3015 new column::NumericStorage<ColumnType::window_id::non_optional_stored_type>( 3016 &window_id_.vector(), 3017 ColumnTypeHelper<ColumnType::window_id::stored_type>::ToColumnType(), 3018 false)), 3019 base64_proto_storage_layer_( 3020 new column::StringStorage(string_pool(), &base64_proto_.vector())), 3021 base64_proto_id_storage_layer_( 3022 new column::NumericStorage<ColumnType::base64_proto_id::non_optional_stored_type>( 3023 &base64_proto_id_.non_null_vector(), 3024 ColumnTypeHelper<ColumnType::base64_proto_id::stored_type>::ToColumnType(), 3025 false)) 3026 , 3027 base64_proto_id_null_layer_(new column::NullOverlay(base64_proto_id_.bv())) { 3028 static_assert( 3029 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::event_id::stored_type>( 3030 ColumnFlag::event_id), 3031 "Column type and flag combination is not valid"); 3032 static_assert( 3033 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::arg_set_id::stored_type>( 3034 ColumnFlag::arg_set_id), 3035 "Column type and flag combination is not valid"); 3036 static_assert( 3037 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::vsync_id::stored_type>( 3038 ColumnFlag::vsync_id), 3039 "Column type and flag combination is not valid"); 3040 static_assert( 3041 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::window_id::stored_type>( 3042 ColumnFlag::window_id), 3043 "Column type and flag combination is not valid"); 3044 static_assert( 3045 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::base64_proto::stored_type>( 3046 ColumnFlag::base64_proto), 3047 "Column type and flag combination is not valid"); 3048 static_assert( 3049 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::base64_proto_id::stored_type>( 3050 ColumnFlag::base64_proto_id), 3051 "Column type and flag combination is not valid"); 3052 OnConstructionCompletedRegularConstructor( 3053 {id_storage_layer_,type_storage_layer_,event_id_storage_layer_,arg_set_id_storage_layer_,vsync_id_storage_layer_,window_id_storage_layer_,base64_proto_storage_layer_,base64_proto_id_storage_layer_}, 3054 {{},{},{},{},{},{},{},base64_proto_id_null_layer_}); 3055 } 3056 ~AndroidInputEventDispatchTable() override; 3057 Name()3058 static const char* Name() { return "__intrinsic_android_input_event_dispatch"; } 3059 ComputeStaticSchema()3060 static Table::Schema ComputeStaticSchema() { 3061 Table::Schema schema; 3062 schema.columns.emplace_back(Table::Schema::Column{ 3063 "id", SqlValue::Type::kLong, true, true, false, false}); 3064 schema.columns.emplace_back(Table::Schema::Column{ 3065 "type", SqlValue::Type::kString, false, false, false, false}); 3066 schema.columns.emplace_back(Table::Schema::Column{ 3067 "event_id", ColumnType::event_id::SqlValueType(), false, 3068 false, 3069 false, 3070 false}); 3071 schema.columns.emplace_back(Table::Schema::Column{ 3072 "arg_set_id", ColumnType::arg_set_id::SqlValueType(), false, 3073 false, 3074 false, 3075 false}); 3076 schema.columns.emplace_back(Table::Schema::Column{ 3077 "vsync_id", ColumnType::vsync_id::SqlValueType(), false, 3078 false, 3079 false, 3080 false}); 3081 schema.columns.emplace_back(Table::Schema::Column{ 3082 "window_id", ColumnType::window_id::SqlValueType(), false, 3083 false, 3084 false, 3085 false}); 3086 schema.columns.emplace_back(Table::Schema::Column{ 3087 "base64_proto", ColumnType::base64_proto::SqlValueType(), false, 3088 false, 3089 false, 3090 false}); 3091 schema.columns.emplace_back(Table::Schema::Column{ 3092 "base64_proto_id", ColumnType::base64_proto_id::SqlValueType(), false, 3093 false, 3094 false, 3095 false}); 3096 return schema; 3097 } 3098 IterateRows()3099 ConstIterator IterateRows() const { 3100 return ConstIterator(this, Table::IterateRows()); 3101 } 3102 IterateRows()3103 Iterator IterateRows() { return Iterator(this, Table::IterateRows()); } 3104 FilterToIterator(const Query & q)3105 ConstIterator FilterToIterator(const Query& q) const { 3106 return ConstIterator(this, QueryToIterator(q)); 3107 } 3108 FilterToIterator(const Query & q)3109 Iterator FilterToIterator(const Query& q) { 3110 return Iterator(this, QueryToIterator(q)); 3111 } 3112 ShrinkToFit()3113 void ShrinkToFit() { 3114 type_.ShrinkToFit(); 3115 event_id_.ShrinkToFit(); 3116 arg_set_id_.ShrinkToFit(); 3117 vsync_id_.ShrinkToFit(); 3118 window_id_.ShrinkToFit(); 3119 base64_proto_.ShrinkToFit(); 3120 base64_proto_id_.ShrinkToFit(); 3121 } 3122 3123 ConstRowReference operator[](uint32_t r) const { 3124 return ConstRowReference(this, r); 3125 } 3126 RowReference operator[](uint32_t r) { return RowReference(this, r); } 3127 ConstRowReference operator[](RowNumber r) const { 3128 return ConstRowReference(this, r.row_number()); 3129 } 3130 RowReference operator[](RowNumber r) { 3131 return RowReference(this, r.row_number()); 3132 } 3133 FindById(Id find_id)3134 std::optional<ConstRowReference> FindById(Id find_id) const { 3135 std::optional<uint32_t> row = id().IndexOf(find_id); 3136 return row ? std::make_optional(ConstRowReference(this, *row)) 3137 : std::nullopt; 3138 } 3139 FindById(Id find_id)3140 std::optional<RowReference> FindById(Id find_id) { 3141 std::optional<uint32_t> row = id().IndexOf(find_id); 3142 return row ? std::make_optional(RowReference(this, *row)) : std::nullopt; 3143 } 3144 Insert(const Row & row)3145 IdAndRow Insert(const Row& row) { 3146 uint32_t row_number = row_count(); 3147 Id id = Id{row_number}; 3148 type_.Append(string_pool()->InternString(row.type())); 3149 mutable_event_id()->Append(row.event_id); 3150 mutable_arg_set_id()->Append(row.arg_set_id); 3151 mutable_vsync_id()->Append(row.vsync_id); 3152 mutable_window_id()->Append(row.window_id); 3153 mutable_base64_proto()->Append(row.base64_proto); 3154 mutable_base64_proto_id()->Append(row.base64_proto_id); 3155 UpdateSelfOverlayAfterInsert(); 3156 return IdAndRow{id, row_number, RowReference(this, row_number), 3157 RowNumber(row_number)}; 3158 } 3159 3160 3161 id()3162 const IdColumn<AndroidInputEventDispatchTable::Id>& id() const { 3163 return static_cast<const ColumnType::id&>(columns()[ColumnIndex::id]); 3164 } type()3165 const TypedColumn<StringPool::Id>& type() const { 3166 return static_cast<const ColumnType::type&>(columns()[ColumnIndex::type]); 3167 } event_id()3168 const TypedColumn<uint32_t>& event_id() const { 3169 return static_cast<const ColumnType::event_id&>(columns()[ColumnIndex::event_id]); 3170 } arg_set_id()3171 const TypedColumn<uint32_t>& arg_set_id() const { 3172 return static_cast<const ColumnType::arg_set_id&>(columns()[ColumnIndex::arg_set_id]); 3173 } vsync_id()3174 const TypedColumn<int64_t>& vsync_id() const { 3175 return static_cast<const ColumnType::vsync_id&>(columns()[ColumnIndex::vsync_id]); 3176 } window_id()3177 const TypedColumn<int32_t>& window_id() const { 3178 return static_cast<const ColumnType::window_id&>(columns()[ColumnIndex::window_id]); 3179 } base64_proto()3180 const TypedColumn<StringPool::Id>& base64_proto() const { 3181 return static_cast<const ColumnType::base64_proto&>(columns()[ColumnIndex::base64_proto]); 3182 } base64_proto_id()3183 const TypedColumn<std::optional<uint32_t>>& base64_proto_id() const { 3184 return static_cast<const ColumnType::base64_proto_id&>(columns()[ColumnIndex::base64_proto_id]); 3185 } 3186 mutable_event_id()3187 TypedColumn<uint32_t>* mutable_event_id() { 3188 return static_cast<ColumnType::event_id*>( 3189 GetColumn(ColumnIndex::event_id)); 3190 } mutable_arg_set_id()3191 TypedColumn<uint32_t>* mutable_arg_set_id() { 3192 return static_cast<ColumnType::arg_set_id*>( 3193 GetColumn(ColumnIndex::arg_set_id)); 3194 } mutable_vsync_id()3195 TypedColumn<int64_t>* mutable_vsync_id() { 3196 return static_cast<ColumnType::vsync_id*>( 3197 GetColumn(ColumnIndex::vsync_id)); 3198 } mutable_window_id()3199 TypedColumn<int32_t>* mutable_window_id() { 3200 return static_cast<ColumnType::window_id*>( 3201 GetColumn(ColumnIndex::window_id)); 3202 } mutable_base64_proto()3203 TypedColumn<StringPool::Id>* mutable_base64_proto() { 3204 return static_cast<ColumnType::base64_proto*>( 3205 GetColumn(ColumnIndex::base64_proto)); 3206 } mutable_base64_proto_id()3207 TypedColumn<std::optional<uint32_t>>* mutable_base64_proto_id() { 3208 return static_cast<ColumnType::base64_proto_id*>( 3209 GetColumn(ColumnIndex::base64_proto_id)); 3210 } 3211 3212 private: 3213 3214 3215 ColumnStorage<ColumnType::event_id::stored_type> event_id_; 3216 ColumnStorage<ColumnType::arg_set_id::stored_type> arg_set_id_; 3217 ColumnStorage<ColumnType::vsync_id::stored_type> vsync_id_; 3218 ColumnStorage<ColumnType::window_id::stored_type> window_id_; 3219 ColumnStorage<ColumnType::base64_proto::stored_type> base64_proto_; 3220 ColumnStorage<ColumnType::base64_proto_id::stored_type> base64_proto_id_; 3221 3222 RefPtr<column::StorageLayer> id_storage_layer_; 3223 RefPtr<column::StorageLayer> type_storage_layer_; 3224 RefPtr<column::StorageLayer> event_id_storage_layer_; 3225 RefPtr<column::StorageLayer> arg_set_id_storage_layer_; 3226 RefPtr<column::StorageLayer> vsync_id_storage_layer_; 3227 RefPtr<column::StorageLayer> window_id_storage_layer_; 3228 RefPtr<column::StorageLayer> base64_proto_storage_layer_; 3229 RefPtr<column::StorageLayer> base64_proto_id_storage_layer_; 3230 3231 RefPtr<column::OverlayLayer> base64_proto_id_null_layer_; 3232 }; 3233 3234 } // namespace perfetto 3235 3236 #endif // SRC_TRACE_PROCESSOR_TABLES_ANDROID_TABLES_PY_H_ 3237