1 #ifndef SRC_TRACE_PROCESSOR_TABLES_WINSCOPE_TABLES_PY_H_ 2 #define SRC_TRACE_PROCESSOR_TABLES_WINSCOPE_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 38 39 namespace perfetto::trace_processor::tables { 40 41 class ProtoLogTable : public macros_internal::MacroTable { 42 public: 43 static constexpr uint32_t kColumnCount = 8; 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 level = 3; 57 static constexpr uint32_t tag = 4; 58 static constexpr uint32_t message = 5; 59 static constexpr uint32_t stacktrace = 6; 60 static constexpr uint32_t location = 7; 61 }; 62 struct ColumnType { 63 using id = IdColumn<ProtoLogTable::Id>; 64 using type = TypedColumn<StringPool::Id>; 65 using ts = TypedColumn<int64_t>; 66 using level = TypedColumn<StringPool::Id>; 67 using tag = TypedColumn<StringPool::Id>; 68 using message = TypedColumn<StringPool::Id>; 69 using stacktrace = TypedColumn<StringPool::Id>; 70 using location = TypedColumn<StringPool::Id>; 71 }; 72 struct Row : public macros_internal::RootParentTable::Row { 73 Row(int64_t in_ts = {}, 74 StringPool::Id in_level = {}, 75 StringPool::Id in_tag = {}, 76 StringPool::Id in_message = {}, 77 StringPool::Id in_stacktrace = {}, 78 StringPool::Id in_location = {}, 79 std::nullptr_t = nullptr) RowRow80 : macros_internal::RootParentTable::Row(), 81 ts(in_ts), 82 level(in_level), 83 tag(in_tag), 84 message(in_message), 85 stacktrace(in_stacktrace), 86 location(in_location) { 87 type_ = "protolog"; 88 } 89 int64_t ts; 90 StringPool::Id level; 91 StringPool::Id tag; 92 StringPool::Id message; 93 StringPool::Id stacktrace; 94 StringPool::Id location; 95 96 bool operator==(const ProtoLogTable::Row& other) const { 97 return type() == other.type() && ColumnType::ts::Equals(ts, other.ts) && 98 ColumnType::level::Equals(level, other.level) && 99 ColumnType::tag::Equals(tag, other.tag) && 100 ColumnType::message::Equals(message, other.message) && 101 ColumnType::stacktrace::Equals(stacktrace, other.stacktrace) && 102 ColumnType::location::Equals(location, other.location); 103 } 104 }; 105 struct ColumnFlag { 106 static constexpr uint32_t ts = static_cast<uint32_t>(ColumnLegacy::Flag::kSorted) | ColumnType::ts::default_flags(); 107 static constexpr uint32_t level = ColumnType::level::default_flags(); 108 static constexpr uint32_t tag = ColumnType::tag::default_flags(); 109 static constexpr uint32_t message = ColumnType::message::default_flags(); 110 static constexpr uint32_t stacktrace = ColumnType::stacktrace::default_flags(); 111 static constexpr uint32_t location = ColumnType::location::default_flags(); 112 }; 113 114 class RowNumber; 115 class ConstRowReference; 116 class RowReference; 117 118 class RowNumber : public macros_internal::AbstractRowNumber< 119 ProtoLogTable, ConstRowReference, RowReference> { 120 public: RowNumber(uint32_t row_number)121 explicit RowNumber(uint32_t row_number) 122 : AbstractRowNumber(row_number) {} 123 }; 124 static_assert(std::is_trivially_destructible_v<RowNumber>, 125 "Inheritance used without trivial destruction"); 126 127 class ConstRowReference : public macros_internal::AbstractConstRowReference< 128 ProtoLogTable, RowNumber> { 129 public: ConstRowReference(const ProtoLogTable * table,uint32_t row_number)130 ConstRowReference(const ProtoLogTable* table, uint32_t row_number) 131 : AbstractConstRowReference(table, row_number) {} 132 id()133 ColumnType::id::type id() const { 134 return table()->id()[row_number_]; 135 } type()136 ColumnType::type::type type() const { 137 return table()->type()[row_number_]; 138 } ts()139 ColumnType::ts::type ts() const { 140 return table()->ts()[row_number_]; 141 } level()142 ColumnType::level::type level() const { 143 return table()->level()[row_number_]; 144 } tag()145 ColumnType::tag::type tag() const { 146 return table()->tag()[row_number_]; 147 } message()148 ColumnType::message::type message() const { 149 return table()->message()[row_number_]; 150 } stacktrace()151 ColumnType::stacktrace::type stacktrace() const { 152 return table()->stacktrace()[row_number_]; 153 } location()154 ColumnType::location::type location() const { 155 return table()->location()[row_number_]; 156 } 157 }; 158 static_assert(std::is_trivially_destructible_v<ConstRowReference>, 159 "Inheritance used without trivial destruction"); 160 class RowReference : public ConstRowReference { 161 public: RowReference(const ProtoLogTable * table,uint32_t row_number)162 RowReference(const ProtoLogTable* table, uint32_t row_number) 163 : ConstRowReference(table, row_number) {} 164 set_ts(ColumnType::ts::non_optional_type v)165 void set_ts( 166 ColumnType::ts::non_optional_type v) { 167 return mutable_table()->mutable_ts()->Set(row_number_, v); 168 } set_level(ColumnType::level::non_optional_type v)169 void set_level( 170 ColumnType::level::non_optional_type v) { 171 return mutable_table()->mutable_level()->Set(row_number_, v); 172 } set_tag(ColumnType::tag::non_optional_type v)173 void set_tag( 174 ColumnType::tag::non_optional_type v) { 175 return mutable_table()->mutable_tag()->Set(row_number_, v); 176 } set_message(ColumnType::message::non_optional_type v)177 void set_message( 178 ColumnType::message::non_optional_type v) { 179 return mutable_table()->mutable_message()->Set(row_number_, v); 180 } set_stacktrace(ColumnType::stacktrace::non_optional_type v)181 void set_stacktrace( 182 ColumnType::stacktrace::non_optional_type v) { 183 return mutable_table()->mutable_stacktrace()->Set(row_number_, v); 184 } set_location(ColumnType::location::non_optional_type v)185 void set_location( 186 ColumnType::location::non_optional_type v) { 187 return mutable_table()->mutable_location()->Set(row_number_, v); 188 } 189 190 private: mutable_table()191 ProtoLogTable* mutable_table() const { 192 return const_cast<ProtoLogTable*>(table()); 193 } 194 }; 195 static_assert(std::is_trivially_destructible_v<RowReference>, 196 "Inheritance used without trivial destruction"); 197 198 class ConstIterator; 199 class ConstIterator : public macros_internal::AbstractConstIterator< 200 ConstIterator, ProtoLogTable, RowNumber, ConstRowReference> { 201 public: id()202 ColumnType::id::type id() const { 203 const auto& col = table()->id(); 204 return col.GetAtIdx( 205 iterator_.StorageIndexForColumn(col.index_in_table())); 206 } type()207 ColumnType::type::type type() const { 208 const auto& col = table()->type(); 209 return col.GetAtIdx( 210 iterator_.StorageIndexForColumn(col.index_in_table())); 211 } ts()212 ColumnType::ts::type ts() const { 213 const auto& col = table()->ts(); 214 return col.GetAtIdx( 215 iterator_.StorageIndexForColumn(col.index_in_table())); 216 } level()217 ColumnType::level::type level() const { 218 const auto& col = table()->level(); 219 return col.GetAtIdx( 220 iterator_.StorageIndexForColumn(col.index_in_table())); 221 } tag()222 ColumnType::tag::type tag() const { 223 const auto& col = table()->tag(); 224 return col.GetAtIdx( 225 iterator_.StorageIndexForColumn(col.index_in_table())); 226 } message()227 ColumnType::message::type message() const { 228 const auto& col = table()->message(); 229 return col.GetAtIdx( 230 iterator_.StorageIndexForColumn(col.index_in_table())); 231 } stacktrace()232 ColumnType::stacktrace::type stacktrace() const { 233 const auto& col = table()->stacktrace(); 234 return col.GetAtIdx( 235 iterator_.StorageIndexForColumn(col.index_in_table())); 236 } location()237 ColumnType::location::type location() const { 238 const auto& col = table()->location(); 239 return col.GetAtIdx( 240 iterator_.StorageIndexForColumn(col.index_in_table())); 241 } 242 243 protected: ConstIterator(const ProtoLogTable * table,Table::Iterator iterator)244 explicit ConstIterator(const ProtoLogTable* table, 245 Table::Iterator iterator) 246 : AbstractConstIterator(table, std::move(iterator)) {} 247 CurrentRowNumber()248 uint32_t CurrentRowNumber() const { 249 return iterator_.StorageIndexForLastOverlay(); 250 } 251 252 private: 253 friend class ProtoLogTable; 254 friend class macros_internal::AbstractConstIterator< 255 ConstIterator, ProtoLogTable, RowNumber, ConstRowReference>; 256 }; 257 class Iterator : public ConstIterator { 258 public: row_reference()259 RowReference row_reference() const { 260 return {const_cast<ProtoLogTable*>(table()), CurrentRowNumber()}; 261 } 262 263 private: 264 friend class ProtoLogTable; 265 Iterator(ProtoLogTable * table,Table::Iterator iterator)266 explicit Iterator(ProtoLogTable* table, Table::Iterator iterator) 267 : ConstIterator(table, std::move(iterator)) {} 268 }; 269 270 struct IdAndRow { 271 Id id; 272 uint32_t row; 273 RowReference row_reference; 274 RowNumber row_number; 275 }; 276 GetColumns(ProtoLogTable * self,const macros_internal::MacroTable * parent)277 static std::vector<ColumnLegacy> GetColumns( 278 ProtoLogTable* self, 279 const macros_internal::MacroTable* parent) { 280 std::vector<ColumnLegacy> columns = 281 CopyColumnsFromParentOrAddRootColumns(self, parent); 282 uint32_t olay_idx = OverlayCount(parent); 283 AddColumnToVector(columns, "ts", &self->ts_, ColumnFlag::ts, 284 static_cast<uint32_t>(columns.size()), olay_idx); 285 AddColumnToVector(columns, "level", &self->level_, ColumnFlag::level, 286 static_cast<uint32_t>(columns.size()), olay_idx); 287 AddColumnToVector(columns, "tag", &self->tag_, ColumnFlag::tag, 288 static_cast<uint32_t>(columns.size()), olay_idx); 289 AddColumnToVector(columns, "message", &self->message_, ColumnFlag::message, 290 static_cast<uint32_t>(columns.size()), olay_idx); 291 AddColumnToVector(columns, "stacktrace", &self->stacktrace_, ColumnFlag::stacktrace, 292 static_cast<uint32_t>(columns.size()), olay_idx); 293 AddColumnToVector(columns, "location", &self->location_, ColumnFlag::location, 294 static_cast<uint32_t>(columns.size()), olay_idx); 295 return columns; 296 } 297 ProtoLogTable(StringPool * pool)298 PERFETTO_NO_INLINE explicit ProtoLogTable(StringPool* pool) 299 : macros_internal::MacroTable( 300 pool, 301 GetColumns(this, nullptr), 302 nullptr), 303 ts_(ColumnStorage<ColumnType::ts::stored_type>::Create<false>()), 304 level_(ColumnStorage<ColumnType::level::stored_type>::Create<false>()), 305 tag_(ColumnStorage<ColumnType::tag::stored_type>::Create<false>()), 306 message_(ColumnStorage<ColumnType::message::stored_type>::Create<false>()), 307 stacktrace_(ColumnStorage<ColumnType::stacktrace::stored_type>::Create<false>()), 308 location_(ColumnStorage<ColumnType::location::stored_type>::Create<false>()) 309 , 310 id_storage_layer_(new column::IdStorage()), 311 type_storage_layer_( 312 new column::StringStorage(string_pool(), &type_.vector())), 313 ts_storage_layer_( 314 new column::NumericStorage<ColumnType::ts::non_optional_stored_type>( 315 &ts_.vector(), 316 ColumnTypeHelper<ColumnType::ts::stored_type>::ToColumnType(), 317 true)), 318 level_storage_layer_( 319 new column::StringStorage(string_pool(), &level_.vector())), 320 tag_storage_layer_( 321 new column::StringStorage(string_pool(), &tag_.vector())), 322 message_storage_layer_( 323 new column::StringStorage(string_pool(), &message_.vector())), 324 stacktrace_storage_layer_( 325 new column::StringStorage(string_pool(), &stacktrace_.vector())), 326 location_storage_layer_( 327 new column::StringStorage(string_pool(), &location_.vector())) 328 { 329 static_assert( 330 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::ts::stored_type>( 331 ColumnFlag::ts), 332 "Column type and flag combination is not valid"); 333 static_assert( 334 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::level::stored_type>( 335 ColumnFlag::level), 336 "Column type and flag combination is not valid"); 337 static_assert( 338 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::tag::stored_type>( 339 ColumnFlag::tag), 340 "Column type and flag combination is not valid"); 341 static_assert( 342 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::message::stored_type>( 343 ColumnFlag::message), 344 "Column type and flag combination is not valid"); 345 static_assert( 346 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::stacktrace::stored_type>( 347 ColumnFlag::stacktrace), 348 "Column type and flag combination is not valid"); 349 static_assert( 350 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::location::stored_type>( 351 ColumnFlag::location), 352 "Column type and flag combination is not valid"); 353 OnConstructionCompletedRegularConstructor( 354 {id_storage_layer_,type_storage_layer_,ts_storage_layer_,level_storage_layer_,tag_storage_layer_,message_storage_layer_,stacktrace_storage_layer_,location_storage_layer_}, 355 {{},{},{},{},{},{},{},{}}); 356 } 357 ~ProtoLogTable() override; 358 Name()359 static const char* Name() { return "protolog"; } 360 ComputeStaticSchema()361 static Table::Schema ComputeStaticSchema() { 362 Table::Schema schema; 363 schema.columns.emplace_back(Table::Schema::Column{ 364 "id", SqlValue::Type::kLong, true, true, false, false}); 365 schema.columns.emplace_back(Table::Schema::Column{ 366 "type", SqlValue::Type::kString, false, false, false, false}); 367 schema.columns.emplace_back(Table::Schema::Column{ 368 "ts", ColumnType::ts::SqlValueType(), false, 369 true, 370 false, 371 false}); 372 schema.columns.emplace_back(Table::Schema::Column{ 373 "level", ColumnType::level::SqlValueType(), false, 374 false, 375 false, 376 false}); 377 schema.columns.emplace_back(Table::Schema::Column{ 378 "tag", ColumnType::tag::SqlValueType(), false, 379 false, 380 false, 381 false}); 382 schema.columns.emplace_back(Table::Schema::Column{ 383 "message", ColumnType::message::SqlValueType(), false, 384 false, 385 false, 386 false}); 387 schema.columns.emplace_back(Table::Schema::Column{ 388 "stacktrace", ColumnType::stacktrace::SqlValueType(), false, 389 false, 390 false, 391 false}); 392 schema.columns.emplace_back(Table::Schema::Column{ 393 "location", ColumnType::location::SqlValueType(), false, 394 false, 395 false, 396 false}); 397 return schema; 398 } 399 IterateRows()400 ConstIterator IterateRows() const { 401 return ConstIterator(this, Table::IterateRows()); 402 } 403 IterateRows()404 Iterator IterateRows() { return Iterator(this, Table::IterateRows()); } 405 FilterToIterator(const Query & q)406 ConstIterator FilterToIterator(const Query& q) const { 407 return ConstIterator(this, QueryToIterator(q)); 408 } 409 FilterToIterator(const Query & q)410 Iterator FilterToIterator(const Query& q) { 411 return Iterator(this, QueryToIterator(q)); 412 } 413 ShrinkToFit()414 void ShrinkToFit() { 415 type_.ShrinkToFit(); 416 ts_.ShrinkToFit(); 417 level_.ShrinkToFit(); 418 tag_.ShrinkToFit(); 419 message_.ShrinkToFit(); 420 stacktrace_.ShrinkToFit(); 421 location_.ShrinkToFit(); 422 } 423 424 ConstRowReference operator[](uint32_t r) const { 425 return ConstRowReference(this, r); 426 } 427 RowReference operator[](uint32_t r) { return RowReference(this, r); } 428 ConstRowReference operator[](RowNumber r) const { 429 return ConstRowReference(this, r.row_number()); 430 } 431 RowReference operator[](RowNumber r) { 432 return RowReference(this, r.row_number()); 433 } 434 FindById(Id find_id)435 std::optional<ConstRowReference> FindById(Id find_id) const { 436 std::optional<uint32_t> row = id().IndexOf(find_id); 437 return row ? std::make_optional(ConstRowReference(this, *row)) 438 : std::nullopt; 439 } 440 FindById(Id find_id)441 std::optional<RowReference> FindById(Id find_id) { 442 std::optional<uint32_t> row = id().IndexOf(find_id); 443 return row ? std::make_optional(RowReference(this, *row)) : std::nullopt; 444 } 445 Insert(const Row & row)446 IdAndRow Insert(const Row& row) { 447 uint32_t row_number = row_count(); 448 Id id = Id{row_number}; 449 type_.Append(string_pool()->InternString(row.type())); 450 mutable_ts()->Append(row.ts); 451 mutable_level()->Append(row.level); 452 mutable_tag()->Append(row.tag); 453 mutable_message()->Append(row.message); 454 mutable_stacktrace()->Append(row.stacktrace); 455 mutable_location()->Append(row.location); 456 UpdateSelfOverlayAfterInsert(); 457 return IdAndRow{id, row_number, RowReference(this, row_number), 458 RowNumber(row_number)}; 459 } 460 461 462 id()463 const IdColumn<ProtoLogTable::Id>& id() const { 464 return static_cast<const ColumnType::id&>(columns()[ColumnIndex::id]); 465 } type()466 const TypedColumn<StringPool::Id>& type() const { 467 return static_cast<const ColumnType::type&>(columns()[ColumnIndex::type]); 468 } ts()469 const TypedColumn<int64_t>& ts() const { 470 return static_cast<const ColumnType::ts&>(columns()[ColumnIndex::ts]); 471 } level()472 const TypedColumn<StringPool::Id>& level() const { 473 return static_cast<const ColumnType::level&>(columns()[ColumnIndex::level]); 474 } tag()475 const TypedColumn<StringPool::Id>& tag() const { 476 return static_cast<const ColumnType::tag&>(columns()[ColumnIndex::tag]); 477 } message()478 const TypedColumn<StringPool::Id>& message() const { 479 return static_cast<const ColumnType::message&>(columns()[ColumnIndex::message]); 480 } stacktrace()481 const TypedColumn<StringPool::Id>& stacktrace() const { 482 return static_cast<const ColumnType::stacktrace&>(columns()[ColumnIndex::stacktrace]); 483 } location()484 const TypedColumn<StringPool::Id>& location() const { 485 return static_cast<const ColumnType::location&>(columns()[ColumnIndex::location]); 486 } 487 mutable_ts()488 TypedColumn<int64_t>* mutable_ts() { 489 return static_cast<ColumnType::ts*>( 490 GetColumn(ColumnIndex::ts)); 491 } mutable_level()492 TypedColumn<StringPool::Id>* mutable_level() { 493 return static_cast<ColumnType::level*>( 494 GetColumn(ColumnIndex::level)); 495 } mutable_tag()496 TypedColumn<StringPool::Id>* mutable_tag() { 497 return static_cast<ColumnType::tag*>( 498 GetColumn(ColumnIndex::tag)); 499 } mutable_message()500 TypedColumn<StringPool::Id>* mutable_message() { 501 return static_cast<ColumnType::message*>( 502 GetColumn(ColumnIndex::message)); 503 } mutable_stacktrace()504 TypedColumn<StringPool::Id>* mutable_stacktrace() { 505 return static_cast<ColumnType::stacktrace*>( 506 GetColumn(ColumnIndex::stacktrace)); 507 } mutable_location()508 TypedColumn<StringPool::Id>* mutable_location() { 509 return static_cast<ColumnType::location*>( 510 GetColumn(ColumnIndex::location)); 511 } 512 513 private: 514 515 516 ColumnStorage<ColumnType::ts::stored_type> ts_; 517 ColumnStorage<ColumnType::level::stored_type> level_; 518 ColumnStorage<ColumnType::tag::stored_type> tag_; 519 ColumnStorage<ColumnType::message::stored_type> message_; 520 ColumnStorage<ColumnType::stacktrace::stored_type> stacktrace_; 521 ColumnStorage<ColumnType::location::stored_type> location_; 522 523 RefPtr<column::StorageLayer> id_storage_layer_; 524 RefPtr<column::StorageLayer> type_storage_layer_; 525 RefPtr<column::StorageLayer> ts_storage_layer_; 526 RefPtr<column::StorageLayer> level_storage_layer_; 527 RefPtr<column::StorageLayer> tag_storage_layer_; 528 RefPtr<column::StorageLayer> message_storage_layer_; 529 RefPtr<column::StorageLayer> stacktrace_storage_layer_; 530 RefPtr<column::StorageLayer> location_storage_layer_; 531 532 533 }; 534 535 536 class InputMethodClientsTable : public macros_internal::MacroTable { 537 public: 538 static constexpr uint32_t kColumnCount = 6; 539 540 struct Id : public BaseId { 541 Id() = default; IdId542 explicit constexpr Id(uint32_t v) : BaseId(v) {} 543 }; 544 static_assert(std::is_trivially_destructible_v<Id>, 545 "Inheritance used without trivial destruction"); 546 547 struct ColumnIndex { 548 static constexpr uint32_t id = 0; 549 static constexpr uint32_t type = 1; 550 static constexpr uint32_t ts = 2; 551 static constexpr uint32_t arg_set_id = 3; 552 static constexpr uint32_t base64_proto = 4; 553 static constexpr uint32_t base64_proto_id = 5; 554 }; 555 struct ColumnType { 556 using id = IdColumn<InputMethodClientsTable::Id>; 557 using type = TypedColumn<StringPool::Id>; 558 using ts = TypedColumn<int64_t>; 559 using arg_set_id = TypedColumn<uint32_t>; 560 using base64_proto = TypedColumn<StringPool::Id>; 561 using base64_proto_id = TypedColumn<std::optional<uint32_t>>; 562 }; 563 struct Row : public macros_internal::RootParentTable::Row { 564 Row(int64_t in_ts = {}, 565 uint32_t in_arg_set_id = {}, 566 StringPool::Id in_base64_proto = {}, 567 std::optional<uint32_t> in_base64_proto_id = {}, 568 std::nullptr_t = nullptr) RowRow569 : macros_internal::RootParentTable::Row(), 570 ts(in_ts), 571 arg_set_id(in_arg_set_id), 572 base64_proto(in_base64_proto), 573 base64_proto_id(in_base64_proto_id) { 574 type_ = "__intrinsic_inputmethod_clients"; 575 } 576 int64_t ts; 577 uint32_t arg_set_id; 578 StringPool::Id base64_proto; 579 std::optional<uint32_t> base64_proto_id; 580 581 bool operator==(const InputMethodClientsTable::Row& other) const { 582 return type() == other.type() && ColumnType::ts::Equals(ts, other.ts) && 583 ColumnType::arg_set_id::Equals(arg_set_id, other.arg_set_id) && 584 ColumnType::base64_proto::Equals(base64_proto, other.base64_proto) && 585 ColumnType::base64_proto_id::Equals(base64_proto_id, other.base64_proto_id); 586 } 587 }; 588 struct ColumnFlag { 589 static constexpr uint32_t ts = static_cast<uint32_t>(ColumnLegacy::Flag::kSorted) | ColumnType::ts::default_flags(); 590 static constexpr uint32_t arg_set_id = ColumnType::arg_set_id::default_flags(); 591 static constexpr uint32_t base64_proto = ColumnType::base64_proto::default_flags(); 592 static constexpr uint32_t base64_proto_id = ColumnType::base64_proto_id::default_flags(); 593 }; 594 595 class RowNumber; 596 class ConstRowReference; 597 class RowReference; 598 599 class RowNumber : public macros_internal::AbstractRowNumber< 600 InputMethodClientsTable, ConstRowReference, RowReference> { 601 public: RowNumber(uint32_t row_number)602 explicit RowNumber(uint32_t row_number) 603 : AbstractRowNumber(row_number) {} 604 }; 605 static_assert(std::is_trivially_destructible_v<RowNumber>, 606 "Inheritance used without trivial destruction"); 607 608 class ConstRowReference : public macros_internal::AbstractConstRowReference< 609 InputMethodClientsTable, RowNumber> { 610 public: ConstRowReference(const InputMethodClientsTable * table,uint32_t row_number)611 ConstRowReference(const InputMethodClientsTable* table, uint32_t row_number) 612 : AbstractConstRowReference(table, row_number) {} 613 id()614 ColumnType::id::type id() const { 615 return table()->id()[row_number_]; 616 } type()617 ColumnType::type::type type() const { 618 return table()->type()[row_number_]; 619 } ts()620 ColumnType::ts::type ts() const { 621 return table()->ts()[row_number_]; 622 } arg_set_id()623 ColumnType::arg_set_id::type arg_set_id() const { 624 return table()->arg_set_id()[row_number_]; 625 } base64_proto()626 ColumnType::base64_proto::type base64_proto() const { 627 return table()->base64_proto()[row_number_]; 628 } base64_proto_id()629 ColumnType::base64_proto_id::type base64_proto_id() const { 630 return table()->base64_proto_id()[row_number_]; 631 } 632 }; 633 static_assert(std::is_trivially_destructible_v<ConstRowReference>, 634 "Inheritance used without trivial destruction"); 635 class RowReference : public ConstRowReference { 636 public: RowReference(const InputMethodClientsTable * table,uint32_t row_number)637 RowReference(const InputMethodClientsTable* table, uint32_t row_number) 638 : ConstRowReference(table, row_number) {} 639 set_ts(ColumnType::ts::non_optional_type v)640 void set_ts( 641 ColumnType::ts::non_optional_type v) { 642 return mutable_table()->mutable_ts()->Set(row_number_, v); 643 } set_arg_set_id(ColumnType::arg_set_id::non_optional_type v)644 void set_arg_set_id( 645 ColumnType::arg_set_id::non_optional_type v) { 646 return mutable_table()->mutable_arg_set_id()->Set(row_number_, v); 647 } set_base64_proto(ColumnType::base64_proto::non_optional_type v)648 void set_base64_proto( 649 ColumnType::base64_proto::non_optional_type v) { 650 return mutable_table()->mutable_base64_proto()->Set(row_number_, v); 651 } set_base64_proto_id(ColumnType::base64_proto_id::non_optional_type v)652 void set_base64_proto_id( 653 ColumnType::base64_proto_id::non_optional_type v) { 654 return mutable_table()->mutable_base64_proto_id()->Set(row_number_, v); 655 } 656 657 private: mutable_table()658 InputMethodClientsTable* mutable_table() const { 659 return const_cast<InputMethodClientsTable*>(table()); 660 } 661 }; 662 static_assert(std::is_trivially_destructible_v<RowReference>, 663 "Inheritance used without trivial destruction"); 664 665 class ConstIterator; 666 class ConstIterator : public macros_internal::AbstractConstIterator< 667 ConstIterator, InputMethodClientsTable, RowNumber, ConstRowReference> { 668 public: id()669 ColumnType::id::type id() const { 670 const auto& col = table()->id(); 671 return col.GetAtIdx( 672 iterator_.StorageIndexForColumn(col.index_in_table())); 673 } type()674 ColumnType::type::type type() const { 675 const auto& col = table()->type(); 676 return col.GetAtIdx( 677 iterator_.StorageIndexForColumn(col.index_in_table())); 678 } ts()679 ColumnType::ts::type ts() const { 680 const auto& col = table()->ts(); 681 return col.GetAtIdx( 682 iterator_.StorageIndexForColumn(col.index_in_table())); 683 } arg_set_id()684 ColumnType::arg_set_id::type arg_set_id() const { 685 const auto& col = table()->arg_set_id(); 686 return col.GetAtIdx( 687 iterator_.StorageIndexForColumn(col.index_in_table())); 688 } base64_proto()689 ColumnType::base64_proto::type base64_proto() const { 690 const auto& col = table()->base64_proto(); 691 return col.GetAtIdx( 692 iterator_.StorageIndexForColumn(col.index_in_table())); 693 } base64_proto_id()694 ColumnType::base64_proto_id::type base64_proto_id() const { 695 const auto& col = table()->base64_proto_id(); 696 return col.GetAtIdx( 697 iterator_.StorageIndexForColumn(col.index_in_table())); 698 } 699 700 protected: ConstIterator(const InputMethodClientsTable * table,Table::Iterator iterator)701 explicit ConstIterator(const InputMethodClientsTable* table, 702 Table::Iterator iterator) 703 : AbstractConstIterator(table, std::move(iterator)) {} 704 CurrentRowNumber()705 uint32_t CurrentRowNumber() const { 706 return iterator_.StorageIndexForLastOverlay(); 707 } 708 709 private: 710 friend class InputMethodClientsTable; 711 friend class macros_internal::AbstractConstIterator< 712 ConstIterator, InputMethodClientsTable, RowNumber, ConstRowReference>; 713 }; 714 class Iterator : public ConstIterator { 715 public: row_reference()716 RowReference row_reference() const { 717 return {const_cast<InputMethodClientsTable*>(table()), CurrentRowNumber()}; 718 } 719 720 private: 721 friend class InputMethodClientsTable; 722 Iterator(InputMethodClientsTable * table,Table::Iterator iterator)723 explicit Iterator(InputMethodClientsTable* table, Table::Iterator iterator) 724 : ConstIterator(table, std::move(iterator)) {} 725 }; 726 727 struct IdAndRow { 728 Id id; 729 uint32_t row; 730 RowReference row_reference; 731 RowNumber row_number; 732 }; 733 GetColumns(InputMethodClientsTable * self,const macros_internal::MacroTable * parent)734 static std::vector<ColumnLegacy> GetColumns( 735 InputMethodClientsTable* self, 736 const macros_internal::MacroTable* parent) { 737 std::vector<ColumnLegacy> columns = 738 CopyColumnsFromParentOrAddRootColumns(self, parent); 739 uint32_t olay_idx = OverlayCount(parent); 740 AddColumnToVector(columns, "ts", &self->ts_, ColumnFlag::ts, 741 static_cast<uint32_t>(columns.size()), olay_idx); 742 AddColumnToVector(columns, "arg_set_id", &self->arg_set_id_, ColumnFlag::arg_set_id, 743 static_cast<uint32_t>(columns.size()), olay_idx); 744 AddColumnToVector(columns, "base64_proto", &self->base64_proto_, ColumnFlag::base64_proto, 745 static_cast<uint32_t>(columns.size()), olay_idx); 746 AddColumnToVector(columns, "base64_proto_id", &self->base64_proto_id_, ColumnFlag::base64_proto_id, 747 static_cast<uint32_t>(columns.size()), olay_idx); 748 return columns; 749 } 750 InputMethodClientsTable(StringPool * pool)751 PERFETTO_NO_INLINE explicit InputMethodClientsTable(StringPool* pool) 752 : macros_internal::MacroTable( 753 pool, 754 GetColumns(this, nullptr), 755 nullptr), 756 ts_(ColumnStorage<ColumnType::ts::stored_type>::Create<false>()), 757 arg_set_id_(ColumnStorage<ColumnType::arg_set_id::stored_type>::Create<false>()), 758 base64_proto_(ColumnStorage<ColumnType::base64_proto::stored_type>::Create<false>()), 759 base64_proto_id_(ColumnStorage<ColumnType::base64_proto_id::stored_type>::Create<false>()) 760 , 761 id_storage_layer_(new column::IdStorage()), 762 type_storage_layer_( 763 new column::StringStorage(string_pool(), &type_.vector())), 764 ts_storage_layer_( 765 new column::NumericStorage<ColumnType::ts::non_optional_stored_type>( 766 &ts_.vector(), 767 ColumnTypeHelper<ColumnType::ts::stored_type>::ToColumnType(), 768 true)), 769 arg_set_id_storage_layer_( 770 new column::NumericStorage<ColumnType::arg_set_id::non_optional_stored_type>( 771 &arg_set_id_.vector(), 772 ColumnTypeHelper<ColumnType::arg_set_id::stored_type>::ToColumnType(), 773 false)), 774 base64_proto_storage_layer_( 775 new column::StringStorage(string_pool(), &base64_proto_.vector())), 776 base64_proto_id_storage_layer_( 777 new column::NumericStorage<ColumnType::base64_proto_id::non_optional_stored_type>( 778 &base64_proto_id_.non_null_vector(), 779 ColumnTypeHelper<ColumnType::base64_proto_id::stored_type>::ToColumnType(), 780 false)) 781 , 782 base64_proto_id_null_layer_(new column::NullOverlay(base64_proto_id_.bv())) { 783 static_assert( 784 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::ts::stored_type>( 785 ColumnFlag::ts), 786 "Column type and flag combination is not valid"); 787 static_assert( 788 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::arg_set_id::stored_type>( 789 ColumnFlag::arg_set_id), 790 "Column type and flag combination is not valid"); 791 static_assert( 792 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::base64_proto::stored_type>( 793 ColumnFlag::base64_proto), 794 "Column type and flag combination is not valid"); 795 static_assert( 796 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::base64_proto_id::stored_type>( 797 ColumnFlag::base64_proto_id), 798 "Column type and flag combination is not valid"); 799 OnConstructionCompletedRegularConstructor( 800 {id_storage_layer_,type_storage_layer_,ts_storage_layer_,arg_set_id_storage_layer_,base64_proto_storage_layer_,base64_proto_id_storage_layer_}, 801 {{},{},{},{},{},base64_proto_id_null_layer_}); 802 } 803 ~InputMethodClientsTable() override; 804 Name()805 static const char* Name() { return "__intrinsic_inputmethod_clients"; } 806 ComputeStaticSchema()807 static Table::Schema ComputeStaticSchema() { 808 Table::Schema schema; 809 schema.columns.emplace_back(Table::Schema::Column{ 810 "id", SqlValue::Type::kLong, true, true, false, false}); 811 schema.columns.emplace_back(Table::Schema::Column{ 812 "type", SqlValue::Type::kString, false, false, false, false}); 813 schema.columns.emplace_back(Table::Schema::Column{ 814 "ts", ColumnType::ts::SqlValueType(), false, 815 true, 816 false, 817 false}); 818 schema.columns.emplace_back(Table::Schema::Column{ 819 "arg_set_id", ColumnType::arg_set_id::SqlValueType(), false, 820 false, 821 false, 822 false}); 823 schema.columns.emplace_back(Table::Schema::Column{ 824 "base64_proto", ColumnType::base64_proto::SqlValueType(), false, 825 false, 826 false, 827 false}); 828 schema.columns.emplace_back(Table::Schema::Column{ 829 "base64_proto_id", ColumnType::base64_proto_id::SqlValueType(), false, 830 false, 831 false, 832 false}); 833 return schema; 834 } 835 IterateRows()836 ConstIterator IterateRows() const { 837 return ConstIterator(this, Table::IterateRows()); 838 } 839 IterateRows()840 Iterator IterateRows() { return Iterator(this, Table::IterateRows()); } 841 FilterToIterator(const Query & q)842 ConstIterator FilterToIterator(const Query& q) const { 843 return ConstIterator(this, QueryToIterator(q)); 844 } 845 FilterToIterator(const Query & q)846 Iterator FilterToIterator(const Query& q) { 847 return Iterator(this, QueryToIterator(q)); 848 } 849 ShrinkToFit()850 void ShrinkToFit() { 851 type_.ShrinkToFit(); 852 ts_.ShrinkToFit(); 853 arg_set_id_.ShrinkToFit(); 854 base64_proto_.ShrinkToFit(); 855 base64_proto_id_.ShrinkToFit(); 856 } 857 858 ConstRowReference operator[](uint32_t r) const { 859 return ConstRowReference(this, r); 860 } 861 RowReference operator[](uint32_t r) { return RowReference(this, r); } 862 ConstRowReference operator[](RowNumber r) const { 863 return ConstRowReference(this, r.row_number()); 864 } 865 RowReference operator[](RowNumber r) { 866 return RowReference(this, r.row_number()); 867 } 868 FindById(Id find_id)869 std::optional<ConstRowReference> FindById(Id find_id) const { 870 std::optional<uint32_t> row = id().IndexOf(find_id); 871 return row ? std::make_optional(ConstRowReference(this, *row)) 872 : std::nullopt; 873 } 874 FindById(Id find_id)875 std::optional<RowReference> FindById(Id find_id) { 876 std::optional<uint32_t> row = id().IndexOf(find_id); 877 return row ? std::make_optional(RowReference(this, *row)) : std::nullopt; 878 } 879 Insert(const Row & row)880 IdAndRow Insert(const Row& row) { 881 uint32_t row_number = row_count(); 882 Id id = Id{row_number}; 883 type_.Append(string_pool()->InternString(row.type())); 884 mutable_ts()->Append(row.ts); 885 mutable_arg_set_id()->Append(row.arg_set_id); 886 mutable_base64_proto()->Append(row.base64_proto); 887 mutable_base64_proto_id()->Append(row.base64_proto_id); 888 UpdateSelfOverlayAfterInsert(); 889 return IdAndRow{id, row_number, RowReference(this, row_number), 890 RowNumber(row_number)}; 891 } 892 893 894 id()895 const IdColumn<InputMethodClientsTable::Id>& id() const { 896 return static_cast<const ColumnType::id&>(columns()[ColumnIndex::id]); 897 } type()898 const TypedColumn<StringPool::Id>& type() const { 899 return static_cast<const ColumnType::type&>(columns()[ColumnIndex::type]); 900 } ts()901 const TypedColumn<int64_t>& ts() const { 902 return static_cast<const ColumnType::ts&>(columns()[ColumnIndex::ts]); 903 } arg_set_id()904 const TypedColumn<uint32_t>& arg_set_id() const { 905 return static_cast<const ColumnType::arg_set_id&>(columns()[ColumnIndex::arg_set_id]); 906 } base64_proto()907 const TypedColumn<StringPool::Id>& base64_proto() const { 908 return static_cast<const ColumnType::base64_proto&>(columns()[ColumnIndex::base64_proto]); 909 } base64_proto_id()910 const TypedColumn<std::optional<uint32_t>>& base64_proto_id() const { 911 return static_cast<const ColumnType::base64_proto_id&>(columns()[ColumnIndex::base64_proto_id]); 912 } 913 mutable_ts()914 TypedColumn<int64_t>* mutable_ts() { 915 return static_cast<ColumnType::ts*>( 916 GetColumn(ColumnIndex::ts)); 917 } mutable_arg_set_id()918 TypedColumn<uint32_t>* mutable_arg_set_id() { 919 return static_cast<ColumnType::arg_set_id*>( 920 GetColumn(ColumnIndex::arg_set_id)); 921 } mutable_base64_proto()922 TypedColumn<StringPool::Id>* mutable_base64_proto() { 923 return static_cast<ColumnType::base64_proto*>( 924 GetColumn(ColumnIndex::base64_proto)); 925 } mutable_base64_proto_id()926 TypedColumn<std::optional<uint32_t>>* mutable_base64_proto_id() { 927 return static_cast<ColumnType::base64_proto_id*>( 928 GetColumn(ColumnIndex::base64_proto_id)); 929 } 930 931 private: 932 933 934 ColumnStorage<ColumnType::ts::stored_type> ts_; 935 ColumnStorage<ColumnType::arg_set_id::stored_type> arg_set_id_; 936 ColumnStorage<ColumnType::base64_proto::stored_type> base64_proto_; 937 ColumnStorage<ColumnType::base64_proto_id::stored_type> base64_proto_id_; 938 939 RefPtr<column::StorageLayer> id_storage_layer_; 940 RefPtr<column::StorageLayer> type_storage_layer_; 941 RefPtr<column::StorageLayer> ts_storage_layer_; 942 RefPtr<column::StorageLayer> arg_set_id_storage_layer_; 943 RefPtr<column::StorageLayer> base64_proto_storage_layer_; 944 RefPtr<column::StorageLayer> base64_proto_id_storage_layer_; 945 946 RefPtr<column::OverlayLayer> base64_proto_id_null_layer_; 947 }; 948 949 950 class InputMethodManagerServiceTable : public macros_internal::MacroTable { 951 public: 952 static constexpr uint32_t kColumnCount = 6; 953 954 struct Id : public BaseId { 955 Id() = default; IdId956 explicit constexpr Id(uint32_t v) : BaseId(v) {} 957 }; 958 static_assert(std::is_trivially_destructible_v<Id>, 959 "Inheritance used without trivial destruction"); 960 961 struct ColumnIndex { 962 static constexpr uint32_t id = 0; 963 static constexpr uint32_t type = 1; 964 static constexpr uint32_t ts = 2; 965 static constexpr uint32_t arg_set_id = 3; 966 static constexpr uint32_t base64_proto = 4; 967 static constexpr uint32_t base64_proto_id = 5; 968 }; 969 struct ColumnType { 970 using id = IdColumn<InputMethodManagerServiceTable::Id>; 971 using type = TypedColumn<StringPool::Id>; 972 using ts = TypedColumn<int64_t>; 973 using arg_set_id = TypedColumn<uint32_t>; 974 using base64_proto = TypedColumn<StringPool::Id>; 975 using base64_proto_id = TypedColumn<std::optional<uint32_t>>; 976 }; 977 struct Row : public macros_internal::RootParentTable::Row { 978 Row(int64_t in_ts = {}, 979 uint32_t in_arg_set_id = {}, 980 StringPool::Id in_base64_proto = {}, 981 std::optional<uint32_t> in_base64_proto_id = {}, 982 std::nullptr_t = nullptr) RowRow983 : macros_internal::RootParentTable::Row(), 984 ts(in_ts), 985 arg_set_id(in_arg_set_id), 986 base64_proto(in_base64_proto), 987 base64_proto_id(in_base64_proto_id) { 988 type_ = "__intrinsic_inputmethod_manager_service"; 989 } 990 int64_t ts; 991 uint32_t arg_set_id; 992 StringPool::Id base64_proto; 993 std::optional<uint32_t> base64_proto_id; 994 995 bool operator==(const InputMethodManagerServiceTable::Row& other) const { 996 return type() == other.type() && ColumnType::ts::Equals(ts, other.ts) && 997 ColumnType::arg_set_id::Equals(arg_set_id, other.arg_set_id) && 998 ColumnType::base64_proto::Equals(base64_proto, other.base64_proto) && 999 ColumnType::base64_proto_id::Equals(base64_proto_id, other.base64_proto_id); 1000 } 1001 }; 1002 struct ColumnFlag { 1003 static constexpr uint32_t ts = static_cast<uint32_t>(ColumnLegacy::Flag::kSorted) | ColumnType::ts::default_flags(); 1004 static constexpr uint32_t arg_set_id = ColumnType::arg_set_id::default_flags(); 1005 static constexpr uint32_t base64_proto = ColumnType::base64_proto::default_flags(); 1006 static constexpr uint32_t base64_proto_id = ColumnType::base64_proto_id::default_flags(); 1007 }; 1008 1009 class RowNumber; 1010 class ConstRowReference; 1011 class RowReference; 1012 1013 class RowNumber : public macros_internal::AbstractRowNumber< 1014 InputMethodManagerServiceTable, ConstRowReference, RowReference> { 1015 public: RowNumber(uint32_t row_number)1016 explicit RowNumber(uint32_t row_number) 1017 : AbstractRowNumber(row_number) {} 1018 }; 1019 static_assert(std::is_trivially_destructible_v<RowNumber>, 1020 "Inheritance used without trivial destruction"); 1021 1022 class ConstRowReference : public macros_internal::AbstractConstRowReference< 1023 InputMethodManagerServiceTable, RowNumber> { 1024 public: ConstRowReference(const InputMethodManagerServiceTable * table,uint32_t row_number)1025 ConstRowReference(const InputMethodManagerServiceTable* table, uint32_t row_number) 1026 : AbstractConstRowReference(table, row_number) {} 1027 id()1028 ColumnType::id::type id() const { 1029 return table()->id()[row_number_]; 1030 } type()1031 ColumnType::type::type type() const { 1032 return table()->type()[row_number_]; 1033 } ts()1034 ColumnType::ts::type ts() const { 1035 return table()->ts()[row_number_]; 1036 } arg_set_id()1037 ColumnType::arg_set_id::type arg_set_id() const { 1038 return table()->arg_set_id()[row_number_]; 1039 } base64_proto()1040 ColumnType::base64_proto::type base64_proto() const { 1041 return table()->base64_proto()[row_number_]; 1042 } base64_proto_id()1043 ColumnType::base64_proto_id::type base64_proto_id() const { 1044 return table()->base64_proto_id()[row_number_]; 1045 } 1046 }; 1047 static_assert(std::is_trivially_destructible_v<ConstRowReference>, 1048 "Inheritance used without trivial destruction"); 1049 class RowReference : public ConstRowReference { 1050 public: RowReference(const InputMethodManagerServiceTable * table,uint32_t row_number)1051 RowReference(const InputMethodManagerServiceTable* table, uint32_t row_number) 1052 : ConstRowReference(table, row_number) {} 1053 set_ts(ColumnType::ts::non_optional_type v)1054 void set_ts( 1055 ColumnType::ts::non_optional_type v) { 1056 return mutable_table()->mutable_ts()->Set(row_number_, v); 1057 } set_arg_set_id(ColumnType::arg_set_id::non_optional_type v)1058 void set_arg_set_id( 1059 ColumnType::arg_set_id::non_optional_type v) { 1060 return mutable_table()->mutable_arg_set_id()->Set(row_number_, v); 1061 } set_base64_proto(ColumnType::base64_proto::non_optional_type v)1062 void set_base64_proto( 1063 ColumnType::base64_proto::non_optional_type v) { 1064 return mutable_table()->mutable_base64_proto()->Set(row_number_, v); 1065 } set_base64_proto_id(ColumnType::base64_proto_id::non_optional_type v)1066 void set_base64_proto_id( 1067 ColumnType::base64_proto_id::non_optional_type v) { 1068 return mutable_table()->mutable_base64_proto_id()->Set(row_number_, v); 1069 } 1070 1071 private: mutable_table()1072 InputMethodManagerServiceTable* mutable_table() const { 1073 return const_cast<InputMethodManagerServiceTable*>(table()); 1074 } 1075 }; 1076 static_assert(std::is_trivially_destructible_v<RowReference>, 1077 "Inheritance used without trivial destruction"); 1078 1079 class ConstIterator; 1080 class ConstIterator : public macros_internal::AbstractConstIterator< 1081 ConstIterator, InputMethodManagerServiceTable, RowNumber, ConstRowReference> { 1082 public: id()1083 ColumnType::id::type id() const { 1084 const auto& col = table()->id(); 1085 return col.GetAtIdx( 1086 iterator_.StorageIndexForColumn(col.index_in_table())); 1087 } type()1088 ColumnType::type::type type() const { 1089 const auto& col = table()->type(); 1090 return col.GetAtIdx( 1091 iterator_.StorageIndexForColumn(col.index_in_table())); 1092 } ts()1093 ColumnType::ts::type ts() const { 1094 const auto& col = table()->ts(); 1095 return col.GetAtIdx( 1096 iterator_.StorageIndexForColumn(col.index_in_table())); 1097 } arg_set_id()1098 ColumnType::arg_set_id::type arg_set_id() const { 1099 const auto& col = table()->arg_set_id(); 1100 return col.GetAtIdx( 1101 iterator_.StorageIndexForColumn(col.index_in_table())); 1102 } base64_proto()1103 ColumnType::base64_proto::type base64_proto() const { 1104 const auto& col = table()->base64_proto(); 1105 return col.GetAtIdx( 1106 iterator_.StorageIndexForColumn(col.index_in_table())); 1107 } base64_proto_id()1108 ColumnType::base64_proto_id::type base64_proto_id() const { 1109 const auto& col = table()->base64_proto_id(); 1110 return col.GetAtIdx( 1111 iterator_.StorageIndexForColumn(col.index_in_table())); 1112 } 1113 1114 protected: ConstIterator(const InputMethodManagerServiceTable * table,Table::Iterator iterator)1115 explicit ConstIterator(const InputMethodManagerServiceTable* table, 1116 Table::Iterator iterator) 1117 : AbstractConstIterator(table, std::move(iterator)) {} 1118 CurrentRowNumber()1119 uint32_t CurrentRowNumber() const { 1120 return iterator_.StorageIndexForLastOverlay(); 1121 } 1122 1123 private: 1124 friend class InputMethodManagerServiceTable; 1125 friend class macros_internal::AbstractConstIterator< 1126 ConstIterator, InputMethodManagerServiceTable, RowNumber, ConstRowReference>; 1127 }; 1128 class Iterator : public ConstIterator { 1129 public: row_reference()1130 RowReference row_reference() const { 1131 return {const_cast<InputMethodManagerServiceTable*>(table()), CurrentRowNumber()}; 1132 } 1133 1134 private: 1135 friend class InputMethodManagerServiceTable; 1136 Iterator(InputMethodManagerServiceTable * table,Table::Iterator iterator)1137 explicit Iterator(InputMethodManagerServiceTable* table, Table::Iterator iterator) 1138 : ConstIterator(table, std::move(iterator)) {} 1139 }; 1140 1141 struct IdAndRow { 1142 Id id; 1143 uint32_t row; 1144 RowReference row_reference; 1145 RowNumber row_number; 1146 }; 1147 GetColumns(InputMethodManagerServiceTable * self,const macros_internal::MacroTable * parent)1148 static std::vector<ColumnLegacy> GetColumns( 1149 InputMethodManagerServiceTable* self, 1150 const macros_internal::MacroTable* parent) { 1151 std::vector<ColumnLegacy> columns = 1152 CopyColumnsFromParentOrAddRootColumns(self, parent); 1153 uint32_t olay_idx = OverlayCount(parent); 1154 AddColumnToVector(columns, "ts", &self->ts_, ColumnFlag::ts, 1155 static_cast<uint32_t>(columns.size()), olay_idx); 1156 AddColumnToVector(columns, "arg_set_id", &self->arg_set_id_, ColumnFlag::arg_set_id, 1157 static_cast<uint32_t>(columns.size()), olay_idx); 1158 AddColumnToVector(columns, "base64_proto", &self->base64_proto_, ColumnFlag::base64_proto, 1159 static_cast<uint32_t>(columns.size()), olay_idx); 1160 AddColumnToVector(columns, "base64_proto_id", &self->base64_proto_id_, ColumnFlag::base64_proto_id, 1161 static_cast<uint32_t>(columns.size()), olay_idx); 1162 return columns; 1163 } 1164 InputMethodManagerServiceTable(StringPool * pool)1165 PERFETTO_NO_INLINE explicit InputMethodManagerServiceTable(StringPool* pool) 1166 : macros_internal::MacroTable( 1167 pool, 1168 GetColumns(this, nullptr), 1169 nullptr), 1170 ts_(ColumnStorage<ColumnType::ts::stored_type>::Create<false>()), 1171 arg_set_id_(ColumnStorage<ColumnType::arg_set_id::stored_type>::Create<false>()), 1172 base64_proto_(ColumnStorage<ColumnType::base64_proto::stored_type>::Create<false>()), 1173 base64_proto_id_(ColumnStorage<ColumnType::base64_proto_id::stored_type>::Create<false>()) 1174 , 1175 id_storage_layer_(new column::IdStorage()), 1176 type_storage_layer_( 1177 new column::StringStorage(string_pool(), &type_.vector())), 1178 ts_storage_layer_( 1179 new column::NumericStorage<ColumnType::ts::non_optional_stored_type>( 1180 &ts_.vector(), 1181 ColumnTypeHelper<ColumnType::ts::stored_type>::ToColumnType(), 1182 true)), 1183 arg_set_id_storage_layer_( 1184 new column::NumericStorage<ColumnType::arg_set_id::non_optional_stored_type>( 1185 &arg_set_id_.vector(), 1186 ColumnTypeHelper<ColumnType::arg_set_id::stored_type>::ToColumnType(), 1187 false)), 1188 base64_proto_storage_layer_( 1189 new column::StringStorage(string_pool(), &base64_proto_.vector())), 1190 base64_proto_id_storage_layer_( 1191 new column::NumericStorage<ColumnType::base64_proto_id::non_optional_stored_type>( 1192 &base64_proto_id_.non_null_vector(), 1193 ColumnTypeHelper<ColumnType::base64_proto_id::stored_type>::ToColumnType(), 1194 false)) 1195 , 1196 base64_proto_id_null_layer_(new column::NullOverlay(base64_proto_id_.bv())) { 1197 static_assert( 1198 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::ts::stored_type>( 1199 ColumnFlag::ts), 1200 "Column type and flag combination is not valid"); 1201 static_assert( 1202 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::arg_set_id::stored_type>( 1203 ColumnFlag::arg_set_id), 1204 "Column type and flag combination is not valid"); 1205 static_assert( 1206 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::base64_proto::stored_type>( 1207 ColumnFlag::base64_proto), 1208 "Column type and flag combination is not valid"); 1209 static_assert( 1210 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::base64_proto_id::stored_type>( 1211 ColumnFlag::base64_proto_id), 1212 "Column type and flag combination is not valid"); 1213 OnConstructionCompletedRegularConstructor( 1214 {id_storage_layer_,type_storage_layer_,ts_storage_layer_,arg_set_id_storage_layer_,base64_proto_storage_layer_,base64_proto_id_storage_layer_}, 1215 {{},{},{},{},{},base64_proto_id_null_layer_}); 1216 } 1217 ~InputMethodManagerServiceTable() override; 1218 Name()1219 static const char* Name() { return "__intrinsic_inputmethod_manager_service"; } 1220 ComputeStaticSchema()1221 static Table::Schema ComputeStaticSchema() { 1222 Table::Schema schema; 1223 schema.columns.emplace_back(Table::Schema::Column{ 1224 "id", SqlValue::Type::kLong, true, true, false, false}); 1225 schema.columns.emplace_back(Table::Schema::Column{ 1226 "type", SqlValue::Type::kString, false, false, false, false}); 1227 schema.columns.emplace_back(Table::Schema::Column{ 1228 "ts", ColumnType::ts::SqlValueType(), false, 1229 true, 1230 false, 1231 false}); 1232 schema.columns.emplace_back(Table::Schema::Column{ 1233 "arg_set_id", ColumnType::arg_set_id::SqlValueType(), false, 1234 false, 1235 false, 1236 false}); 1237 schema.columns.emplace_back(Table::Schema::Column{ 1238 "base64_proto", ColumnType::base64_proto::SqlValueType(), false, 1239 false, 1240 false, 1241 false}); 1242 schema.columns.emplace_back(Table::Schema::Column{ 1243 "base64_proto_id", ColumnType::base64_proto_id::SqlValueType(), false, 1244 false, 1245 false, 1246 false}); 1247 return schema; 1248 } 1249 IterateRows()1250 ConstIterator IterateRows() const { 1251 return ConstIterator(this, Table::IterateRows()); 1252 } 1253 IterateRows()1254 Iterator IterateRows() { return Iterator(this, Table::IterateRows()); } 1255 FilterToIterator(const Query & q)1256 ConstIterator FilterToIterator(const Query& q) const { 1257 return ConstIterator(this, QueryToIterator(q)); 1258 } 1259 FilterToIterator(const Query & q)1260 Iterator FilterToIterator(const Query& q) { 1261 return Iterator(this, QueryToIterator(q)); 1262 } 1263 ShrinkToFit()1264 void ShrinkToFit() { 1265 type_.ShrinkToFit(); 1266 ts_.ShrinkToFit(); 1267 arg_set_id_.ShrinkToFit(); 1268 base64_proto_.ShrinkToFit(); 1269 base64_proto_id_.ShrinkToFit(); 1270 } 1271 1272 ConstRowReference operator[](uint32_t r) const { 1273 return ConstRowReference(this, r); 1274 } 1275 RowReference operator[](uint32_t r) { return RowReference(this, r); } 1276 ConstRowReference operator[](RowNumber r) const { 1277 return ConstRowReference(this, r.row_number()); 1278 } 1279 RowReference operator[](RowNumber r) { 1280 return RowReference(this, r.row_number()); 1281 } 1282 FindById(Id find_id)1283 std::optional<ConstRowReference> FindById(Id find_id) const { 1284 std::optional<uint32_t> row = id().IndexOf(find_id); 1285 return row ? std::make_optional(ConstRowReference(this, *row)) 1286 : std::nullopt; 1287 } 1288 FindById(Id find_id)1289 std::optional<RowReference> FindById(Id find_id) { 1290 std::optional<uint32_t> row = id().IndexOf(find_id); 1291 return row ? std::make_optional(RowReference(this, *row)) : std::nullopt; 1292 } 1293 Insert(const Row & row)1294 IdAndRow Insert(const Row& row) { 1295 uint32_t row_number = row_count(); 1296 Id id = Id{row_number}; 1297 type_.Append(string_pool()->InternString(row.type())); 1298 mutable_ts()->Append(row.ts); 1299 mutable_arg_set_id()->Append(row.arg_set_id); 1300 mutable_base64_proto()->Append(row.base64_proto); 1301 mutable_base64_proto_id()->Append(row.base64_proto_id); 1302 UpdateSelfOverlayAfterInsert(); 1303 return IdAndRow{id, row_number, RowReference(this, row_number), 1304 RowNumber(row_number)}; 1305 } 1306 1307 1308 id()1309 const IdColumn<InputMethodManagerServiceTable::Id>& id() const { 1310 return static_cast<const ColumnType::id&>(columns()[ColumnIndex::id]); 1311 } type()1312 const TypedColumn<StringPool::Id>& type() const { 1313 return static_cast<const ColumnType::type&>(columns()[ColumnIndex::type]); 1314 } ts()1315 const TypedColumn<int64_t>& ts() const { 1316 return static_cast<const ColumnType::ts&>(columns()[ColumnIndex::ts]); 1317 } arg_set_id()1318 const TypedColumn<uint32_t>& arg_set_id() const { 1319 return static_cast<const ColumnType::arg_set_id&>(columns()[ColumnIndex::arg_set_id]); 1320 } base64_proto()1321 const TypedColumn<StringPool::Id>& base64_proto() const { 1322 return static_cast<const ColumnType::base64_proto&>(columns()[ColumnIndex::base64_proto]); 1323 } base64_proto_id()1324 const TypedColumn<std::optional<uint32_t>>& base64_proto_id() const { 1325 return static_cast<const ColumnType::base64_proto_id&>(columns()[ColumnIndex::base64_proto_id]); 1326 } 1327 mutable_ts()1328 TypedColumn<int64_t>* mutable_ts() { 1329 return static_cast<ColumnType::ts*>( 1330 GetColumn(ColumnIndex::ts)); 1331 } mutable_arg_set_id()1332 TypedColumn<uint32_t>* mutable_arg_set_id() { 1333 return static_cast<ColumnType::arg_set_id*>( 1334 GetColumn(ColumnIndex::arg_set_id)); 1335 } mutable_base64_proto()1336 TypedColumn<StringPool::Id>* mutable_base64_proto() { 1337 return static_cast<ColumnType::base64_proto*>( 1338 GetColumn(ColumnIndex::base64_proto)); 1339 } mutable_base64_proto_id()1340 TypedColumn<std::optional<uint32_t>>* mutable_base64_proto_id() { 1341 return static_cast<ColumnType::base64_proto_id*>( 1342 GetColumn(ColumnIndex::base64_proto_id)); 1343 } 1344 1345 private: 1346 1347 1348 ColumnStorage<ColumnType::ts::stored_type> ts_; 1349 ColumnStorage<ColumnType::arg_set_id::stored_type> arg_set_id_; 1350 ColumnStorage<ColumnType::base64_proto::stored_type> base64_proto_; 1351 ColumnStorage<ColumnType::base64_proto_id::stored_type> base64_proto_id_; 1352 1353 RefPtr<column::StorageLayer> id_storage_layer_; 1354 RefPtr<column::StorageLayer> type_storage_layer_; 1355 RefPtr<column::StorageLayer> ts_storage_layer_; 1356 RefPtr<column::StorageLayer> arg_set_id_storage_layer_; 1357 RefPtr<column::StorageLayer> base64_proto_storage_layer_; 1358 RefPtr<column::StorageLayer> base64_proto_id_storage_layer_; 1359 1360 RefPtr<column::OverlayLayer> base64_proto_id_null_layer_; 1361 }; 1362 1363 1364 class InputMethodServiceTable : public macros_internal::MacroTable { 1365 public: 1366 static constexpr uint32_t kColumnCount = 6; 1367 1368 struct Id : public BaseId { 1369 Id() = default; IdId1370 explicit constexpr Id(uint32_t v) : BaseId(v) {} 1371 }; 1372 static_assert(std::is_trivially_destructible_v<Id>, 1373 "Inheritance used without trivial destruction"); 1374 1375 struct ColumnIndex { 1376 static constexpr uint32_t id = 0; 1377 static constexpr uint32_t type = 1; 1378 static constexpr uint32_t ts = 2; 1379 static constexpr uint32_t arg_set_id = 3; 1380 static constexpr uint32_t base64_proto = 4; 1381 static constexpr uint32_t base64_proto_id = 5; 1382 }; 1383 struct ColumnType { 1384 using id = IdColumn<InputMethodServiceTable::Id>; 1385 using type = TypedColumn<StringPool::Id>; 1386 using ts = TypedColumn<int64_t>; 1387 using arg_set_id = TypedColumn<uint32_t>; 1388 using base64_proto = TypedColumn<StringPool::Id>; 1389 using base64_proto_id = TypedColumn<std::optional<uint32_t>>; 1390 }; 1391 struct Row : public macros_internal::RootParentTable::Row { 1392 Row(int64_t in_ts = {}, 1393 uint32_t in_arg_set_id = {}, 1394 StringPool::Id in_base64_proto = {}, 1395 std::optional<uint32_t> in_base64_proto_id = {}, 1396 std::nullptr_t = nullptr) RowRow1397 : macros_internal::RootParentTable::Row(), 1398 ts(in_ts), 1399 arg_set_id(in_arg_set_id), 1400 base64_proto(in_base64_proto), 1401 base64_proto_id(in_base64_proto_id) { 1402 type_ = "__intrinsic_inputmethod_service"; 1403 } 1404 int64_t ts; 1405 uint32_t arg_set_id; 1406 StringPool::Id base64_proto; 1407 std::optional<uint32_t> base64_proto_id; 1408 1409 bool operator==(const InputMethodServiceTable::Row& other) const { 1410 return type() == other.type() && ColumnType::ts::Equals(ts, other.ts) && 1411 ColumnType::arg_set_id::Equals(arg_set_id, other.arg_set_id) && 1412 ColumnType::base64_proto::Equals(base64_proto, other.base64_proto) && 1413 ColumnType::base64_proto_id::Equals(base64_proto_id, other.base64_proto_id); 1414 } 1415 }; 1416 struct ColumnFlag { 1417 static constexpr uint32_t ts = static_cast<uint32_t>(ColumnLegacy::Flag::kSorted) | ColumnType::ts::default_flags(); 1418 static constexpr uint32_t arg_set_id = ColumnType::arg_set_id::default_flags(); 1419 static constexpr uint32_t base64_proto = ColumnType::base64_proto::default_flags(); 1420 static constexpr uint32_t base64_proto_id = ColumnType::base64_proto_id::default_flags(); 1421 }; 1422 1423 class RowNumber; 1424 class ConstRowReference; 1425 class RowReference; 1426 1427 class RowNumber : public macros_internal::AbstractRowNumber< 1428 InputMethodServiceTable, ConstRowReference, RowReference> { 1429 public: RowNumber(uint32_t row_number)1430 explicit RowNumber(uint32_t row_number) 1431 : AbstractRowNumber(row_number) {} 1432 }; 1433 static_assert(std::is_trivially_destructible_v<RowNumber>, 1434 "Inheritance used without trivial destruction"); 1435 1436 class ConstRowReference : public macros_internal::AbstractConstRowReference< 1437 InputMethodServiceTable, RowNumber> { 1438 public: ConstRowReference(const InputMethodServiceTable * table,uint32_t row_number)1439 ConstRowReference(const InputMethodServiceTable* table, uint32_t row_number) 1440 : AbstractConstRowReference(table, row_number) {} 1441 id()1442 ColumnType::id::type id() const { 1443 return table()->id()[row_number_]; 1444 } type()1445 ColumnType::type::type type() const { 1446 return table()->type()[row_number_]; 1447 } ts()1448 ColumnType::ts::type ts() const { 1449 return table()->ts()[row_number_]; 1450 } arg_set_id()1451 ColumnType::arg_set_id::type arg_set_id() const { 1452 return table()->arg_set_id()[row_number_]; 1453 } base64_proto()1454 ColumnType::base64_proto::type base64_proto() const { 1455 return table()->base64_proto()[row_number_]; 1456 } base64_proto_id()1457 ColumnType::base64_proto_id::type base64_proto_id() const { 1458 return table()->base64_proto_id()[row_number_]; 1459 } 1460 }; 1461 static_assert(std::is_trivially_destructible_v<ConstRowReference>, 1462 "Inheritance used without trivial destruction"); 1463 class RowReference : public ConstRowReference { 1464 public: RowReference(const InputMethodServiceTable * table,uint32_t row_number)1465 RowReference(const InputMethodServiceTable* table, uint32_t row_number) 1466 : ConstRowReference(table, row_number) {} 1467 set_ts(ColumnType::ts::non_optional_type v)1468 void set_ts( 1469 ColumnType::ts::non_optional_type v) { 1470 return mutable_table()->mutable_ts()->Set(row_number_, v); 1471 } set_arg_set_id(ColumnType::arg_set_id::non_optional_type v)1472 void set_arg_set_id( 1473 ColumnType::arg_set_id::non_optional_type v) { 1474 return mutable_table()->mutable_arg_set_id()->Set(row_number_, v); 1475 } set_base64_proto(ColumnType::base64_proto::non_optional_type v)1476 void set_base64_proto( 1477 ColumnType::base64_proto::non_optional_type v) { 1478 return mutable_table()->mutable_base64_proto()->Set(row_number_, v); 1479 } set_base64_proto_id(ColumnType::base64_proto_id::non_optional_type v)1480 void set_base64_proto_id( 1481 ColumnType::base64_proto_id::non_optional_type v) { 1482 return mutable_table()->mutable_base64_proto_id()->Set(row_number_, v); 1483 } 1484 1485 private: mutable_table()1486 InputMethodServiceTable* mutable_table() const { 1487 return const_cast<InputMethodServiceTable*>(table()); 1488 } 1489 }; 1490 static_assert(std::is_trivially_destructible_v<RowReference>, 1491 "Inheritance used without trivial destruction"); 1492 1493 class ConstIterator; 1494 class ConstIterator : public macros_internal::AbstractConstIterator< 1495 ConstIterator, InputMethodServiceTable, RowNumber, ConstRowReference> { 1496 public: id()1497 ColumnType::id::type id() const { 1498 const auto& col = table()->id(); 1499 return col.GetAtIdx( 1500 iterator_.StorageIndexForColumn(col.index_in_table())); 1501 } type()1502 ColumnType::type::type type() const { 1503 const auto& col = table()->type(); 1504 return col.GetAtIdx( 1505 iterator_.StorageIndexForColumn(col.index_in_table())); 1506 } ts()1507 ColumnType::ts::type ts() const { 1508 const auto& col = table()->ts(); 1509 return col.GetAtIdx( 1510 iterator_.StorageIndexForColumn(col.index_in_table())); 1511 } arg_set_id()1512 ColumnType::arg_set_id::type arg_set_id() const { 1513 const auto& col = table()->arg_set_id(); 1514 return col.GetAtIdx( 1515 iterator_.StorageIndexForColumn(col.index_in_table())); 1516 } base64_proto()1517 ColumnType::base64_proto::type base64_proto() const { 1518 const auto& col = table()->base64_proto(); 1519 return col.GetAtIdx( 1520 iterator_.StorageIndexForColumn(col.index_in_table())); 1521 } base64_proto_id()1522 ColumnType::base64_proto_id::type base64_proto_id() const { 1523 const auto& col = table()->base64_proto_id(); 1524 return col.GetAtIdx( 1525 iterator_.StorageIndexForColumn(col.index_in_table())); 1526 } 1527 1528 protected: ConstIterator(const InputMethodServiceTable * table,Table::Iterator iterator)1529 explicit ConstIterator(const InputMethodServiceTable* table, 1530 Table::Iterator iterator) 1531 : AbstractConstIterator(table, std::move(iterator)) {} 1532 CurrentRowNumber()1533 uint32_t CurrentRowNumber() const { 1534 return iterator_.StorageIndexForLastOverlay(); 1535 } 1536 1537 private: 1538 friend class InputMethodServiceTable; 1539 friend class macros_internal::AbstractConstIterator< 1540 ConstIterator, InputMethodServiceTable, RowNumber, ConstRowReference>; 1541 }; 1542 class Iterator : public ConstIterator { 1543 public: row_reference()1544 RowReference row_reference() const { 1545 return {const_cast<InputMethodServiceTable*>(table()), CurrentRowNumber()}; 1546 } 1547 1548 private: 1549 friend class InputMethodServiceTable; 1550 Iterator(InputMethodServiceTable * table,Table::Iterator iterator)1551 explicit Iterator(InputMethodServiceTable* table, Table::Iterator iterator) 1552 : ConstIterator(table, std::move(iterator)) {} 1553 }; 1554 1555 struct IdAndRow { 1556 Id id; 1557 uint32_t row; 1558 RowReference row_reference; 1559 RowNumber row_number; 1560 }; 1561 GetColumns(InputMethodServiceTable * self,const macros_internal::MacroTable * parent)1562 static std::vector<ColumnLegacy> GetColumns( 1563 InputMethodServiceTable* self, 1564 const macros_internal::MacroTable* parent) { 1565 std::vector<ColumnLegacy> columns = 1566 CopyColumnsFromParentOrAddRootColumns(self, parent); 1567 uint32_t olay_idx = OverlayCount(parent); 1568 AddColumnToVector(columns, "ts", &self->ts_, ColumnFlag::ts, 1569 static_cast<uint32_t>(columns.size()), olay_idx); 1570 AddColumnToVector(columns, "arg_set_id", &self->arg_set_id_, ColumnFlag::arg_set_id, 1571 static_cast<uint32_t>(columns.size()), olay_idx); 1572 AddColumnToVector(columns, "base64_proto", &self->base64_proto_, ColumnFlag::base64_proto, 1573 static_cast<uint32_t>(columns.size()), olay_idx); 1574 AddColumnToVector(columns, "base64_proto_id", &self->base64_proto_id_, ColumnFlag::base64_proto_id, 1575 static_cast<uint32_t>(columns.size()), olay_idx); 1576 return columns; 1577 } 1578 InputMethodServiceTable(StringPool * pool)1579 PERFETTO_NO_INLINE explicit InputMethodServiceTable(StringPool* pool) 1580 : macros_internal::MacroTable( 1581 pool, 1582 GetColumns(this, nullptr), 1583 nullptr), 1584 ts_(ColumnStorage<ColumnType::ts::stored_type>::Create<false>()), 1585 arg_set_id_(ColumnStorage<ColumnType::arg_set_id::stored_type>::Create<false>()), 1586 base64_proto_(ColumnStorage<ColumnType::base64_proto::stored_type>::Create<false>()), 1587 base64_proto_id_(ColumnStorage<ColumnType::base64_proto_id::stored_type>::Create<false>()) 1588 , 1589 id_storage_layer_(new column::IdStorage()), 1590 type_storage_layer_( 1591 new column::StringStorage(string_pool(), &type_.vector())), 1592 ts_storage_layer_( 1593 new column::NumericStorage<ColumnType::ts::non_optional_stored_type>( 1594 &ts_.vector(), 1595 ColumnTypeHelper<ColumnType::ts::stored_type>::ToColumnType(), 1596 true)), 1597 arg_set_id_storage_layer_( 1598 new column::NumericStorage<ColumnType::arg_set_id::non_optional_stored_type>( 1599 &arg_set_id_.vector(), 1600 ColumnTypeHelper<ColumnType::arg_set_id::stored_type>::ToColumnType(), 1601 false)), 1602 base64_proto_storage_layer_( 1603 new column::StringStorage(string_pool(), &base64_proto_.vector())), 1604 base64_proto_id_storage_layer_( 1605 new column::NumericStorage<ColumnType::base64_proto_id::non_optional_stored_type>( 1606 &base64_proto_id_.non_null_vector(), 1607 ColumnTypeHelper<ColumnType::base64_proto_id::stored_type>::ToColumnType(), 1608 false)) 1609 , 1610 base64_proto_id_null_layer_(new column::NullOverlay(base64_proto_id_.bv())) { 1611 static_assert( 1612 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::ts::stored_type>( 1613 ColumnFlag::ts), 1614 "Column type and flag combination is not valid"); 1615 static_assert( 1616 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::arg_set_id::stored_type>( 1617 ColumnFlag::arg_set_id), 1618 "Column type and flag combination is not valid"); 1619 static_assert( 1620 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::base64_proto::stored_type>( 1621 ColumnFlag::base64_proto), 1622 "Column type and flag combination is not valid"); 1623 static_assert( 1624 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::base64_proto_id::stored_type>( 1625 ColumnFlag::base64_proto_id), 1626 "Column type and flag combination is not valid"); 1627 OnConstructionCompletedRegularConstructor( 1628 {id_storage_layer_,type_storage_layer_,ts_storage_layer_,arg_set_id_storage_layer_,base64_proto_storage_layer_,base64_proto_id_storage_layer_}, 1629 {{},{},{},{},{},base64_proto_id_null_layer_}); 1630 } 1631 ~InputMethodServiceTable() override; 1632 Name()1633 static const char* Name() { return "__intrinsic_inputmethod_service"; } 1634 ComputeStaticSchema()1635 static Table::Schema ComputeStaticSchema() { 1636 Table::Schema schema; 1637 schema.columns.emplace_back(Table::Schema::Column{ 1638 "id", SqlValue::Type::kLong, true, true, false, false}); 1639 schema.columns.emplace_back(Table::Schema::Column{ 1640 "type", SqlValue::Type::kString, false, false, false, false}); 1641 schema.columns.emplace_back(Table::Schema::Column{ 1642 "ts", ColumnType::ts::SqlValueType(), false, 1643 true, 1644 false, 1645 false}); 1646 schema.columns.emplace_back(Table::Schema::Column{ 1647 "arg_set_id", ColumnType::arg_set_id::SqlValueType(), false, 1648 false, 1649 false, 1650 false}); 1651 schema.columns.emplace_back(Table::Schema::Column{ 1652 "base64_proto", ColumnType::base64_proto::SqlValueType(), false, 1653 false, 1654 false, 1655 false}); 1656 schema.columns.emplace_back(Table::Schema::Column{ 1657 "base64_proto_id", ColumnType::base64_proto_id::SqlValueType(), false, 1658 false, 1659 false, 1660 false}); 1661 return schema; 1662 } 1663 IterateRows()1664 ConstIterator IterateRows() const { 1665 return ConstIterator(this, Table::IterateRows()); 1666 } 1667 IterateRows()1668 Iterator IterateRows() { return Iterator(this, Table::IterateRows()); } 1669 FilterToIterator(const Query & q)1670 ConstIterator FilterToIterator(const Query& q) const { 1671 return ConstIterator(this, QueryToIterator(q)); 1672 } 1673 FilterToIterator(const Query & q)1674 Iterator FilterToIterator(const Query& q) { 1675 return Iterator(this, QueryToIterator(q)); 1676 } 1677 ShrinkToFit()1678 void ShrinkToFit() { 1679 type_.ShrinkToFit(); 1680 ts_.ShrinkToFit(); 1681 arg_set_id_.ShrinkToFit(); 1682 base64_proto_.ShrinkToFit(); 1683 base64_proto_id_.ShrinkToFit(); 1684 } 1685 1686 ConstRowReference operator[](uint32_t r) const { 1687 return ConstRowReference(this, r); 1688 } 1689 RowReference operator[](uint32_t r) { return RowReference(this, r); } 1690 ConstRowReference operator[](RowNumber r) const { 1691 return ConstRowReference(this, r.row_number()); 1692 } 1693 RowReference operator[](RowNumber r) { 1694 return RowReference(this, r.row_number()); 1695 } 1696 FindById(Id find_id)1697 std::optional<ConstRowReference> FindById(Id find_id) const { 1698 std::optional<uint32_t> row = id().IndexOf(find_id); 1699 return row ? std::make_optional(ConstRowReference(this, *row)) 1700 : std::nullopt; 1701 } 1702 FindById(Id find_id)1703 std::optional<RowReference> FindById(Id find_id) { 1704 std::optional<uint32_t> row = id().IndexOf(find_id); 1705 return row ? std::make_optional(RowReference(this, *row)) : std::nullopt; 1706 } 1707 Insert(const Row & row)1708 IdAndRow Insert(const Row& row) { 1709 uint32_t row_number = row_count(); 1710 Id id = Id{row_number}; 1711 type_.Append(string_pool()->InternString(row.type())); 1712 mutable_ts()->Append(row.ts); 1713 mutable_arg_set_id()->Append(row.arg_set_id); 1714 mutable_base64_proto()->Append(row.base64_proto); 1715 mutable_base64_proto_id()->Append(row.base64_proto_id); 1716 UpdateSelfOverlayAfterInsert(); 1717 return IdAndRow{id, row_number, RowReference(this, row_number), 1718 RowNumber(row_number)}; 1719 } 1720 1721 1722 id()1723 const IdColumn<InputMethodServiceTable::Id>& id() const { 1724 return static_cast<const ColumnType::id&>(columns()[ColumnIndex::id]); 1725 } type()1726 const TypedColumn<StringPool::Id>& type() const { 1727 return static_cast<const ColumnType::type&>(columns()[ColumnIndex::type]); 1728 } ts()1729 const TypedColumn<int64_t>& ts() const { 1730 return static_cast<const ColumnType::ts&>(columns()[ColumnIndex::ts]); 1731 } arg_set_id()1732 const TypedColumn<uint32_t>& arg_set_id() const { 1733 return static_cast<const ColumnType::arg_set_id&>(columns()[ColumnIndex::arg_set_id]); 1734 } base64_proto()1735 const TypedColumn<StringPool::Id>& base64_proto() const { 1736 return static_cast<const ColumnType::base64_proto&>(columns()[ColumnIndex::base64_proto]); 1737 } base64_proto_id()1738 const TypedColumn<std::optional<uint32_t>>& base64_proto_id() const { 1739 return static_cast<const ColumnType::base64_proto_id&>(columns()[ColumnIndex::base64_proto_id]); 1740 } 1741 mutable_ts()1742 TypedColumn<int64_t>* mutable_ts() { 1743 return static_cast<ColumnType::ts*>( 1744 GetColumn(ColumnIndex::ts)); 1745 } mutable_arg_set_id()1746 TypedColumn<uint32_t>* mutable_arg_set_id() { 1747 return static_cast<ColumnType::arg_set_id*>( 1748 GetColumn(ColumnIndex::arg_set_id)); 1749 } mutable_base64_proto()1750 TypedColumn<StringPool::Id>* mutable_base64_proto() { 1751 return static_cast<ColumnType::base64_proto*>( 1752 GetColumn(ColumnIndex::base64_proto)); 1753 } mutable_base64_proto_id()1754 TypedColumn<std::optional<uint32_t>>* mutable_base64_proto_id() { 1755 return static_cast<ColumnType::base64_proto_id*>( 1756 GetColumn(ColumnIndex::base64_proto_id)); 1757 } 1758 1759 private: 1760 1761 1762 ColumnStorage<ColumnType::ts::stored_type> ts_; 1763 ColumnStorage<ColumnType::arg_set_id::stored_type> arg_set_id_; 1764 ColumnStorage<ColumnType::base64_proto::stored_type> base64_proto_; 1765 ColumnStorage<ColumnType::base64_proto_id::stored_type> base64_proto_id_; 1766 1767 RefPtr<column::StorageLayer> id_storage_layer_; 1768 RefPtr<column::StorageLayer> type_storage_layer_; 1769 RefPtr<column::StorageLayer> ts_storage_layer_; 1770 RefPtr<column::StorageLayer> arg_set_id_storage_layer_; 1771 RefPtr<column::StorageLayer> base64_proto_storage_layer_; 1772 RefPtr<column::StorageLayer> base64_proto_id_storage_layer_; 1773 1774 RefPtr<column::OverlayLayer> base64_proto_id_null_layer_; 1775 }; 1776 1777 1778 class SurfaceFlingerLayersSnapshotTable : public macros_internal::MacroTable { 1779 public: 1780 static constexpr uint32_t kColumnCount = 6; 1781 1782 struct Id : public BaseId { 1783 Id() = default; IdId1784 explicit constexpr Id(uint32_t v) : BaseId(v) {} 1785 }; 1786 static_assert(std::is_trivially_destructible_v<Id>, 1787 "Inheritance used without trivial destruction"); 1788 1789 struct ColumnIndex { 1790 static constexpr uint32_t id = 0; 1791 static constexpr uint32_t type = 1; 1792 static constexpr uint32_t ts = 2; 1793 static constexpr uint32_t arg_set_id = 3; 1794 static constexpr uint32_t base64_proto = 4; 1795 static constexpr uint32_t base64_proto_id = 5; 1796 }; 1797 struct ColumnType { 1798 using id = IdColumn<SurfaceFlingerLayersSnapshotTable::Id>; 1799 using type = TypedColumn<StringPool::Id>; 1800 using ts = TypedColumn<int64_t>; 1801 using arg_set_id = TypedColumn<uint32_t>; 1802 using base64_proto = TypedColumn<StringPool::Id>; 1803 using base64_proto_id = TypedColumn<std::optional<uint32_t>>; 1804 }; 1805 struct Row : public macros_internal::RootParentTable::Row { 1806 Row(int64_t in_ts = {}, 1807 uint32_t in_arg_set_id = {}, 1808 StringPool::Id in_base64_proto = {}, 1809 std::optional<uint32_t> in_base64_proto_id = {}, 1810 std::nullptr_t = nullptr) RowRow1811 : macros_internal::RootParentTable::Row(), 1812 ts(in_ts), 1813 arg_set_id(in_arg_set_id), 1814 base64_proto(in_base64_proto), 1815 base64_proto_id(in_base64_proto_id) { 1816 type_ = "surfaceflinger_layers_snapshot"; 1817 } 1818 int64_t ts; 1819 uint32_t arg_set_id; 1820 StringPool::Id base64_proto; 1821 std::optional<uint32_t> base64_proto_id; 1822 1823 bool operator==(const SurfaceFlingerLayersSnapshotTable::Row& other) const { 1824 return type() == other.type() && ColumnType::ts::Equals(ts, other.ts) && 1825 ColumnType::arg_set_id::Equals(arg_set_id, other.arg_set_id) && 1826 ColumnType::base64_proto::Equals(base64_proto, other.base64_proto) && 1827 ColumnType::base64_proto_id::Equals(base64_proto_id, other.base64_proto_id); 1828 } 1829 }; 1830 struct ColumnFlag { 1831 static constexpr uint32_t ts = static_cast<uint32_t>(ColumnLegacy::Flag::kSorted) | ColumnType::ts::default_flags(); 1832 static constexpr uint32_t arg_set_id = ColumnType::arg_set_id::default_flags(); 1833 static constexpr uint32_t base64_proto = ColumnType::base64_proto::default_flags(); 1834 static constexpr uint32_t base64_proto_id = ColumnType::base64_proto_id::default_flags(); 1835 }; 1836 1837 class RowNumber; 1838 class ConstRowReference; 1839 class RowReference; 1840 1841 class RowNumber : public macros_internal::AbstractRowNumber< 1842 SurfaceFlingerLayersSnapshotTable, ConstRowReference, RowReference> { 1843 public: RowNumber(uint32_t row_number)1844 explicit RowNumber(uint32_t row_number) 1845 : AbstractRowNumber(row_number) {} 1846 }; 1847 static_assert(std::is_trivially_destructible_v<RowNumber>, 1848 "Inheritance used without trivial destruction"); 1849 1850 class ConstRowReference : public macros_internal::AbstractConstRowReference< 1851 SurfaceFlingerLayersSnapshotTable, RowNumber> { 1852 public: ConstRowReference(const SurfaceFlingerLayersSnapshotTable * table,uint32_t row_number)1853 ConstRowReference(const SurfaceFlingerLayersSnapshotTable* table, uint32_t row_number) 1854 : AbstractConstRowReference(table, row_number) {} 1855 id()1856 ColumnType::id::type id() const { 1857 return table()->id()[row_number_]; 1858 } type()1859 ColumnType::type::type type() const { 1860 return table()->type()[row_number_]; 1861 } ts()1862 ColumnType::ts::type ts() const { 1863 return table()->ts()[row_number_]; 1864 } arg_set_id()1865 ColumnType::arg_set_id::type arg_set_id() const { 1866 return table()->arg_set_id()[row_number_]; 1867 } base64_proto()1868 ColumnType::base64_proto::type base64_proto() const { 1869 return table()->base64_proto()[row_number_]; 1870 } base64_proto_id()1871 ColumnType::base64_proto_id::type base64_proto_id() const { 1872 return table()->base64_proto_id()[row_number_]; 1873 } 1874 }; 1875 static_assert(std::is_trivially_destructible_v<ConstRowReference>, 1876 "Inheritance used without trivial destruction"); 1877 class RowReference : public ConstRowReference { 1878 public: RowReference(const SurfaceFlingerLayersSnapshotTable * table,uint32_t row_number)1879 RowReference(const SurfaceFlingerLayersSnapshotTable* table, uint32_t row_number) 1880 : ConstRowReference(table, row_number) {} 1881 set_ts(ColumnType::ts::non_optional_type v)1882 void set_ts( 1883 ColumnType::ts::non_optional_type v) { 1884 return mutable_table()->mutable_ts()->Set(row_number_, v); 1885 } set_arg_set_id(ColumnType::arg_set_id::non_optional_type v)1886 void set_arg_set_id( 1887 ColumnType::arg_set_id::non_optional_type v) { 1888 return mutable_table()->mutable_arg_set_id()->Set(row_number_, v); 1889 } set_base64_proto(ColumnType::base64_proto::non_optional_type v)1890 void set_base64_proto( 1891 ColumnType::base64_proto::non_optional_type v) { 1892 return mutable_table()->mutable_base64_proto()->Set(row_number_, v); 1893 } set_base64_proto_id(ColumnType::base64_proto_id::non_optional_type v)1894 void set_base64_proto_id( 1895 ColumnType::base64_proto_id::non_optional_type v) { 1896 return mutable_table()->mutable_base64_proto_id()->Set(row_number_, v); 1897 } 1898 1899 private: mutable_table()1900 SurfaceFlingerLayersSnapshotTable* mutable_table() const { 1901 return const_cast<SurfaceFlingerLayersSnapshotTable*>(table()); 1902 } 1903 }; 1904 static_assert(std::is_trivially_destructible_v<RowReference>, 1905 "Inheritance used without trivial destruction"); 1906 1907 class ConstIterator; 1908 class ConstIterator : public macros_internal::AbstractConstIterator< 1909 ConstIterator, SurfaceFlingerLayersSnapshotTable, RowNumber, ConstRowReference> { 1910 public: id()1911 ColumnType::id::type id() const { 1912 const auto& col = table()->id(); 1913 return col.GetAtIdx( 1914 iterator_.StorageIndexForColumn(col.index_in_table())); 1915 } type()1916 ColumnType::type::type type() const { 1917 const auto& col = table()->type(); 1918 return col.GetAtIdx( 1919 iterator_.StorageIndexForColumn(col.index_in_table())); 1920 } ts()1921 ColumnType::ts::type ts() const { 1922 const auto& col = table()->ts(); 1923 return col.GetAtIdx( 1924 iterator_.StorageIndexForColumn(col.index_in_table())); 1925 } arg_set_id()1926 ColumnType::arg_set_id::type arg_set_id() const { 1927 const auto& col = table()->arg_set_id(); 1928 return col.GetAtIdx( 1929 iterator_.StorageIndexForColumn(col.index_in_table())); 1930 } base64_proto()1931 ColumnType::base64_proto::type base64_proto() const { 1932 const auto& col = table()->base64_proto(); 1933 return col.GetAtIdx( 1934 iterator_.StorageIndexForColumn(col.index_in_table())); 1935 } base64_proto_id()1936 ColumnType::base64_proto_id::type base64_proto_id() const { 1937 const auto& col = table()->base64_proto_id(); 1938 return col.GetAtIdx( 1939 iterator_.StorageIndexForColumn(col.index_in_table())); 1940 } 1941 1942 protected: ConstIterator(const SurfaceFlingerLayersSnapshotTable * table,Table::Iterator iterator)1943 explicit ConstIterator(const SurfaceFlingerLayersSnapshotTable* table, 1944 Table::Iterator iterator) 1945 : AbstractConstIterator(table, std::move(iterator)) {} 1946 CurrentRowNumber()1947 uint32_t CurrentRowNumber() const { 1948 return iterator_.StorageIndexForLastOverlay(); 1949 } 1950 1951 private: 1952 friend class SurfaceFlingerLayersSnapshotTable; 1953 friend class macros_internal::AbstractConstIterator< 1954 ConstIterator, SurfaceFlingerLayersSnapshotTable, RowNumber, ConstRowReference>; 1955 }; 1956 class Iterator : public ConstIterator { 1957 public: row_reference()1958 RowReference row_reference() const { 1959 return {const_cast<SurfaceFlingerLayersSnapshotTable*>(table()), CurrentRowNumber()}; 1960 } 1961 1962 private: 1963 friend class SurfaceFlingerLayersSnapshotTable; 1964 Iterator(SurfaceFlingerLayersSnapshotTable * table,Table::Iterator iterator)1965 explicit Iterator(SurfaceFlingerLayersSnapshotTable* table, Table::Iterator iterator) 1966 : ConstIterator(table, std::move(iterator)) {} 1967 }; 1968 1969 struct IdAndRow { 1970 Id id; 1971 uint32_t row; 1972 RowReference row_reference; 1973 RowNumber row_number; 1974 }; 1975 GetColumns(SurfaceFlingerLayersSnapshotTable * self,const macros_internal::MacroTable * parent)1976 static std::vector<ColumnLegacy> GetColumns( 1977 SurfaceFlingerLayersSnapshotTable* self, 1978 const macros_internal::MacroTable* parent) { 1979 std::vector<ColumnLegacy> columns = 1980 CopyColumnsFromParentOrAddRootColumns(self, parent); 1981 uint32_t olay_idx = OverlayCount(parent); 1982 AddColumnToVector(columns, "ts", &self->ts_, ColumnFlag::ts, 1983 static_cast<uint32_t>(columns.size()), olay_idx); 1984 AddColumnToVector(columns, "arg_set_id", &self->arg_set_id_, ColumnFlag::arg_set_id, 1985 static_cast<uint32_t>(columns.size()), olay_idx); 1986 AddColumnToVector(columns, "base64_proto", &self->base64_proto_, ColumnFlag::base64_proto, 1987 static_cast<uint32_t>(columns.size()), olay_idx); 1988 AddColumnToVector(columns, "base64_proto_id", &self->base64_proto_id_, ColumnFlag::base64_proto_id, 1989 static_cast<uint32_t>(columns.size()), olay_idx); 1990 return columns; 1991 } 1992 SurfaceFlingerLayersSnapshotTable(StringPool * pool)1993 PERFETTO_NO_INLINE explicit SurfaceFlingerLayersSnapshotTable(StringPool* pool) 1994 : macros_internal::MacroTable( 1995 pool, 1996 GetColumns(this, nullptr), 1997 nullptr), 1998 ts_(ColumnStorage<ColumnType::ts::stored_type>::Create<false>()), 1999 arg_set_id_(ColumnStorage<ColumnType::arg_set_id::stored_type>::Create<false>()), 2000 base64_proto_(ColumnStorage<ColumnType::base64_proto::stored_type>::Create<false>()), 2001 base64_proto_id_(ColumnStorage<ColumnType::base64_proto_id::stored_type>::Create<false>()) 2002 , 2003 id_storage_layer_(new column::IdStorage()), 2004 type_storage_layer_( 2005 new column::StringStorage(string_pool(), &type_.vector())), 2006 ts_storage_layer_( 2007 new column::NumericStorage<ColumnType::ts::non_optional_stored_type>( 2008 &ts_.vector(), 2009 ColumnTypeHelper<ColumnType::ts::stored_type>::ToColumnType(), 2010 true)), 2011 arg_set_id_storage_layer_( 2012 new column::NumericStorage<ColumnType::arg_set_id::non_optional_stored_type>( 2013 &arg_set_id_.vector(), 2014 ColumnTypeHelper<ColumnType::arg_set_id::stored_type>::ToColumnType(), 2015 false)), 2016 base64_proto_storage_layer_( 2017 new column::StringStorage(string_pool(), &base64_proto_.vector())), 2018 base64_proto_id_storage_layer_( 2019 new column::NumericStorage<ColumnType::base64_proto_id::non_optional_stored_type>( 2020 &base64_proto_id_.non_null_vector(), 2021 ColumnTypeHelper<ColumnType::base64_proto_id::stored_type>::ToColumnType(), 2022 false)) 2023 , 2024 base64_proto_id_null_layer_(new column::NullOverlay(base64_proto_id_.bv())) { 2025 static_assert( 2026 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::ts::stored_type>( 2027 ColumnFlag::ts), 2028 "Column type and flag combination is not valid"); 2029 static_assert( 2030 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::arg_set_id::stored_type>( 2031 ColumnFlag::arg_set_id), 2032 "Column type and flag combination is not valid"); 2033 static_assert( 2034 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::base64_proto::stored_type>( 2035 ColumnFlag::base64_proto), 2036 "Column type and flag combination is not valid"); 2037 static_assert( 2038 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::base64_proto_id::stored_type>( 2039 ColumnFlag::base64_proto_id), 2040 "Column type and flag combination is not valid"); 2041 OnConstructionCompletedRegularConstructor( 2042 {id_storage_layer_,type_storage_layer_,ts_storage_layer_,arg_set_id_storage_layer_,base64_proto_storage_layer_,base64_proto_id_storage_layer_}, 2043 {{},{},{},{},{},base64_proto_id_null_layer_}); 2044 } 2045 ~SurfaceFlingerLayersSnapshotTable() override; 2046 Name()2047 static const char* Name() { return "surfaceflinger_layers_snapshot"; } 2048 ComputeStaticSchema()2049 static Table::Schema ComputeStaticSchema() { 2050 Table::Schema schema; 2051 schema.columns.emplace_back(Table::Schema::Column{ 2052 "id", SqlValue::Type::kLong, true, true, false, false}); 2053 schema.columns.emplace_back(Table::Schema::Column{ 2054 "type", SqlValue::Type::kString, false, false, false, false}); 2055 schema.columns.emplace_back(Table::Schema::Column{ 2056 "ts", ColumnType::ts::SqlValueType(), false, 2057 true, 2058 false, 2059 false}); 2060 schema.columns.emplace_back(Table::Schema::Column{ 2061 "arg_set_id", ColumnType::arg_set_id::SqlValueType(), false, 2062 false, 2063 false, 2064 false}); 2065 schema.columns.emplace_back(Table::Schema::Column{ 2066 "base64_proto", ColumnType::base64_proto::SqlValueType(), false, 2067 false, 2068 false, 2069 false}); 2070 schema.columns.emplace_back(Table::Schema::Column{ 2071 "base64_proto_id", ColumnType::base64_proto_id::SqlValueType(), false, 2072 false, 2073 false, 2074 false}); 2075 return schema; 2076 } 2077 IterateRows()2078 ConstIterator IterateRows() const { 2079 return ConstIterator(this, Table::IterateRows()); 2080 } 2081 IterateRows()2082 Iterator IterateRows() { return Iterator(this, Table::IterateRows()); } 2083 FilterToIterator(const Query & q)2084 ConstIterator FilterToIterator(const Query& q) const { 2085 return ConstIterator(this, QueryToIterator(q)); 2086 } 2087 FilterToIterator(const Query & q)2088 Iterator FilterToIterator(const Query& q) { 2089 return Iterator(this, QueryToIterator(q)); 2090 } 2091 ShrinkToFit()2092 void ShrinkToFit() { 2093 type_.ShrinkToFit(); 2094 ts_.ShrinkToFit(); 2095 arg_set_id_.ShrinkToFit(); 2096 base64_proto_.ShrinkToFit(); 2097 base64_proto_id_.ShrinkToFit(); 2098 } 2099 2100 ConstRowReference operator[](uint32_t r) const { 2101 return ConstRowReference(this, r); 2102 } 2103 RowReference operator[](uint32_t r) { return RowReference(this, r); } 2104 ConstRowReference operator[](RowNumber r) const { 2105 return ConstRowReference(this, r.row_number()); 2106 } 2107 RowReference operator[](RowNumber r) { 2108 return RowReference(this, r.row_number()); 2109 } 2110 FindById(Id find_id)2111 std::optional<ConstRowReference> FindById(Id find_id) const { 2112 std::optional<uint32_t> row = id().IndexOf(find_id); 2113 return row ? std::make_optional(ConstRowReference(this, *row)) 2114 : std::nullopt; 2115 } 2116 FindById(Id find_id)2117 std::optional<RowReference> FindById(Id find_id) { 2118 std::optional<uint32_t> row = id().IndexOf(find_id); 2119 return row ? std::make_optional(RowReference(this, *row)) : std::nullopt; 2120 } 2121 Insert(const Row & row)2122 IdAndRow Insert(const Row& row) { 2123 uint32_t row_number = row_count(); 2124 Id id = Id{row_number}; 2125 type_.Append(string_pool()->InternString(row.type())); 2126 mutable_ts()->Append(row.ts); 2127 mutable_arg_set_id()->Append(row.arg_set_id); 2128 mutable_base64_proto()->Append(row.base64_proto); 2129 mutable_base64_proto_id()->Append(row.base64_proto_id); 2130 UpdateSelfOverlayAfterInsert(); 2131 return IdAndRow{id, row_number, RowReference(this, row_number), 2132 RowNumber(row_number)}; 2133 } 2134 2135 2136 id()2137 const IdColumn<SurfaceFlingerLayersSnapshotTable::Id>& id() const { 2138 return static_cast<const ColumnType::id&>(columns()[ColumnIndex::id]); 2139 } type()2140 const TypedColumn<StringPool::Id>& type() const { 2141 return static_cast<const ColumnType::type&>(columns()[ColumnIndex::type]); 2142 } ts()2143 const TypedColumn<int64_t>& ts() const { 2144 return static_cast<const ColumnType::ts&>(columns()[ColumnIndex::ts]); 2145 } arg_set_id()2146 const TypedColumn<uint32_t>& arg_set_id() const { 2147 return static_cast<const ColumnType::arg_set_id&>(columns()[ColumnIndex::arg_set_id]); 2148 } base64_proto()2149 const TypedColumn<StringPool::Id>& base64_proto() const { 2150 return static_cast<const ColumnType::base64_proto&>(columns()[ColumnIndex::base64_proto]); 2151 } base64_proto_id()2152 const TypedColumn<std::optional<uint32_t>>& base64_proto_id() const { 2153 return static_cast<const ColumnType::base64_proto_id&>(columns()[ColumnIndex::base64_proto_id]); 2154 } 2155 mutable_ts()2156 TypedColumn<int64_t>* mutable_ts() { 2157 return static_cast<ColumnType::ts*>( 2158 GetColumn(ColumnIndex::ts)); 2159 } mutable_arg_set_id()2160 TypedColumn<uint32_t>* mutable_arg_set_id() { 2161 return static_cast<ColumnType::arg_set_id*>( 2162 GetColumn(ColumnIndex::arg_set_id)); 2163 } mutable_base64_proto()2164 TypedColumn<StringPool::Id>* mutable_base64_proto() { 2165 return static_cast<ColumnType::base64_proto*>( 2166 GetColumn(ColumnIndex::base64_proto)); 2167 } mutable_base64_proto_id()2168 TypedColumn<std::optional<uint32_t>>* mutable_base64_proto_id() { 2169 return static_cast<ColumnType::base64_proto_id*>( 2170 GetColumn(ColumnIndex::base64_proto_id)); 2171 } 2172 2173 private: 2174 2175 2176 ColumnStorage<ColumnType::ts::stored_type> ts_; 2177 ColumnStorage<ColumnType::arg_set_id::stored_type> arg_set_id_; 2178 ColumnStorage<ColumnType::base64_proto::stored_type> base64_proto_; 2179 ColumnStorage<ColumnType::base64_proto_id::stored_type> base64_proto_id_; 2180 2181 RefPtr<column::StorageLayer> id_storage_layer_; 2182 RefPtr<column::StorageLayer> type_storage_layer_; 2183 RefPtr<column::StorageLayer> ts_storage_layer_; 2184 RefPtr<column::StorageLayer> arg_set_id_storage_layer_; 2185 RefPtr<column::StorageLayer> base64_proto_storage_layer_; 2186 RefPtr<column::StorageLayer> base64_proto_id_storage_layer_; 2187 2188 RefPtr<column::OverlayLayer> base64_proto_id_null_layer_; 2189 }; 2190 2191 2192 class SurfaceFlingerLayerTable : public macros_internal::MacroTable { 2193 public: 2194 static constexpr uint32_t kColumnCount = 6; 2195 2196 struct Id : public BaseId { 2197 Id() = default; IdId2198 explicit constexpr Id(uint32_t v) : BaseId(v) {} 2199 }; 2200 static_assert(std::is_trivially_destructible_v<Id>, 2201 "Inheritance used without trivial destruction"); 2202 2203 struct ColumnIndex { 2204 static constexpr uint32_t id = 0; 2205 static constexpr uint32_t type = 1; 2206 static constexpr uint32_t snapshot_id = 2; 2207 static constexpr uint32_t arg_set_id = 3; 2208 static constexpr uint32_t base64_proto = 4; 2209 static constexpr uint32_t base64_proto_id = 5; 2210 }; 2211 struct ColumnType { 2212 using id = IdColumn<SurfaceFlingerLayerTable::Id>; 2213 using type = TypedColumn<StringPool::Id>; 2214 using snapshot_id = TypedColumn<SurfaceFlingerLayersSnapshotTable::Id>; 2215 using arg_set_id = TypedColumn<uint32_t>; 2216 using base64_proto = TypedColumn<StringPool::Id>; 2217 using base64_proto_id = TypedColumn<std::optional<uint32_t>>; 2218 }; 2219 struct Row : public macros_internal::RootParentTable::Row { 2220 Row(SurfaceFlingerLayersSnapshotTable::Id in_snapshot_id = {}, 2221 uint32_t in_arg_set_id = {}, 2222 StringPool::Id in_base64_proto = {}, 2223 std::optional<uint32_t> in_base64_proto_id = {}, 2224 std::nullptr_t = nullptr) RowRow2225 : macros_internal::RootParentTable::Row(), 2226 snapshot_id(in_snapshot_id), 2227 arg_set_id(in_arg_set_id), 2228 base64_proto(in_base64_proto), 2229 base64_proto_id(in_base64_proto_id) { 2230 type_ = "surfaceflinger_layer"; 2231 } 2232 SurfaceFlingerLayersSnapshotTable::Id snapshot_id; 2233 uint32_t arg_set_id; 2234 StringPool::Id base64_proto; 2235 std::optional<uint32_t> base64_proto_id; 2236 2237 bool operator==(const SurfaceFlingerLayerTable::Row& other) const { 2238 return type() == other.type() && ColumnType::snapshot_id::Equals(snapshot_id, other.snapshot_id) && 2239 ColumnType::arg_set_id::Equals(arg_set_id, other.arg_set_id) && 2240 ColumnType::base64_proto::Equals(base64_proto, other.base64_proto) && 2241 ColumnType::base64_proto_id::Equals(base64_proto_id, other.base64_proto_id); 2242 } 2243 }; 2244 struct ColumnFlag { 2245 static constexpr uint32_t snapshot_id = ColumnType::snapshot_id::default_flags(); 2246 static constexpr uint32_t arg_set_id = ColumnType::arg_set_id::default_flags(); 2247 static constexpr uint32_t base64_proto = ColumnType::base64_proto::default_flags(); 2248 static constexpr uint32_t base64_proto_id = ColumnType::base64_proto_id::default_flags(); 2249 }; 2250 2251 class RowNumber; 2252 class ConstRowReference; 2253 class RowReference; 2254 2255 class RowNumber : public macros_internal::AbstractRowNumber< 2256 SurfaceFlingerLayerTable, ConstRowReference, RowReference> { 2257 public: RowNumber(uint32_t row_number)2258 explicit RowNumber(uint32_t row_number) 2259 : AbstractRowNumber(row_number) {} 2260 }; 2261 static_assert(std::is_trivially_destructible_v<RowNumber>, 2262 "Inheritance used without trivial destruction"); 2263 2264 class ConstRowReference : public macros_internal::AbstractConstRowReference< 2265 SurfaceFlingerLayerTable, RowNumber> { 2266 public: ConstRowReference(const SurfaceFlingerLayerTable * table,uint32_t row_number)2267 ConstRowReference(const SurfaceFlingerLayerTable* table, uint32_t row_number) 2268 : AbstractConstRowReference(table, row_number) {} 2269 id()2270 ColumnType::id::type id() const { 2271 return table()->id()[row_number_]; 2272 } type()2273 ColumnType::type::type type() const { 2274 return table()->type()[row_number_]; 2275 } snapshot_id()2276 ColumnType::snapshot_id::type snapshot_id() const { 2277 return table()->snapshot_id()[row_number_]; 2278 } arg_set_id()2279 ColumnType::arg_set_id::type arg_set_id() const { 2280 return table()->arg_set_id()[row_number_]; 2281 } base64_proto()2282 ColumnType::base64_proto::type base64_proto() const { 2283 return table()->base64_proto()[row_number_]; 2284 } base64_proto_id()2285 ColumnType::base64_proto_id::type base64_proto_id() const { 2286 return table()->base64_proto_id()[row_number_]; 2287 } 2288 }; 2289 static_assert(std::is_trivially_destructible_v<ConstRowReference>, 2290 "Inheritance used without trivial destruction"); 2291 class RowReference : public ConstRowReference { 2292 public: RowReference(const SurfaceFlingerLayerTable * table,uint32_t row_number)2293 RowReference(const SurfaceFlingerLayerTable* table, uint32_t row_number) 2294 : ConstRowReference(table, row_number) {} 2295 set_snapshot_id(ColumnType::snapshot_id::non_optional_type v)2296 void set_snapshot_id( 2297 ColumnType::snapshot_id::non_optional_type v) { 2298 return mutable_table()->mutable_snapshot_id()->Set(row_number_, v); 2299 } set_arg_set_id(ColumnType::arg_set_id::non_optional_type v)2300 void set_arg_set_id( 2301 ColumnType::arg_set_id::non_optional_type v) { 2302 return mutable_table()->mutable_arg_set_id()->Set(row_number_, v); 2303 } set_base64_proto(ColumnType::base64_proto::non_optional_type v)2304 void set_base64_proto( 2305 ColumnType::base64_proto::non_optional_type v) { 2306 return mutable_table()->mutable_base64_proto()->Set(row_number_, v); 2307 } set_base64_proto_id(ColumnType::base64_proto_id::non_optional_type v)2308 void set_base64_proto_id( 2309 ColumnType::base64_proto_id::non_optional_type v) { 2310 return mutable_table()->mutable_base64_proto_id()->Set(row_number_, v); 2311 } 2312 2313 private: mutable_table()2314 SurfaceFlingerLayerTable* mutable_table() const { 2315 return const_cast<SurfaceFlingerLayerTable*>(table()); 2316 } 2317 }; 2318 static_assert(std::is_trivially_destructible_v<RowReference>, 2319 "Inheritance used without trivial destruction"); 2320 2321 class ConstIterator; 2322 class ConstIterator : public macros_internal::AbstractConstIterator< 2323 ConstIterator, SurfaceFlingerLayerTable, RowNumber, ConstRowReference> { 2324 public: id()2325 ColumnType::id::type id() const { 2326 const auto& col = table()->id(); 2327 return col.GetAtIdx( 2328 iterator_.StorageIndexForColumn(col.index_in_table())); 2329 } type()2330 ColumnType::type::type type() const { 2331 const auto& col = table()->type(); 2332 return col.GetAtIdx( 2333 iterator_.StorageIndexForColumn(col.index_in_table())); 2334 } snapshot_id()2335 ColumnType::snapshot_id::type snapshot_id() const { 2336 const auto& col = table()->snapshot_id(); 2337 return col.GetAtIdx( 2338 iterator_.StorageIndexForColumn(col.index_in_table())); 2339 } arg_set_id()2340 ColumnType::arg_set_id::type arg_set_id() const { 2341 const auto& col = table()->arg_set_id(); 2342 return col.GetAtIdx( 2343 iterator_.StorageIndexForColumn(col.index_in_table())); 2344 } base64_proto()2345 ColumnType::base64_proto::type base64_proto() const { 2346 const auto& col = table()->base64_proto(); 2347 return col.GetAtIdx( 2348 iterator_.StorageIndexForColumn(col.index_in_table())); 2349 } base64_proto_id()2350 ColumnType::base64_proto_id::type base64_proto_id() const { 2351 const auto& col = table()->base64_proto_id(); 2352 return col.GetAtIdx( 2353 iterator_.StorageIndexForColumn(col.index_in_table())); 2354 } 2355 2356 protected: ConstIterator(const SurfaceFlingerLayerTable * table,Table::Iterator iterator)2357 explicit ConstIterator(const SurfaceFlingerLayerTable* table, 2358 Table::Iterator iterator) 2359 : AbstractConstIterator(table, std::move(iterator)) {} 2360 CurrentRowNumber()2361 uint32_t CurrentRowNumber() const { 2362 return iterator_.StorageIndexForLastOverlay(); 2363 } 2364 2365 private: 2366 friend class SurfaceFlingerLayerTable; 2367 friend class macros_internal::AbstractConstIterator< 2368 ConstIterator, SurfaceFlingerLayerTable, RowNumber, ConstRowReference>; 2369 }; 2370 class Iterator : public ConstIterator { 2371 public: row_reference()2372 RowReference row_reference() const { 2373 return {const_cast<SurfaceFlingerLayerTable*>(table()), CurrentRowNumber()}; 2374 } 2375 2376 private: 2377 friend class SurfaceFlingerLayerTable; 2378 Iterator(SurfaceFlingerLayerTable * table,Table::Iterator iterator)2379 explicit Iterator(SurfaceFlingerLayerTable* table, Table::Iterator iterator) 2380 : ConstIterator(table, std::move(iterator)) {} 2381 }; 2382 2383 struct IdAndRow { 2384 Id id; 2385 uint32_t row; 2386 RowReference row_reference; 2387 RowNumber row_number; 2388 }; 2389 GetColumns(SurfaceFlingerLayerTable * self,const macros_internal::MacroTable * parent)2390 static std::vector<ColumnLegacy> GetColumns( 2391 SurfaceFlingerLayerTable* self, 2392 const macros_internal::MacroTable* parent) { 2393 std::vector<ColumnLegacy> columns = 2394 CopyColumnsFromParentOrAddRootColumns(self, parent); 2395 uint32_t olay_idx = OverlayCount(parent); 2396 AddColumnToVector(columns, "snapshot_id", &self->snapshot_id_, ColumnFlag::snapshot_id, 2397 static_cast<uint32_t>(columns.size()), olay_idx); 2398 AddColumnToVector(columns, "arg_set_id", &self->arg_set_id_, ColumnFlag::arg_set_id, 2399 static_cast<uint32_t>(columns.size()), olay_idx); 2400 AddColumnToVector(columns, "base64_proto", &self->base64_proto_, ColumnFlag::base64_proto, 2401 static_cast<uint32_t>(columns.size()), olay_idx); 2402 AddColumnToVector(columns, "base64_proto_id", &self->base64_proto_id_, ColumnFlag::base64_proto_id, 2403 static_cast<uint32_t>(columns.size()), olay_idx); 2404 return columns; 2405 } 2406 SurfaceFlingerLayerTable(StringPool * pool)2407 PERFETTO_NO_INLINE explicit SurfaceFlingerLayerTable(StringPool* pool) 2408 : macros_internal::MacroTable( 2409 pool, 2410 GetColumns(this, nullptr), 2411 nullptr), 2412 snapshot_id_(ColumnStorage<ColumnType::snapshot_id::stored_type>::Create<false>()), 2413 arg_set_id_(ColumnStorage<ColumnType::arg_set_id::stored_type>::Create<false>()), 2414 base64_proto_(ColumnStorage<ColumnType::base64_proto::stored_type>::Create<false>()), 2415 base64_proto_id_(ColumnStorage<ColumnType::base64_proto_id::stored_type>::Create<false>()) 2416 , 2417 id_storage_layer_(new column::IdStorage()), 2418 type_storage_layer_( 2419 new column::StringStorage(string_pool(), &type_.vector())), 2420 snapshot_id_storage_layer_( 2421 new column::NumericStorage<ColumnType::snapshot_id::non_optional_stored_type>( 2422 &snapshot_id_.vector(), 2423 ColumnTypeHelper<ColumnType::snapshot_id::stored_type>::ToColumnType(), 2424 false)), 2425 arg_set_id_storage_layer_( 2426 new column::NumericStorage<ColumnType::arg_set_id::non_optional_stored_type>( 2427 &arg_set_id_.vector(), 2428 ColumnTypeHelper<ColumnType::arg_set_id::stored_type>::ToColumnType(), 2429 false)), 2430 base64_proto_storage_layer_( 2431 new column::StringStorage(string_pool(), &base64_proto_.vector())), 2432 base64_proto_id_storage_layer_( 2433 new column::NumericStorage<ColumnType::base64_proto_id::non_optional_stored_type>( 2434 &base64_proto_id_.non_null_vector(), 2435 ColumnTypeHelper<ColumnType::base64_proto_id::stored_type>::ToColumnType(), 2436 false)) 2437 , 2438 base64_proto_id_null_layer_(new column::NullOverlay(base64_proto_id_.bv())) { 2439 static_assert( 2440 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::snapshot_id::stored_type>( 2441 ColumnFlag::snapshot_id), 2442 "Column type and flag combination is not valid"); 2443 static_assert( 2444 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::arg_set_id::stored_type>( 2445 ColumnFlag::arg_set_id), 2446 "Column type and flag combination is not valid"); 2447 static_assert( 2448 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::base64_proto::stored_type>( 2449 ColumnFlag::base64_proto), 2450 "Column type and flag combination is not valid"); 2451 static_assert( 2452 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::base64_proto_id::stored_type>( 2453 ColumnFlag::base64_proto_id), 2454 "Column type and flag combination is not valid"); 2455 OnConstructionCompletedRegularConstructor( 2456 {id_storage_layer_,type_storage_layer_,snapshot_id_storage_layer_,arg_set_id_storage_layer_,base64_proto_storage_layer_,base64_proto_id_storage_layer_}, 2457 {{},{},{},{},{},base64_proto_id_null_layer_}); 2458 } 2459 ~SurfaceFlingerLayerTable() override; 2460 Name()2461 static const char* Name() { return "surfaceflinger_layer"; } 2462 ComputeStaticSchema()2463 static Table::Schema ComputeStaticSchema() { 2464 Table::Schema schema; 2465 schema.columns.emplace_back(Table::Schema::Column{ 2466 "id", SqlValue::Type::kLong, true, true, false, false}); 2467 schema.columns.emplace_back(Table::Schema::Column{ 2468 "type", SqlValue::Type::kString, false, false, false, false}); 2469 schema.columns.emplace_back(Table::Schema::Column{ 2470 "snapshot_id", ColumnType::snapshot_id::SqlValueType(), false, 2471 false, 2472 false, 2473 false}); 2474 schema.columns.emplace_back(Table::Schema::Column{ 2475 "arg_set_id", ColumnType::arg_set_id::SqlValueType(), false, 2476 false, 2477 false, 2478 false}); 2479 schema.columns.emplace_back(Table::Schema::Column{ 2480 "base64_proto", ColumnType::base64_proto::SqlValueType(), false, 2481 false, 2482 false, 2483 false}); 2484 schema.columns.emplace_back(Table::Schema::Column{ 2485 "base64_proto_id", ColumnType::base64_proto_id::SqlValueType(), false, 2486 false, 2487 false, 2488 false}); 2489 return schema; 2490 } 2491 IterateRows()2492 ConstIterator IterateRows() const { 2493 return ConstIterator(this, Table::IterateRows()); 2494 } 2495 IterateRows()2496 Iterator IterateRows() { return Iterator(this, Table::IterateRows()); } 2497 FilterToIterator(const Query & q)2498 ConstIterator FilterToIterator(const Query& q) const { 2499 return ConstIterator(this, QueryToIterator(q)); 2500 } 2501 FilterToIterator(const Query & q)2502 Iterator FilterToIterator(const Query& q) { 2503 return Iterator(this, QueryToIterator(q)); 2504 } 2505 ShrinkToFit()2506 void ShrinkToFit() { 2507 type_.ShrinkToFit(); 2508 snapshot_id_.ShrinkToFit(); 2509 arg_set_id_.ShrinkToFit(); 2510 base64_proto_.ShrinkToFit(); 2511 base64_proto_id_.ShrinkToFit(); 2512 } 2513 2514 ConstRowReference operator[](uint32_t r) const { 2515 return ConstRowReference(this, r); 2516 } 2517 RowReference operator[](uint32_t r) { return RowReference(this, r); } 2518 ConstRowReference operator[](RowNumber r) const { 2519 return ConstRowReference(this, r.row_number()); 2520 } 2521 RowReference operator[](RowNumber r) { 2522 return RowReference(this, r.row_number()); 2523 } 2524 FindById(Id find_id)2525 std::optional<ConstRowReference> FindById(Id find_id) const { 2526 std::optional<uint32_t> row = id().IndexOf(find_id); 2527 return row ? std::make_optional(ConstRowReference(this, *row)) 2528 : std::nullopt; 2529 } 2530 FindById(Id find_id)2531 std::optional<RowReference> FindById(Id find_id) { 2532 std::optional<uint32_t> row = id().IndexOf(find_id); 2533 return row ? std::make_optional(RowReference(this, *row)) : std::nullopt; 2534 } 2535 Insert(const Row & row)2536 IdAndRow Insert(const Row& row) { 2537 uint32_t row_number = row_count(); 2538 Id id = Id{row_number}; 2539 type_.Append(string_pool()->InternString(row.type())); 2540 mutable_snapshot_id()->Append(row.snapshot_id); 2541 mutable_arg_set_id()->Append(row.arg_set_id); 2542 mutable_base64_proto()->Append(row.base64_proto); 2543 mutable_base64_proto_id()->Append(row.base64_proto_id); 2544 UpdateSelfOverlayAfterInsert(); 2545 return IdAndRow{id, row_number, RowReference(this, row_number), 2546 RowNumber(row_number)}; 2547 } 2548 2549 2550 id()2551 const IdColumn<SurfaceFlingerLayerTable::Id>& id() const { 2552 return static_cast<const ColumnType::id&>(columns()[ColumnIndex::id]); 2553 } type()2554 const TypedColumn<StringPool::Id>& type() const { 2555 return static_cast<const ColumnType::type&>(columns()[ColumnIndex::type]); 2556 } snapshot_id()2557 const TypedColumn<SurfaceFlingerLayersSnapshotTable::Id>& snapshot_id() const { 2558 return static_cast<const ColumnType::snapshot_id&>(columns()[ColumnIndex::snapshot_id]); 2559 } arg_set_id()2560 const TypedColumn<uint32_t>& arg_set_id() const { 2561 return static_cast<const ColumnType::arg_set_id&>(columns()[ColumnIndex::arg_set_id]); 2562 } base64_proto()2563 const TypedColumn<StringPool::Id>& base64_proto() const { 2564 return static_cast<const ColumnType::base64_proto&>(columns()[ColumnIndex::base64_proto]); 2565 } base64_proto_id()2566 const TypedColumn<std::optional<uint32_t>>& base64_proto_id() const { 2567 return static_cast<const ColumnType::base64_proto_id&>(columns()[ColumnIndex::base64_proto_id]); 2568 } 2569 mutable_snapshot_id()2570 TypedColumn<SurfaceFlingerLayersSnapshotTable::Id>* mutable_snapshot_id() { 2571 return static_cast<ColumnType::snapshot_id*>( 2572 GetColumn(ColumnIndex::snapshot_id)); 2573 } mutable_arg_set_id()2574 TypedColumn<uint32_t>* mutable_arg_set_id() { 2575 return static_cast<ColumnType::arg_set_id*>( 2576 GetColumn(ColumnIndex::arg_set_id)); 2577 } mutable_base64_proto()2578 TypedColumn<StringPool::Id>* mutable_base64_proto() { 2579 return static_cast<ColumnType::base64_proto*>( 2580 GetColumn(ColumnIndex::base64_proto)); 2581 } mutable_base64_proto_id()2582 TypedColumn<std::optional<uint32_t>>* mutable_base64_proto_id() { 2583 return static_cast<ColumnType::base64_proto_id*>( 2584 GetColumn(ColumnIndex::base64_proto_id)); 2585 } 2586 2587 private: 2588 2589 2590 ColumnStorage<ColumnType::snapshot_id::stored_type> snapshot_id_; 2591 ColumnStorage<ColumnType::arg_set_id::stored_type> arg_set_id_; 2592 ColumnStorage<ColumnType::base64_proto::stored_type> base64_proto_; 2593 ColumnStorage<ColumnType::base64_proto_id::stored_type> base64_proto_id_; 2594 2595 RefPtr<column::StorageLayer> id_storage_layer_; 2596 RefPtr<column::StorageLayer> type_storage_layer_; 2597 RefPtr<column::StorageLayer> snapshot_id_storage_layer_; 2598 RefPtr<column::StorageLayer> arg_set_id_storage_layer_; 2599 RefPtr<column::StorageLayer> base64_proto_storage_layer_; 2600 RefPtr<column::StorageLayer> base64_proto_id_storage_layer_; 2601 2602 RefPtr<column::OverlayLayer> base64_proto_id_null_layer_; 2603 }; 2604 2605 2606 class SurfaceFlingerTransactionsTable : public macros_internal::MacroTable { 2607 public: 2608 static constexpr uint32_t kColumnCount = 6; 2609 2610 struct Id : public BaseId { 2611 Id() = default; IdId2612 explicit constexpr Id(uint32_t v) : BaseId(v) {} 2613 }; 2614 static_assert(std::is_trivially_destructible_v<Id>, 2615 "Inheritance used without trivial destruction"); 2616 2617 struct ColumnIndex { 2618 static constexpr uint32_t id = 0; 2619 static constexpr uint32_t type = 1; 2620 static constexpr uint32_t ts = 2; 2621 static constexpr uint32_t arg_set_id = 3; 2622 static constexpr uint32_t base64_proto = 4; 2623 static constexpr uint32_t base64_proto_id = 5; 2624 }; 2625 struct ColumnType { 2626 using id = IdColumn<SurfaceFlingerTransactionsTable::Id>; 2627 using type = TypedColumn<StringPool::Id>; 2628 using ts = TypedColumn<int64_t>; 2629 using arg_set_id = TypedColumn<uint32_t>; 2630 using base64_proto = TypedColumn<StringPool::Id>; 2631 using base64_proto_id = TypedColumn<std::optional<uint32_t>>; 2632 }; 2633 struct Row : public macros_internal::RootParentTable::Row { 2634 Row(int64_t in_ts = {}, 2635 uint32_t in_arg_set_id = {}, 2636 StringPool::Id in_base64_proto = {}, 2637 std::optional<uint32_t> in_base64_proto_id = {}, 2638 std::nullptr_t = nullptr) RowRow2639 : macros_internal::RootParentTable::Row(), 2640 ts(in_ts), 2641 arg_set_id(in_arg_set_id), 2642 base64_proto(in_base64_proto), 2643 base64_proto_id(in_base64_proto_id) { 2644 type_ = "surfaceflinger_transactions"; 2645 } 2646 int64_t ts; 2647 uint32_t arg_set_id; 2648 StringPool::Id base64_proto; 2649 std::optional<uint32_t> base64_proto_id; 2650 2651 bool operator==(const SurfaceFlingerTransactionsTable::Row& other) const { 2652 return type() == other.type() && ColumnType::ts::Equals(ts, other.ts) && 2653 ColumnType::arg_set_id::Equals(arg_set_id, other.arg_set_id) && 2654 ColumnType::base64_proto::Equals(base64_proto, other.base64_proto) && 2655 ColumnType::base64_proto_id::Equals(base64_proto_id, other.base64_proto_id); 2656 } 2657 }; 2658 struct ColumnFlag { 2659 static constexpr uint32_t ts = static_cast<uint32_t>(ColumnLegacy::Flag::kSorted) | ColumnType::ts::default_flags(); 2660 static constexpr uint32_t arg_set_id = ColumnType::arg_set_id::default_flags(); 2661 static constexpr uint32_t base64_proto = ColumnType::base64_proto::default_flags(); 2662 static constexpr uint32_t base64_proto_id = ColumnType::base64_proto_id::default_flags(); 2663 }; 2664 2665 class RowNumber; 2666 class ConstRowReference; 2667 class RowReference; 2668 2669 class RowNumber : public macros_internal::AbstractRowNumber< 2670 SurfaceFlingerTransactionsTable, ConstRowReference, RowReference> { 2671 public: RowNumber(uint32_t row_number)2672 explicit RowNumber(uint32_t row_number) 2673 : AbstractRowNumber(row_number) {} 2674 }; 2675 static_assert(std::is_trivially_destructible_v<RowNumber>, 2676 "Inheritance used without trivial destruction"); 2677 2678 class ConstRowReference : public macros_internal::AbstractConstRowReference< 2679 SurfaceFlingerTransactionsTable, RowNumber> { 2680 public: ConstRowReference(const SurfaceFlingerTransactionsTable * table,uint32_t row_number)2681 ConstRowReference(const SurfaceFlingerTransactionsTable* table, uint32_t row_number) 2682 : AbstractConstRowReference(table, row_number) {} 2683 id()2684 ColumnType::id::type id() const { 2685 return table()->id()[row_number_]; 2686 } type()2687 ColumnType::type::type type() const { 2688 return table()->type()[row_number_]; 2689 } ts()2690 ColumnType::ts::type ts() const { 2691 return table()->ts()[row_number_]; 2692 } arg_set_id()2693 ColumnType::arg_set_id::type arg_set_id() const { 2694 return table()->arg_set_id()[row_number_]; 2695 } base64_proto()2696 ColumnType::base64_proto::type base64_proto() const { 2697 return table()->base64_proto()[row_number_]; 2698 } base64_proto_id()2699 ColumnType::base64_proto_id::type base64_proto_id() const { 2700 return table()->base64_proto_id()[row_number_]; 2701 } 2702 }; 2703 static_assert(std::is_trivially_destructible_v<ConstRowReference>, 2704 "Inheritance used without trivial destruction"); 2705 class RowReference : public ConstRowReference { 2706 public: RowReference(const SurfaceFlingerTransactionsTable * table,uint32_t row_number)2707 RowReference(const SurfaceFlingerTransactionsTable* table, uint32_t row_number) 2708 : ConstRowReference(table, row_number) {} 2709 set_ts(ColumnType::ts::non_optional_type v)2710 void set_ts( 2711 ColumnType::ts::non_optional_type v) { 2712 return mutable_table()->mutable_ts()->Set(row_number_, v); 2713 } set_arg_set_id(ColumnType::arg_set_id::non_optional_type v)2714 void set_arg_set_id( 2715 ColumnType::arg_set_id::non_optional_type v) { 2716 return mutable_table()->mutable_arg_set_id()->Set(row_number_, v); 2717 } set_base64_proto(ColumnType::base64_proto::non_optional_type v)2718 void set_base64_proto( 2719 ColumnType::base64_proto::non_optional_type v) { 2720 return mutable_table()->mutable_base64_proto()->Set(row_number_, v); 2721 } set_base64_proto_id(ColumnType::base64_proto_id::non_optional_type v)2722 void set_base64_proto_id( 2723 ColumnType::base64_proto_id::non_optional_type v) { 2724 return mutable_table()->mutable_base64_proto_id()->Set(row_number_, v); 2725 } 2726 2727 private: mutable_table()2728 SurfaceFlingerTransactionsTable* mutable_table() const { 2729 return const_cast<SurfaceFlingerTransactionsTable*>(table()); 2730 } 2731 }; 2732 static_assert(std::is_trivially_destructible_v<RowReference>, 2733 "Inheritance used without trivial destruction"); 2734 2735 class ConstIterator; 2736 class ConstIterator : public macros_internal::AbstractConstIterator< 2737 ConstIterator, SurfaceFlingerTransactionsTable, RowNumber, ConstRowReference> { 2738 public: id()2739 ColumnType::id::type id() const { 2740 const auto& col = table()->id(); 2741 return col.GetAtIdx( 2742 iterator_.StorageIndexForColumn(col.index_in_table())); 2743 } type()2744 ColumnType::type::type type() const { 2745 const auto& col = table()->type(); 2746 return col.GetAtIdx( 2747 iterator_.StorageIndexForColumn(col.index_in_table())); 2748 } ts()2749 ColumnType::ts::type ts() const { 2750 const auto& col = table()->ts(); 2751 return col.GetAtIdx( 2752 iterator_.StorageIndexForColumn(col.index_in_table())); 2753 } arg_set_id()2754 ColumnType::arg_set_id::type arg_set_id() const { 2755 const auto& col = table()->arg_set_id(); 2756 return col.GetAtIdx( 2757 iterator_.StorageIndexForColumn(col.index_in_table())); 2758 } base64_proto()2759 ColumnType::base64_proto::type base64_proto() const { 2760 const auto& col = table()->base64_proto(); 2761 return col.GetAtIdx( 2762 iterator_.StorageIndexForColumn(col.index_in_table())); 2763 } base64_proto_id()2764 ColumnType::base64_proto_id::type base64_proto_id() const { 2765 const auto& col = table()->base64_proto_id(); 2766 return col.GetAtIdx( 2767 iterator_.StorageIndexForColumn(col.index_in_table())); 2768 } 2769 2770 protected: ConstIterator(const SurfaceFlingerTransactionsTable * table,Table::Iterator iterator)2771 explicit ConstIterator(const SurfaceFlingerTransactionsTable* table, 2772 Table::Iterator iterator) 2773 : AbstractConstIterator(table, std::move(iterator)) {} 2774 CurrentRowNumber()2775 uint32_t CurrentRowNumber() const { 2776 return iterator_.StorageIndexForLastOverlay(); 2777 } 2778 2779 private: 2780 friend class SurfaceFlingerTransactionsTable; 2781 friend class macros_internal::AbstractConstIterator< 2782 ConstIterator, SurfaceFlingerTransactionsTable, RowNumber, ConstRowReference>; 2783 }; 2784 class Iterator : public ConstIterator { 2785 public: row_reference()2786 RowReference row_reference() const { 2787 return {const_cast<SurfaceFlingerTransactionsTable*>(table()), CurrentRowNumber()}; 2788 } 2789 2790 private: 2791 friend class SurfaceFlingerTransactionsTable; 2792 Iterator(SurfaceFlingerTransactionsTable * table,Table::Iterator iterator)2793 explicit Iterator(SurfaceFlingerTransactionsTable* table, Table::Iterator iterator) 2794 : ConstIterator(table, std::move(iterator)) {} 2795 }; 2796 2797 struct IdAndRow { 2798 Id id; 2799 uint32_t row; 2800 RowReference row_reference; 2801 RowNumber row_number; 2802 }; 2803 GetColumns(SurfaceFlingerTransactionsTable * self,const macros_internal::MacroTable * parent)2804 static std::vector<ColumnLegacy> GetColumns( 2805 SurfaceFlingerTransactionsTable* self, 2806 const macros_internal::MacroTable* parent) { 2807 std::vector<ColumnLegacy> columns = 2808 CopyColumnsFromParentOrAddRootColumns(self, parent); 2809 uint32_t olay_idx = OverlayCount(parent); 2810 AddColumnToVector(columns, "ts", &self->ts_, ColumnFlag::ts, 2811 static_cast<uint32_t>(columns.size()), olay_idx); 2812 AddColumnToVector(columns, "arg_set_id", &self->arg_set_id_, ColumnFlag::arg_set_id, 2813 static_cast<uint32_t>(columns.size()), olay_idx); 2814 AddColumnToVector(columns, "base64_proto", &self->base64_proto_, ColumnFlag::base64_proto, 2815 static_cast<uint32_t>(columns.size()), olay_idx); 2816 AddColumnToVector(columns, "base64_proto_id", &self->base64_proto_id_, ColumnFlag::base64_proto_id, 2817 static_cast<uint32_t>(columns.size()), olay_idx); 2818 return columns; 2819 } 2820 SurfaceFlingerTransactionsTable(StringPool * pool)2821 PERFETTO_NO_INLINE explicit SurfaceFlingerTransactionsTable(StringPool* pool) 2822 : macros_internal::MacroTable( 2823 pool, 2824 GetColumns(this, nullptr), 2825 nullptr), 2826 ts_(ColumnStorage<ColumnType::ts::stored_type>::Create<false>()), 2827 arg_set_id_(ColumnStorage<ColumnType::arg_set_id::stored_type>::Create<false>()), 2828 base64_proto_(ColumnStorage<ColumnType::base64_proto::stored_type>::Create<false>()), 2829 base64_proto_id_(ColumnStorage<ColumnType::base64_proto_id::stored_type>::Create<false>()) 2830 , 2831 id_storage_layer_(new column::IdStorage()), 2832 type_storage_layer_( 2833 new column::StringStorage(string_pool(), &type_.vector())), 2834 ts_storage_layer_( 2835 new column::NumericStorage<ColumnType::ts::non_optional_stored_type>( 2836 &ts_.vector(), 2837 ColumnTypeHelper<ColumnType::ts::stored_type>::ToColumnType(), 2838 true)), 2839 arg_set_id_storage_layer_( 2840 new column::NumericStorage<ColumnType::arg_set_id::non_optional_stored_type>( 2841 &arg_set_id_.vector(), 2842 ColumnTypeHelper<ColumnType::arg_set_id::stored_type>::ToColumnType(), 2843 false)), 2844 base64_proto_storage_layer_( 2845 new column::StringStorage(string_pool(), &base64_proto_.vector())), 2846 base64_proto_id_storage_layer_( 2847 new column::NumericStorage<ColumnType::base64_proto_id::non_optional_stored_type>( 2848 &base64_proto_id_.non_null_vector(), 2849 ColumnTypeHelper<ColumnType::base64_proto_id::stored_type>::ToColumnType(), 2850 false)) 2851 , 2852 base64_proto_id_null_layer_(new column::NullOverlay(base64_proto_id_.bv())) { 2853 static_assert( 2854 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::ts::stored_type>( 2855 ColumnFlag::ts), 2856 "Column type and flag combination is not valid"); 2857 static_assert( 2858 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::arg_set_id::stored_type>( 2859 ColumnFlag::arg_set_id), 2860 "Column type and flag combination is not valid"); 2861 static_assert( 2862 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::base64_proto::stored_type>( 2863 ColumnFlag::base64_proto), 2864 "Column type and flag combination is not valid"); 2865 static_assert( 2866 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::base64_proto_id::stored_type>( 2867 ColumnFlag::base64_proto_id), 2868 "Column type and flag combination is not valid"); 2869 OnConstructionCompletedRegularConstructor( 2870 {id_storage_layer_,type_storage_layer_,ts_storage_layer_,arg_set_id_storage_layer_,base64_proto_storage_layer_,base64_proto_id_storage_layer_}, 2871 {{},{},{},{},{},base64_proto_id_null_layer_}); 2872 } 2873 ~SurfaceFlingerTransactionsTable() override; 2874 Name()2875 static const char* Name() { return "surfaceflinger_transactions"; } 2876 ComputeStaticSchema()2877 static Table::Schema ComputeStaticSchema() { 2878 Table::Schema schema; 2879 schema.columns.emplace_back(Table::Schema::Column{ 2880 "id", SqlValue::Type::kLong, true, true, false, false}); 2881 schema.columns.emplace_back(Table::Schema::Column{ 2882 "type", SqlValue::Type::kString, false, false, false, false}); 2883 schema.columns.emplace_back(Table::Schema::Column{ 2884 "ts", ColumnType::ts::SqlValueType(), false, 2885 true, 2886 false, 2887 false}); 2888 schema.columns.emplace_back(Table::Schema::Column{ 2889 "arg_set_id", ColumnType::arg_set_id::SqlValueType(), false, 2890 false, 2891 false, 2892 false}); 2893 schema.columns.emplace_back(Table::Schema::Column{ 2894 "base64_proto", ColumnType::base64_proto::SqlValueType(), false, 2895 false, 2896 false, 2897 false}); 2898 schema.columns.emplace_back(Table::Schema::Column{ 2899 "base64_proto_id", ColumnType::base64_proto_id::SqlValueType(), false, 2900 false, 2901 false, 2902 false}); 2903 return schema; 2904 } 2905 IterateRows()2906 ConstIterator IterateRows() const { 2907 return ConstIterator(this, Table::IterateRows()); 2908 } 2909 IterateRows()2910 Iterator IterateRows() { return Iterator(this, Table::IterateRows()); } 2911 FilterToIterator(const Query & q)2912 ConstIterator FilterToIterator(const Query& q) const { 2913 return ConstIterator(this, QueryToIterator(q)); 2914 } 2915 FilterToIterator(const Query & q)2916 Iterator FilterToIterator(const Query& q) { 2917 return Iterator(this, QueryToIterator(q)); 2918 } 2919 ShrinkToFit()2920 void ShrinkToFit() { 2921 type_.ShrinkToFit(); 2922 ts_.ShrinkToFit(); 2923 arg_set_id_.ShrinkToFit(); 2924 base64_proto_.ShrinkToFit(); 2925 base64_proto_id_.ShrinkToFit(); 2926 } 2927 2928 ConstRowReference operator[](uint32_t r) const { 2929 return ConstRowReference(this, r); 2930 } 2931 RowReference operator[](uint32_t r) { return RowReference(this, r); } 2932 ConstRowReference operator[](RowNumber r) const { 2933 return ConstRowReference(this, r.row_number()); 2934 } 2935 RowReference operator[](RowNumber r) { 2936 return RowReference(this, r.row_number()); 2937 } 2938 FindById(Id find_id)2939 std::optional<ConstRowReference> FindById(Id find_id) const { 2940 std::optional<uint32_t> row = id().IndexOf(find_id); 2941 return row ? std::make_optional(ConstRowReference(this, *row)) 2942 : std::nullopt; 2943 } 2944 FindById(Id find_id)2945 std::optional<RowReference> FindById(Id find_id) { 2946 std::optional<uint32_t> row = id().IndexOf(find_id); 2947 return row ? std::make_optional(RowReference(this, *row)) : std::nullopt; 2948 } 2949 Insert(const Row & row)2950 IdAndRow Insert(const Row& row) { 2951 uint32_t row_number = row_count(); 2952 Id id = Id{row_number}; 2953 type_.Append(string_pool()->InternString(row.type())); 2954 mutable_ts()->Append(row.ts); 2955 mutable_arg_set_id()->Append(row.arg_set_id); 2956 mutable_base64_proto()->Append(row.base64_proto); 2957 mutable_base64_proto_id()->Append(row.base64_proto_id); 2958 UpdateSelfOverlayAfterInsert(); 2959 return IdAndRow{id, row_number, RowReference(this, row_number), 2960 RowNumber(row_number)}; 2961 } 2962 2963 2964 id()2965 const IdColumn<SurfaceFlingerTransactionsTable::Id>& id() const { 2966 return static_cast<const ColumnType::id&>(columns()[ColumnIndex::id]); 2967 } type()2968 const TypedColumn<StringPool::Id>& type() const { 2969 return static_cast<const ColumnType::type&>(columns()[ColumnIndex::type]); 2970 } ts()2971 const TypedColumn<int64_t>& ts() const { 2972 return static_cast<const ColumnType::ts&>(columns()[ColumnIndex::ts]); 2973 } arg_set_id()2974 const TypedColumn<uint32_t>& arg_set_id() const { 2975 return static_cast<const ColumnType::arg_set_id&>(columns()[ColumnIndex::arg_set_id]); 2976 } base64_proto()2977 const TypedColumn<StringPool::Id>& base64_proto() const { 2978 return static_cast<const ColumnType::base64_proto&>(columns()[ColumnIndex::base64_proto]); 2979 } base64_proto_id()2980 const TypedColumn<std::optional<uint32_t>>& base64_proto_id() const { 2981 return static_cast<const ColumnType::base64_proto_id&>(columns()[ColumnIndex::base64_proto_id]); 2982 } 2983 mutable_ts()2984 TypedColumn<int64_t>* mutable_ts() { 2985 return static_cast<ColumnType::ts*>( 2986 GetColumn(ColumnIndex::ts)); 2987 } mutable_arg_set_id()2988 TypedColumn<uint32_t>* mutable_arg_set_id() { 2989 return static_cast<ColumnType::arg_set_id*>( 2990 GetColumn(ColumnIndex::arg_set_id)); 2991 } mutable_base64_proto()2992 TypedColumn<StringPool::Id>* mutable_base64_proto() { 2993 return static_cast<ColumnType::base64_proto*>( 2994 GetColumn(ColumnIndex::base64_proto)); 2995 } mutable_base64_proto_id()2996 TypedColumn<std::optional<uint32_t>>* mutable_base64_proto_id() { 2997 return static_cast<ColumnType::base64_proto_id*>( 2998 GetColumn(ColumnIndex::base64_proto_id)); 2999 } 3000 3001 private: 3002 3003 3004 ColumnStorage<ColumnType::ts::stored_type> ts_; 3005 ColumnStorage<ColumnType::arg_set_id::stored_type> arg_set_id_; 3006 ColumnStorage<ColumnType::base64_proto::stored_type> base64_proto_; 3007 ColumnStorage<ColumnType::base64_proto_id::stored_type> base64_proto_id_; 3008 3009 RefPtr<column::StorageLayer> id_storage_layer_; 3010 RefPtr<column::StorageLayer> type_storage_layer_; 3011 RefPtr<column::StorageLayer> ts_storage_layer_; 3012 RefPtr<column::StorageLayer> arg_set_id_storage_layer_; 3013 RefPtr<column::StorageLayer> base64_proto_storage_layer_; 3014 RefPtr<column::StorageLayer> base64_proto_id_storage_layer_; 3015 3016 RefPtr<column::OverlayLayer> base64_proto_id_null_layer_; 3017 }; 3018 3019 3020 class ViewCaptureTable : public macros_internal::MacroTable { 3021 public: 3022 static constexpr uint32_t kColumnCount = 6; 3023 3024 struct Id : public BaseId { 3025 Id() = default; IdId3026 explicit constexpr Id(uint32_t v) : BaseId(v) {} 3027 }; 3028 static_assert(std::is_trivially_destructible_v<Id>, 3029 "Inheritance used without trivial destruction"); 3030 3031 struct ColumnIndex { 3032 static constexpr uint32_t id = 0; 3033 static constexpr uint32_t type = 1; 3034 static constexpr uint32_t ts = 2; 3035 static constexpr uint32_t arg_set_id = 3; 3036 static constexpr uint32_t base64_proto = 4; 3037 static constexpr uint32_t base64_proto_id = 5; 3038 }; 3039 struct ColumnType { 3040 using id = IdColumn<ViewCaptureTable::Id>; 3041 using type = TypedColumn<StringPool::Id>; 3042 using ts = TypedColumn<int64_t>; 3043 using arg_set_id = TypedColumn<uint32_t>; 3044 using base64_proto = TypedColumn<StringPool::Id>; 3045 using base64_proto_id = TypedColumn<std::optional<uint32_t>>; 3046 }; 3047 struct Row : public macros_internal::RootParentTable::Row { 3048 Row(int64_t in_ts = {}, 3049 uint32_t in_arg_set_id = {}, 3050 StringPool::Id in_base64_proto = {}, 3051 std::optional<uint32_t> in_base64_proto_id = {}, 3052 std::nullptr_t = nullptr) RowRow3053 : macros_internal::RootParentTable::Row(), 3054 ts(in_ts), 3055 arg_set_id(in_arg_set_id), 3056 base64_proto(in_base64_proto), 3057 base64_proto_id(in_base64_proto_id) { 3058 type_ = "__intrinsic_viewcapture"; 3059 } 3060 int64_t ts; 3061 uint32_t arg_set_id; 3062 StringPool::Id base64_proto; 3063 std::optional<uint32_t> base64_proto_id; 3064 3065 bool operator==(const ViewCaptureTable::Row& other) const { 3066 return type() == other.type() && ColumnType::ts::Equals(ts, other.ts) && 3067 ColumnType::arg_set_id::Equals(arg_set_id, other.arg_set_id) && 3068 ColumnType::base64_proto::Equals(base64_proto, other.base64_proto) && 3069 ColumnType::base64_proto_id::Equals(base64_proto_id, other.base64_proto_id); 3070 } 3071 }; 3072 struct ColumnFlag { 3073 static constexpr uint32_t ts = static_cast<uint32_t>(ColumnLegacy::Flag::kSorted) | ColumnType::ts::default_flags(); 3074 static constexpr uint32_t arg_set_id = ColumnType::arg_set_id::default_flags(); 3075 static constexpr uint32_t base64_proto = ColumnType::base64_proto::default_flags(); 3076 static constexpr uint32_t base64_proto_id = ColumnType::base64_proto_id::default_flags(); 3077 }; 3078 3079 class RowNumber; 3080 class ConstRowReference; 3081 class RowReference; 3082 3083 class RowNumber : public macros_internal::AbstractRowNumber< 3084 ViewCaptureTable, ConstRowReference, RowReference> { 3085 public: RowNumber(uint32_t row_number)3086 explicit RowNumber(uint32_t row_number) 3087 : AbstractRowNumber(row_number) {} 3088 }; 3089 static_assert(std::is_trivially_destructible_v<RowNumber>, 3090 "Inheritance used without trivial destruction"); 3091 3092 class ConstRowReference : public macros_internal::AbstractConstRowReference< 3093 ViewCaptureTable, RowNumber> { 3094 public: ConstRowReference(const ViewCaptureTable * table,uint32_t row_number)3095 ConstRowReference(const ViewCaptureTable* table, uint32_t row_number) 3096 : AbstractConstRowReference(table, row_number) {} 3097 id()3098 ColumnType::id::type id() const { 3099 return table()->id()[row_number_]; 3100 } type()3101 ColumnType::type::type type() const { 3102 return table()->type()[row_number_]; 3103 } ts()3104 ColumnType::ts::type ts() const { 3105 return table()->ts()[row_number_]; 3106 } arg_set_id()3107 ColumnType::arg_set_id::type arg_set_id() const { 3108 return table()->arg_set_id()[row_number_]; 3109 } base64_proto()3110 ColumnType::base64_proto::type base64_proto() const { 3111 return table()->base64_proto()[row_number_]; 3112 } base64_proto_id()3113 ColumnType::base64_proto_id::type base64_proto_id() const { 3114 return table()->base64_proto_id()[row_number_]; 3115 } 3116 }; 3117 static_assert(std::is_trivially_destructible_v<ConstRowReference>, 3118 "Inheritance used without trivial destruction"); 3119 class RowReference : public ConstRowReference { 3120 public: RowReference(const ViewCaptureTable * table,uint32_t row_number)3121 RowReference(const ViewCaptureTable* table, uint32_t row_number) 3122 : ConstRowReference(table, row_number) {} 3123 set_ts(ColumnType::ts::non_optional_type v)3124 void set_ts( 3125 ColumnType::ts::non_optional_type v) { 3126 return mutable_table()->mutable_ts()->Set(row_number_, v); 3127 } set_arg_set_id(ColumnType::arg_set_id::non_optional_type v)3128 void set_arg_set_id( 3129 ColumnType::arg_set_id::non_optional_type v) { 3130 return mutable_table()->mutable_arg_set_id()->Set(row_number_, v); 3131 } set_base64_proto(ColumnType::base64_proto::non_optional_type v)3132 void set_base64_proto( 3133 ColumnType::base64_proto::non_optional_type v) { 3134 return mutable_table()->mutable_base64_proto()->Set(row_number_, v); 3135 } set_base64_proto_id(ColumnType::base64_proto_id::non_optional_type v)3136 void set_base64_proto_id( 3137 ColumnType::base64_proto_id::non_optional_type v) { 3138 return mutable_table()->mutable_base64_proto_id()->Set(row_number_, v); 3139 } 3140 3141 private: mutable_table()3142 ViewCaptureTable* mutable_table() const { 3143 return const_cast<ViewCaptureTable*>(table()); 3144 } 3145 }; 3146 static_assert(std::is_trivially_destructible_v<RowReference>, 3147 "Inheritance used without trivial destruction"); 3148 3149 class ConstIterator; 3150 class ConstIterator : public macros_internal::AbstractConstIterator< 3151 ConstIterator, ViewCaptureTable, RowNumber, ConstRowReference> { 3152 public: id()3153 ColumnType::id::type id() const { 3154 const auto& col = table()->id(); 3155 return col.GetAtIdx( 3156 iterator_.StorageIndexForColumn(col.index_in_table())); 3157 } type()3158 ColumnType::type::type type() const { 3159 const auto& col = table()->type(); 3160 return col.GetAtIdx( 3161 iterator_.StorageIndexForColumn(col.index_in_table())); 3162 } ts()3163 ColumnType::ts::type ts() const { 3164 const auto& col = table()->ts(); 3165 return col.GetAtIdx( 3166 iterator_.StorageIndexForColumn(col.index_in_table())); 3167 } arg_set_id()3168 ColumnType::arg_set_id::type arg_set_id() const { 3169 const auto& col = table()->arg_set_id(); 3170 return col.GetAtIdx( 3171 iterator_.StorageIndexForColumn(col.index_in_table())); 3172 } base64_proto()3173 ColumnType::base64_proto::type base64_proto() const { 3174 const auto& col = table()->base64_proto(); 3175 return col.GetAtIdx( 3176 iterator_.StorageIndexForColumn(col.index_in_table())); 3177 } base64_proto_id()3178 ColumnType::base64_proto_id::type base64_proto_id() const { 3179 const auto& col = table()->base64_proto_id(); 3180 return col.GetAtIdx( 3181 iterator_.StorageIndexForColumn(col.index_in_table())); 3182 } 3183 3184 protected: ConstIterator(const ViewCaptureTable * table,Table::Iterator iterator)3185 explicit ConstIterator(const ViewCaptureTable* table, 3186 Table::Iterator iterator) 3187 : AbstractConstIterator(table, std::move(iterator)) {} 3188 CurrentRowNumber()3189 uint32_t CurrentRowNumber() const { 3190 return iterator_.StorageIndexForLastOverlay(); 3191 } 3192 3193 private: 3194 friend class ViewCaptureTable; 3195 friend class macros_internal::AbstractConstIterator< 3196 ConstIterator, ViewCaptureTable, RowNumber, ConstRowReference>; 3197 }; 3198 class Iterator : public ConstIterator { 3199 public: row_reference()3200 RowReference row_reference() const { 3201 return {const_cast<ViewCaptureTable*>(table()), CurrentRowNumber()}; 3202 } 3203 3204 private: 3205 friend class ViewCaptureTable; 3206 Iterator(ViewCaptureTable * table,Table::Iterator iterator)3207 explicit Iterator(ViewCaptureTable* table, Table::Iterator iterator) 3208 : ConstIterator(table, std::move(iterator)) {} 3209 }; 3210 3211 struct IdAndRow { 3212 Id id; 3213 uint32_t row; 3214 RowReference row_reference; 3215 RowNumber row_number; 3216 }; 3217 GetColumns(ViewCaptureTable * self,const macros_internal::MacroTable * parent)3218 static std::vector<ColumnLegacy> GetColumns( 3219 ViewCaptureTable* self, 3220 const macros_internal::MacroTable* parent) { 3221 std::vector<ColumnLegacy> columns = 3222 CopyColumnsFromParentOrAddRootColumns(self, parent); 3223 uint32_t olay_idx = OverlayCount(parent); 3224 AddColumnToVector(columns, "ts", &self->ts_, ColumnFlag::ts, 3225 static_cast<uint32_t>(columns.size()), olay_idx); 3226 AddColumnToVector(columns, "arg_set_id", &self->arg_set_id_, ColumnFlag::arg_set_id, 3227 static_cast<uint32_t>(columns.size()), olay_idx); 3228 AddColumnToVector(columns, "base64_proto", &self->base64_proto_, ColumnFlag::base64_proto, 3229 static_cast<uint32_t>(columns.size()), olay_idx); 3230 AddColumnToVector(columns, "base64_proto_id", &self->base64_proto_id_, ColumnFlag::base64_proto_id, 3231 static_cast<uint32_t>(columns.size()), olay_idx); 3232 return columns; 3233 } 3234 ViewCaptureTable(StringPool * pool)3235 PERFETTO_NO_INLINE explicit ViewCaptureTable(StringPool* pool) 3236 : macros_internal::MacroTable( 3237 pool, 3238 GetColumns(this, nullptr), 3239 nullptr), 3240 ts_(ColumnStorage<ColumnType::ts::stored_type>::Create<false>()), 3241 arg_set_id_(ColumnStorage<ColumnType::arg_set_id::stored_type>::Create<false>()), 3242 base64_proto_(ColumnStorage<ColumnType::base64_proto::stored_type>::Create<false>()), 3243 base64_proto_id_(ColumnStorage<ColumnType::base64_proto_id::stored_type>::Create<false>()) 3244 , 3245 id_storage_layer_(new column::IdStorage()), 3246 type_storage_layer_( 3247 new column::StringStorage(string_pool(), &type_.vector())), 3248 ts_storage_layer_( 3249 new column::NumericStorage<ColumnType::ts::non_optional_stored_type>( 3250 &ts_.vector(), 3251 ColumnTypeHelper<ColumnType::ts::stored_type>::ToColumnType(), 3252 true)), 3253 arg_set_id_storage_layer_( 3254 new column::NumericStorage<ColumnType::arg_set_id::non_optional_stored_type>( 3255 &arg_set_id_.vector(), 3256 ColumnTypeHelper<ColumnType::arg_set_id::stored_type>::ToColumnType(), 3257 false)), 3258 base64_proto_storage_layer_( 3259 new column::StringStorage(string_pool(), &base64_proto_.vector())), 3260 base64_proto_id_storage_layer_( 3261 new column::NumericStorage<ColumnType::base64_proto_id::non_optional_stored_type>( 3262 &base64_proto_id_.non_null_vector(), 3263 ColumnTypeHelper<ColumnType::base64_proto_id::stored_type>::ToColumnType(), 3264 false)) 3265 , 3266 base64_proto_id_null_layer_(new column::NullOverlay(base64_proto_id_.bv())) { 3267 static_assert( 3268 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::ts::stored_type>( 3269 ColumnFlag::ts), 3270 "Column type and flag combination is not valid"); 3271 static_assert( 3272 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::arg_set_id::stored_type>( 3273 ColumnFlag::arg_set_id), 3274 "Column type and flag combination is not valid"); 3275 static_assert( 3276 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::base64_proto::stored_type>( 3277 ColumnFlag::base64_proto), 3278 "Column type and flag combination is not valid"); 3279 static_assert( 3280 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::base64_proto_id::stored_type>( 3281 ColumnFlag::base64_proto_id), 3282 "Column type and flag combination is not valid"); 3283 OnConstructionCompletedRegularConstructor( 3284 {id_storage_layer_,type_storage_layer_,ts_storage_layer_,arg_set_id_storage_layer_,base64_proto_storage_layer_,base64_proto_id_storage_layer_}, 3285 {{},{},{},{},{},base64_proto_id_null_layer_}); 3286 } 3287 ~ViewCaptureTable() override; 3288 Name()3289 static const char* Name() { return "__intrinsic_viewcapture"; } 3290 ComputeStaticSchema()3291 static Table::Schema ComputeStaticSchema() { 3292 Table::Schema schema; 3293 schema.columns.emplace_back(Table::Schema::Column{ 3294 "id", SqlValue::Type::kLong, true, true, false, false}); 3295 schema.columns.emplace_back(Table::Schema::Column{ 3296 "type", SqlValue::Type::kString, false, false, false, false}); 3297 schema.columns.emplace_back(Table::Schema::Column{ 3298 "ts", ColumnType::ts::SqlValueType(), false, 3299 true, 3300 false, 3301 false}); 3302 schema.columns.emplace_back(Table::Schema::Column{ 3303 "arg_set_id", ColumnType::arg_set_id::SqlValueType(), false, 3304 false, 3305 false, 3306 false}); 3307 schema.columns.emplace_back(Table::Schema::Column{ 3308 "base64_proto", ColumnType::base64_proto::SqlValueType(), false, 3309 false, 3310 false, 3311 false}); 3312 schema.columns.emplace_back(Table::Schema::Column{ 3313 "base64_proto_id", ColumnType::base64_proto_id::SqlValueType(), false, 3314 false, 3315 false, 3316 false}); 3317 return schema; 3318 } 3319 IterateRows()3320 ConstIterator IterateRows() const { 3321 return ConstIterator(this, Table::IterateRows()); 3322 } 3323 IterateRows()3324 Iterator IterateRows() { return Iterator(this, Table::IterateRows()); } 3325 FilterToIterator(const Query & q)3326 ConstIterator FilterToIterator(const Query& q) const { 3327 return ConstIterator(this, QueryToIterator(q)); 3328 } 3329 FilterToIterator(const Query & q)3330 Iterator FilterToIterator(const Query& q) { 3331 return Iterator(this, QueryToIterator(q)); 3332 } 3333 ShrinkToFit()3334 void ShrinkToFit() { 3335 type_.ShrinkToFit(); 3336 ts_.ShrinkToFit(); 3337 arg_set_id_.ShrinkToFit(); 3338 base64_proto_.ShrinkToFit(); 3339 base64_proto_id_.ShrinkToFit(); 3340 } 3341 3342 ConstRowReference operator[](uint32_t r) const { 3343 return ConstRowReference(this, r); 3344 } 3345 RowReference operator[](uint32_t r) { return RowReference(this, r); } 3346 ConstRowReference operator[](RowNumber r) const { 3347 return ConstRowReference(this, r.row_number()); 3348 } 3349 RowReference operator[](RowNumber r) { 3350 return RowReference(this, r.row_number()); 3351 } 3352 FindById(Id find_id)3353 std::optional<ConstRowReference> FindById(Id find_id) const { 3354 std::optional<uint32_t> row = id().IndexOf(find_id); 3355 return row ? std::make_optional(ConstRowReference(this, *row)) 3356 : std::nullopt; 3357 } 3358 FindById(Id find_id)3359 std::optional<RowReference> FindById(Id find_id) { 3360 std::optional<uint32_t> row = id().IndexOf(find_id); 3361 return row ? std::make_optional(RowReference(this, *row)) : std::nullopt; 3362 } 3363 Insert(const Row & row)3364 IdAndRow Insert(const Row& row) { 3365 uint32_t row_number = row_count(); 3366 Id id = Id{row_number}; 3367 type_.Append(string_pool()->InternString(row.type())); 3368 mutable_ts()->Append(row.ts); 3369 mutable_arg_set_id()->Append(row.arg_set_id); 3370 mutable_base64_proto()->Append(row.base64_proto); 3371 mutable_base64_proto_id()->Append(row.base64_proto_id); 3372 UpdateSelfOverlayAfterInsert(); 3373 return IdAndRow{id, row_number, RowReference(this, row_number), 3374 RowNumber(row_number)}; 3375 } 3376 3377 3378 id()3379 const IdColumn<ViewCaptureTable::Id>& id() const { 3380 return static_cast<const ColumnType::id&>(columns()[ColumnIndex::id]); 3381 } type()3382 const TypedColumn<StringPool::Id>& type() const { 3383 return static_cast<const ColumnType::type&>(columns()[ColumnIndex::type]); 3384 } ts()3385 const TypedColumn<int64_t>& ts() const { 3386 return static_cast<const ColumnType::ts&>(columns()[ColumnIndex::ts]); 3387 } arg_set_id()3388 const TypedColumn<uint32_t>& arg_set_id() const { 3389 return static_cast<const ColumnType::arg_set_id&>(columns()[ColumnIndex::arg_set_id]); 3390 } base64_proto()3391 const TypedColumn<StringPool::Id>& base64_proto() const { 3392 return static_cast<const ColumnType::base64_proto&>(columns()[ColumnIndex::base64_proto]); 3393 } base64_proto_id()3394 const TypedColumn<std::optional<uint32_t>>& base64_proto_id() const { 3395 return static_cast<const ColumnType::base64_proto_id&>(columns()[ColumnIndex::base64_proto_id]); 3396 } 3397 mutable_ts()3398 TypedColumn<int64_t>* mutable_ts() { 3399 return static_cast<ColumnType::ts*>( 3400 GetColumn(ColumnIndex::ts)); 3401 } mutable_arg_set_id()3402 TypedColumn<uint32_t>* mutable_arg_set_id() { 3403 return static_cast<ColumnType::arg_set_id*>( 3404 GetColumn(ColumnIndex::arg_set_id)); 3405 } mutable_base64_proto()3406 TypedColumn<StringPool::Id>* mutable_base64_proto() { 3407 return static_cast<ColumnType::base64_proto*>( 3408 GetColumn(ColumnIndex::base64_proto)); 3409 } mutable_base64_proto_id()3410 TypedColumn<std::optional<uint32_t>>* mutable_base64_proto_id() { 3411 return static_cast<ColumnType::base64_proto_id*>( 3412 GetColumn(ColumnIndex::base64_proto_id)); 3413 } 3414 3415 private: 3416 3417 3418 ColumnStorage<ColumnType::ts::stored_type> ts_; 3419 ColumnStorage<ColumnType::arg_set_id::stored_type> arg_set_id_; 3420 ColumnStorage<ColumnType::base64_proto::stored_type> base64_proto_; 3421 ColumnStorage<ColumnType::base64_proto_id::stored_type> base64_proto_id_; 3422 3423 RefPtr<column::StorageLayer> id_storage_layer_; 3424 RefPtr<column::StorageLayer> type_storage_layer_; 3425 RefPtr<column::StorageLayer> ts_storage_layer_; 3426 RefPtr<column::StorageLayer> arg_set_id_storage_layer_; 3427 RefPtr<column::StorageLayer> base64_proto_storage_layer_; 3428 RefPtr<column::StorageLayer> base64_proto_id_storage_layer_; 3429 3430 RefPtr<column::OverlayLayer> base64_proto_id_null_layer_; 3431 }; 3432 3433 3434 class WindowManagerShellTransitionsTable : public macros_internal::MacroTable { 3435 public: 3436 static constexpr uint32_t kColumnCount = 7; 3437 3438 struct Id : public BaseId { 3439 Id() = default; IdId3440 explicit constexpr Id(uint32_t v) : BaseId(v) {} 3441 }; 3442 static_assert(std::is_trivially_destructible_v<Id>, 3443 "Inheritance used without trivial destruction"); 3444 3445 struct ColumnIndex { 3446 static constexpr uint32_t id = 0; 3447 static constexpr uint32_t type = 1; 3448 static constexpr uint32_t ts = 2; 3449 static constexpr uint32_t transition_id = 3; 3450 static constexpr uint32_t arg_set_id = 4; 3451 static constexpr uint32_t base64_proto = 5; 3452 static constexpr uint32_t base64_proto_id = 6; 3453 }; 3454 struct ColumnType { 3455 using id = IdColumn<WindowManagerShellTransitionsTable::Id>; 3456 using type = TypedColumn<StringPool::Id>; 3457 using ts = TypedColumn<int64_t>; 3458 using transition_id = TypedColumn<int64_t>; 3459 using arg_set_id = TypedColumn<uint32_t>; 3460 using base64_proto = TypedColumn<StringPool::Id>; 3461 using base64_proto_id = TypedColumn<std::optional<uint32_t>>; 3462 }; 3463 struct Row : public macros_internal::RootParentTable::Row { 3464 Row(int64_t in_ts = {}, 3465 int64_t in_transition_id = {}, 3466 uint32_t in_arg_set_id = {}, 3467 StringPool::Id in_base64_proto = {}, 3468 std::optional<uint32_t> in_base64_proto_id = {}, 3469 std::nullptr_t = nullptr) RowRow3470 : macros_internal::RootParentTable::Row(), 3471 ts(in_ts), 3472 transition_id(in_transition_id), 3473 arg_set_id(in_arg_set_id), 3474 base64_proto(in_base64_proto), 3475 base64_proto_id(in_base64_proto_id) { 3476 type_ = "window_manager_shell_transitions"; 3477 } 3478 int64_t ts; 3479 int64_t transition_id; 3480 uint32_t arg_set_id; 3481 StringPool::Id base64_proto; 3482 std::optional<uint32_t> base64_proto_id; 3483 3484 bool operator==(const WindowManagerShellTransitionsTable::Row& other) const { 3485 return type() == other.type() && ColumnType::ts::Equals(ts, other.ts) && 3486 ColumnType::transition_id::Equals(transition_id, other.transition_id) && 3487 ColumnType::arg_set_id::Equals(arg_set_id, other.arg_set_id) && 3488 ColumnType::base64_proto::Equals(base64_proto, other.base64_proto) && 3489 ColumnType::base64_proto_id::Equals(base64_proto_id, other.base64_proto_id); 3490 } 3491 }; 3492 struct ColumnFlag { 3493 static constexpr uint32_t ts = ColumnType::ts::default_flags(); 3494 static constexpr uint32_t transition_id = static_cast<uint32_t>(ColumnLegacy::Flag::kSorted) | ColumnType::transition_id::default_flags(); 3495 static constexpr uint32_t arg_set_id = ColumnType::arg_set_id::default_flags(); 3496 static constexpr uint32_t base64_proto = ColumnType::base64_proto::default_flags(); 3497 static constexpr uint32_t base64_proto_id = ColumnType::base64_proto_id::default_flags(); 3498 }; 3499 3500 class RowNumber; 3501 class ConstRowReference; 3502 class RowReference; 3503 3504 class RowNumber : public macros_internal::AbstractRowNumber< 3505 WindowManagerShellTransitionsTable, ConstRowReference, RowReference> { 3506 public: RowNumber(uint32_t row_number)3507 explicit RowNumber(uint32_t row_number) 3508 : AbstractRowNumber(row_number) {} 3509 }; 3510 static_assert(std::is_trivially_destructible_v<RowNumber>, 3511 "Inheritance used without trivial destruction"); 3512 3513 class ConstRowReference : public macros_internal::AbstractConstRowReference< 3514 WindowManagerShellTransitionsTable, RowNumber> { 3515 public: ConstRowReference(const WindowManagerShellTransitionsTable * table,uint32_t row_number)3516 ConstRowReference(const WindowManagerShellTransitionsTable* table, uint32_t row_number) 3517 : AbstractConstRowReference(table, row_number) {} 3518 id()3519 ColumnType::id::type id() const { 3520 return table()->id()[row_number_]; 3521 } type()3522 ColumnType::type::type type() const { 3523 return table()->type()[row_number_]; 3524 } ts()3525 ColumnType::ts::type ts() const { 3526 return table()->ts()[row_number_]; 3527 } transition_id()3528 ColumnType::transition_id::type transition_id() const { 3529 return table()->transition_id()[row_number_]; 3530 } arg_set_id()3531 ColumnType::arg_set_id::type arg_set_id() const { 3532 return table()->arg_set_id()[row_number_]; 3533 } base64_proto()3534 ColumnType::base64_proto::type base64_proto() const { 3535 return table()->base64_proto()[row_number_]; 3536 } base64_proto_id()3537 ColumnType::base64_proto_id::type base64_proto_id() const { 3538 return table()->base64_proto_id()[row_number_]; 3539 } 3540 }; 3541 static_assert(std::is_trivially_destructible_v<ConstRowReference>, 3542 "Inheritance used without trivial destruction"); 3543 class RowReference : public ConstRowReference { 3544 public: RowReference(const WindowManagerShellTransitionsTable * table,uint32_t row_number)3545 RowReference(const WindowManagerShellTransitionsTable* table, uint32_t row_number) 3546 : ConstRowReference(table, row_number) {} 3547 set_ts(ColumnType::ts::non_optional_type v)3548 void set_ts( 3549 ColumnType::ts::non_optional_type v) { 3550 return mutable_table()->mutable_ts()->Set(row_number_, v); 3551 } set_transition_id(ColumnType::transition_id::non_optional_type v)3552 void set_transition_id( 3553 ColumnType::transition_id::non_optional_type v) { 3554 return mutable_table()->mutable_transition_id()->Set(row_number_, v); 3555 } set_arg_set_id(ColumnType::arg_set_id::non_optional_type v)3556 void set_arg_set_id( 3557 ColumnType::arg_set_id::non_optional_type v) { 3558 return mutable_table()->mutable_arg_set_id()->Set(row_number_, v); 3559 } set_base64_proto(ColumnType::base64_proto::non_optional_type v)3560 void set_base64_proto( 3561 ColumnType::base64_proto::non_optional_type v) { 3562 return mutable_table()->mutable_base64_proto()->Set(row_number_, v); 3563 } set_base64_proto_id(ColumnType::base64_proto_id::non_optional_type v)3564 void set_base64_proto_id( 3565 ColumnType::base64_proto_id::non_optional_type v) { 3566 return mutable_table()->mutable_base64_proto_id()->Set(row_number_, v); 3567 } 3568 3569 private: mutable_table()3570 WindowManagerShellTransitionsTable* mutable_table() const { 3571 return const_cast<WindowManagerShellTransitionsTable*>(table()); 3572 } 3573 }; 3574 static_assert(std::is_trivially_destructible_v<RowReference>, 3575 "Inheritance used without trivial destruction"); 3576 3577 class ConstIterator; 3578 class ConstIterator : public macros_internal::AbstractConstIterator< 3579 ConstIterator, WindowManagerShellTransitionsTable, RowNumber, ConstRowReference> { 3580 public: id()3581 ColumnType::id::type id() const { 3582 const auto& col = table()->id(); 3583 return col.GetAtIdx( 3584 iterator_.StorageIndexForColumn(col.index_in_table())); 3585 } type()3586 ColumnType::type::type type() const { 3587 const auto& col = table()->type(); 3588 return col.GetAtIdx( 3589 iterator_.StorageIndexForColumn(col.index_in_table())); 3590 } ts()3591 ColumnType::ts::type ts() const { 3592 const auto& col = table()->ts(); 3593 return col.GetAtIdx( 3594 iterator_.StorageIndexForColumn(col.index_in_table())); 3595 } transition_id()3596 ColumnType::transition_id::type transition_id() const { 3597 const auto& col = table()->transition_id(); 3598 return col.GetAtIdx( 3599 iterator_.StorageIndexForColumn(col.index_in_table())); 3600 } arg_set_id()3601 ColumnType::arg_set_id::type arg_set_id() const { 3602 const auto& col = table()->arg_set_id(); 3603 return col.GetAtIdx( 3604 iterator_.StorageIndexForColumn(col.index_in_table())); 3605 } base64_proto()3606 ColumnType::base64_proto::type base64_proto() const { 3607 const auto& col = table()->base64_proto(); 3608 return col.GetAtIdx( 3609 iterator_.StorageIndexForColumn(col.index_in_table())); 3610 } base64_proto_id()3611 ColumnType::base64_proto_id::type base64_proto_id() const { 3612 const auto& col = table()->base64_proto_id(); 3613 return col.GetAtIdx( 3614 iterator_.StorageIndexForColumn(col.index_in_table())); 3615 } 3616 3617 protected: ConstIterator(const WindowManagerShellTransitionsTable * table,Table::Iterator iterator)3618 explicit ConstIterator(const WindowManagerShellTransitionsTable* table, 3619 Table::Iterator iterator) 3620 : AbstractConstIterator(table, std::move(iterator)) {} 3621 CurrentRowNumber()3622 uint32_t CurrentRowNumber() const { 3623 return iterator_.StorageIndexForLastOverlay(); 3624 } 3625 3626 private: 3627 friend class WindowManagerShellTransitionsTable; 3628 friend class macros_internal::AbstractConstIterator< 3629 ConstIterator, WindowManagerShellTransitionsTable, RowNumber, ConstRowReference>; 3630 }; 3631 class Iterator : public ConstIterator { 3632 public: row_reference()3633 RowReference row_reference() const { 3634 return {const_cast<WindowManagerShellTransitionsTable*>(table()), CurrentRowNumber()}; 3635 } 3636 3637 private: 3638 friend class WindowManagerShellTransitionsTable; 3639 Iterator(WindowManagerShellTransitionsTable * table,Table::Iterator iterator)3640 explicit Iterator(WindowManagerShellTransitionsTable* table, Table::Iterator iterator) 3641 : ConstIterator(table, std::move(iterator)) {} 3642 }; 3643 3644 struct IdAndRow { 3645 Id id; 3646 uint32_t row; 3647 RowReference row_reference; 3648 RowNumber row_number; 3649 }; 3650 GetColumns(WindowManagerShellTransitionsTable * self,const macros_internal::MacroTable * parent)3651 static std::vector<ColumnLegacy> GetColumns( 3652 WindowManagerShellTransitionsTable* self, 3653 const macros_internal::MacroTable* parent) { 3654 std::vector<ColumnLegacy> columns = 3655 CopyColumnsFromParentOrAddRootColumns(self, parent); 3656 uint32_t olay_idx = OverlayCount(parent); 3657 AddColumnToVector(columns, "ts", &self->ts_, ColumnFlag::ts, 3658 static_cast<uint32_t>(columns.size()), olay_idx); 3659 AddColumnToVector(columns, "transition_id", &self->transition_id_, ColumnFlag::transition_id, 3660 static_cast<uint32_t>(columns.size()), olay_idx); 3661 AddColumnToVector(columns, "arg_set_id", &self->arg_set_id_, ColumnFlag::arg_set_id, 3662 static_cast<uint32_t>(columns.size()), olay_idx); 3663 AddColumnToVector(columns, "base64_proto", &self->base64_proto_, ColumnFlag::base64_proto, 3664 static_cast<uint32_t>(columns.size()), olay_idx); 3665 AddColumnToVector(columns, "base64_proto_id", &self->base64_proto_id_, ColumnFlag::base64_proto_id, 3666 static_cast<uint32_t>(columns.size()), olay_idx); 3667 return columns; 3668 } 3669 WindowManagerShellTransitionsTable(StringPool * pool)3670 PERFETTO_NO_INLINE explicit WindowManagerShellTransitionsTable(StringPool* pool) 3671 : macros_internal::MacroTable( 3672 pool, 3673 GetColumns(this, nullptr), 3674 nullptr), 3675 ts_(ColumnStorage<ColumnType::ts::stored_type>::Create<false>()), 3676 transition_id_(ColumnStorage<ColumnType::transition_id::stored_type>::Create<false>()), 3677 arg_set_id_(ColumnStorage<ColumnType::arg_set_id::stored_type>::Create<false>()), 3678 base64_proto_(ColumnStorage<ColumnType::base64_proto::stored_type>::Create<false>()), 3679 base64_proto_id_(ColumnStorage<ColumnType::base64_proto_id::stored_type>::Create<false>()) 3680 , 3681 id_storage_layer_(new column::IdStorage()), 3682 type_storage_layer_( 3683 new column::StringStorage(string_pool(), &type_.vector())), 3684 ts_storage_layer_( 3685 new column::NumericStorage<ColumnType::ts::non_optional_stored_type>( 3686 &ts_.vector(), 3687 ColumnTypeHelper<ColumnType::ts::stored_type>::ToColumnType(), 3688 false)), 3689 transition_id_storage_layer_( 3690 new column::NumericStorage<ColumnType::transition_id::non_optional_stored_type>( 3691 &transition_id_.vector(), 3692 ColumnTypeHelper<ColumnType::transition_id::stored_type>::ToColumnType(), 3693 true)), 3694 arg_set_id_storage_layer_( 3695 new column::NumericStorage<ColumnType::arg_set_id::non_optional_stored_type>( 3696 &arg_set_id_.vector(), 3697 ColumnTypeHelper<ColumnType::arg_set_id::stored_type>::ToColumnType(), 3698 false)), 3699 base64_proto_storage_layer_( 3700 new column::StringStorage(string_pool(), &base64_proto_.vector())), 3701 base64_proto_id_storage_layer_( 3702 new column::NumericStorage<ColumnType::base64_proto_id::non_optional_stored_type>( 3703 &base64_proto_id_.non_null_vector(), 3704 ColumnTypeHelper<ColumnType::base64_proto_id::stored_type>::ToColumnType(), 3705 false)) 3706 , 3707 base64_proto_id_null_layer_(new column::NullOverlay(base64_proto_id_.bv())) { 3708 static_assert( 3709 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::ts::stored_type>( 3710 ColumnFlag::ts), 3711 "Column type and flag combination is not valid"); 3712 static_assert( 3713 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::transition_id::stored_type>( 3714 ColumnFlag::transition_id), 3715 "Column type and flag combination is not valid"); 3716 static_assert( 3717 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::arg_set_id::stored_type>( 3718 ColumnFlag::arg_set_id), 3719 "Column type and flag combination is not valid"); 3720 static_assert( 3721 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::base64_proto::stored_type>( 3722 ColumnFlag::base64_proto), 3723 "Column type and flag combination is not valid"); 3724 static_assert( 3725 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::base64_proto_id::stored_type>( 3726 ColumnFlag::base64_proto_id), 3727 "Column type and flag combination is not valid"); 3728 OnConstructionCompletedRegularConstructor( 3729 {id_storage_layer_,type_storage_layer_,ts_storage_layer_,transition_id_storage_layer_,arg_set_id_storage_layer_,base64_proto_storage_layer_,base64_proto_id_storage_layer_}, 3730 {{},{},{},{},{},{},base64_proto_id_null_layer_}); 3731 } 3732 ~WindowManagerShellTransitionsTable() override; 3733 Name()3734 static const char* Name() { return "window_manager_shell_transitions"; } 3735 ComputeStaticSchema()3736 static Table::Schema ComputeStaticSchema() { 3737 Table::Schema schema; 3738 schema.columns.emplace_back(Table::Schema::Column{ 3739 "id", SqlValue::Type::kLong, true, true, false, false}); 3740 schema.columns.emplace_back(Table::Schema::Column{ 3741 "type", SqlValue::Type::kString, false, false, false, false}); 3742 schema.columns.emplace_back(Table::Schema::Column{ 3743 "ts", ColumnType::ts::SqlValueType(), false, 3744 false, 3745 false, 3746 false}); 3747 schema.columns.emplace_back(Table::Schema::Column{ 3748 "transition_id", ColumnType::transition_id::SqlValueType(), false, 3749 true, 3750 false, 3751 false}); 3752 schema.columns.emplace_back(Table::Schema::Column{ 3753 "arg_set_id", ColumnType::arg_set_id::SqlValueType(), false, 3754 false, 3755 false, 3756 false}); 3757 schema.columns.emplace_back(Table::Schema::Column{ 3758 "base64_proto", ColumnType::base64_proto::SqlValueType(), false, 3759 false, 3760 false, 3761 false}); 3762 schema.columns.emplace_back(Table::Schema::Column{ 3763 "base64_proto_id", ColumnType::base64_proto_id::SqlValueType(), false, 3764 false, 3765 false, 3766 false}); 3767 return schema; 3768 } 3769 IterateRows()3770 ConstIterator IterateRows() const { 3771 return ConstIterator(this, Table::IterateRows()); 3772 } 3773 IterateRows()3774 Iterator IterateRows() { return Iterator(this, Table::IterateRows()); } 3775 FilterToIterator(const Query & q)3776 ConstIterator FilterToIterator(const Query& q) const { 3777 return ConstIterator(this, QueryToIterator(q)); 3778 } 3779 FilterToIterator(const Query & q)3780 Iterator FilterToIterator(const Query& q) { 3781 return Iterator(this, QueryToIterator(q)); 3782 } 3783 ShrinkToFit()3784 void ShrinkToFit() { 3785 type_.ShrinkToFit(); 3786 ts_.ShrinkToFit(); 3787 transition_id_.ShrinkToFit(); 3788 arg_set_id_.ShrinkToFit(); 3789 base64_proto_.ShrinkToFit(); 3790 base64_proto_id_.ShrinkToFit(); 3791 } 3792 3793 ConstRowReference operator[](uint32_t r) const { 3794 return ConstRowReference(this, r); 3795 } 3796 RowReference operator[](uint32_t r) { return RowReference(this, r); } 3797 ConstRowReference operator[](RowNumber r) const { 3798 return ConstRowReference(this, r.row_number()); 3799 } 3800 RowReference operator[](RowNumber r) { 3801 return RowReference(this, r.row_number()); 3802 } 3803 FindById(Id find_id)3804 std::optional<ConstRowReference> FindById(Id find_id) const { 3805 std::optional<uint32_t> row = id().IndexOf(find_id); 3806 return row ? std::make_optional(ConstRowReference(this, *row)) 3807 : std::nullopt; 3808 } 3809 FindById(Id find_id)3810 std::optional<RowReference> FindById(Id find_id) { 3811 std::optional<uint32_t> row = id().IndexOf(find_id); 3812 return row ? std::make_optional(RowReference(this, *row)) : std::nullopt; 3813 } 3814 Insert(const Row & row)3815 IdAndRow Insert(const Row& row) { 3816 uint32_t row_number = row_count(); 3817 Id id = Id{row_number}; 3818 type_.Append(string_pool()->InternString(row.type())); 3819 mutable_ts()->Append(row.ts); 3820 mutable_transition_id()->Append(row.transition_id); 3821 mutable_arg_set_id()->Append(row.arg_set_id); 3822 mutable_base64_proto()->Append(row.base64_proto); 3823 mutable_base64_proto_id()->Append(row.base64_proto_id); 3824 UpdateSelfOverlayAfterInsert(); 3825 return IdAndRow{id, row_number, RowReference(this, row_number), 3826 RowNumber(row_number)}; 3827 } 3828 3829 3830 id()3831 const IdColumn<WindowManagerShellTransitionsTable::Id>& id() const { 3832 return static_cast<const ColumnType::id&>(columns()[ColumnIndex::id]); 3833 } type()3834 const TypedColumn<StringPool::Id>& type() const { 3835 return static_cast<const ColumnType::type&>(columns()[ColumnIndex::type]); 3836 } ts()3837 const TypedColumn<int64_t>& ts() const { 3838 return static_cast<const ColumnType::ts&>(columns()[ColumnIndex::ts]); 3839 } transition_id()3840 const TypedColumn<int64_t>& transition_id() const { 3841 return static_cast<const ColumnType::transition_id&>(columns()[ColumnIndex::transition_id]); 3842 } arg_set_id()3843 const TypedColumn<uint32_t>& arg_set_id() const { 3844 return static_cast<const ColumnType::arg_set_id&>(columns()[ColumnIndex::arg_set_id]); 3845 } base64_proto()3846 const TypedColumn<StringPool::Id>& base64_proto() const { 3847 return static_cast<const ColumnType::base64_proto&>(columns()[ColumnIndex::base64_proto]); 3848 } base64_proto_id()3849 const TypedColumn<std::optional<uint32_t>>& base64_proto_id() const { 3850 return static_cast<const ColumnType::base64_proto_id&>(columns()[ColumnIndex::base64_proto_id]); 3851 } 3852 mutable_ts()3853 TypedColumn<int64_t>* mutable_ts() { 3854 return static_cast<ColumnType::ts*>( 3855 GetColumn(ColumnIndex::ts)); 3856 } mutable_transition_id()3857 TypedColumn<int64_t>* mutable_transition_id() { 3858 return static_cast<ColumnType::transition_id*>( 3859 GetColumn(ColumnIndex::transition_id)); 3860 } mutable_arg_set_id()3861 TypedColumn<uint32_t>* mutable_arg_set_id() { 3862 return static_cast<ColumnType::arg_set_id*>( 3863 GetColumn(ColumnIndex::arg_set_id)); 3864 } mutable_base64_proto()3865 TypedColumn<StringPool::Id>* mutable_base64_proto() { 3866 return static_cast<ColumnType::base64_proto*>( 3867 GetColumn(ColumnIndex::base64_proto)); 3868 } mutable_base64_proto_id()3869 TypedColumn<std::optional<uint32_t>>* mutable_base64_proto_id() { 3870 return static_cast<ColumnType::base64_proto_id*>( 3871 GetColumn(ColumnIndex::base64_proto_id)); 3872 } 3873 3874 private: 3875 3876 3877 ColumnStorage<ColumnType::ts::stored_type> ts_; 3878 ColumnStorage<ColumnType::transition_id::stored_type> transition_id_; 3879 ColumnStorage<ColumnType::arg_set_id::stored_type> arg_set_id_; 3880 ColumnStorage<ColumnType::base64_proto::stored_type> base64_proto_; 3881 ColumnStorage<ColumnType::base64_proto_id::stored_type> base64_proto_id_; 3882 3883 RefPtr<column::StorageLayer> id_storage_layer_; 3884 RefPtr<column::StorageLayer> type_storage_layer_; 3885 RefPtr<column::StorageLayer> ts_storage_layer_; 3886 RefPtr<column::StorageLayer> transition_id_storage_layer_; 3887 RefPtr<column::StorageLayer> arg_set_id_storage_layer_; 3888 RefPtr<column::StorageLayer> base64_proto_storage_layer_; 3889 RefPtr<column::StorageLayer> base64_proto_id_storage_layer_; 3890 3891 RefPtr<column::OverlayLayer> base64_proto_id_null_layer_; 3892 }; 3893 3894 3895 class WindowManagerShellTransitionHandlersTable : public macros_internal::MacroTable { 3896 public: 3897 static constexpr uint32_t kColumnCount = 6; 3898 3899 struct Id : public BaseId { 3900 Id() = default; IdId3901 explicit constexpr Id(uint32_t v) : BaseId(v) {} 3902 }; 3903 static_assert(std::is_trivially_destructible_v<Id>, 3904 "Inheritance used without trivial destruction"); 3905 3906 struct ColumnIndex { 3907 static constexpr uint32_t id = 0; 3908 static constexpr uint32_t type = 1; 3909 static constexpr uint32_t handler_id = 2; 3910 static constexpr uint32_t handler_name = 3; 3911 static constexpr uint32_t base64_proto = 4; 3912 static constexpr uint32_t base64_proto_id = 5; 3913 }; 3914 struct ColumnType { 3915 using id = IdColumn<WindowManagerShellTransitionHandlersTable::Id>; 3916 using type = TypedColumn<StringPool::Id>; 3917 using handler_id = TypedColumn<int64_t>; 3918 using handler_name = TypedColumn<StringPool::Id>; 3919 using base64_proto = TypedColumn<StringPool::Id>; 3920 using base64_proto_id = TypedColumn<std::optional<uint32_t>>; 3921 }; 3922 struct Row : public macros_internal::RootParentTable::Row { 3923 Row(int64_t in_handler_id = {}, 3924 StringPool::Id in_handler_name = {}, 3925 StringPool::Id in_base64_proto = {}, 3926 std::optional<uint32_t> in_base64_proto_id = {}, 3927 std::nullptr_t = nullptr) RowRow3928 : macros_internal::RootParentTable::Row(), 3929 handler_id(in_handler_id), 3930 handler_name(in_handler_name), 3931 base64_proto(in_base64_proto), 3932 base64_proto_id(in_base64_proto_id) { 3933 type_ = "window_manager_shell_transition_handlers"; 3934 } 3935 int64_t handler_id; 3936 StringPool::Id handler_name; 3937 StringPool::Id base64_proto; 3938 std::optional<uint32_t> base64_proto_id; 3939 3940 bool operator==(const WindowManagerShellTransitionHandlersTable::Row& other) const { 3941 return type() == other.type() && ColumnType::handler_id::Equals(handler_id, other.handler_id) && 3942 ColumnType::handler_name::Equals(handler_name, other.handler_name) && 3943 ColumnType::base64_proto::Equals(base64_proto, other.base64_proto) && 3944 ColumnType::base64_proto_id::Equals(base64_proto_id, other.base64_proto_id); 3945 } 3946 }; 3947 struct ColumnFlag { 3948 static constexpr uint32_t handler_id = ColumnType::handler_id::default_flags(); 3949 static constexpr uint32_t handler_name = ColumnType::handler_name::default_flags(); 3950 static constexpr uint32_t base64_proto = ColumnType::base64_proto::default_flags(); 3951 static constexpr uint32_t base64_proto_id = ColumnType::base64_proto_id::default_flags(); 3952 }; 3953 3954 class RowNumber; 3955 class ConstRowReference; 3956 class RowReference; 3957 3958 class RowNumber : public macros_internal::AbstractRowNumber< 3959 WindowManagerShellTransitionHandlersTable, ConstRowReference, RowReference> { 3960 public: RowNumber(uint32_t row_number)3961 explicit RowNumber(uint32_t row_number) 3962 : AbstractRowNumber(row_number) {} 3963 }; 3964 static_assert(std::is_trivially_destructible_v<RowNumber>, 3965 "Inheritance used without trivial destruction"); 3966 3967 class ConstRowReference : public macros_internal::AbstractConstRowReference< 3968 WindowManagerShellTransitionHandlersTable, RowNumber> { 3969 public: ConstRowReference(const WindowManagerShellTransitionHandlersTable * table,uint32_t row_number)3970 ConstRowReference(const WindowManagerShellTransitionHandlersTable* table, uint32_t row_number) 3971 : AbstractConstRowReference(table, row_number) {} 3972 id()3973 ColumnType::id::type id() const { 3974 return table()->id()[row_number_]; 3975 } type()3976 ColumnType::type::type type() const { 3977 return table()->type()[row_number_]; 3978 } handler_id()3979 ColumnType::handler_id::type handler_id() const { 3980 return table()->handler_id()[row_number_]; 3981 } handler_name()3982 ColumnType::handler_name::type handler_name() const { 3983 return table()->handler_name()[row_number_]; 3984 } base64_proto()3985 ColumnType::base64_proto::type base64_proto() const { 3986 return table()->base64_proto()[row_number_]; 3987 } base64_proto_id()3988 ColumnType::base64_proto_id::type base64_proto_id() const { 3989 return table()->base64_proto_id()[row_number_]; 3990 } 3991 }; 3992 static_assert(std::is_trivially_destructible_v<ConstRowReference>, 3993 "Inheritance used without trivial destruction"); 3994 class RowReference : public ConstRowReference { 3995 public: RowReference(const WindowManagerShellTransitionHandlersTable * table,uint32_t row_number)3996 RowReference(const WindowManagerShellTransitionHandlersTable* table, uint32_t row_number) 3997 : ConstRowReference(table, row_number) {} 3998 set_handler_id(ColumnType::handler_id::non_optional_type v)3999 void set_handler_id( 4000 ColumnType::handler_id::non_optional_type v) { 4001 return mutable_table()->mutable_handler_id()->Set(row_number_, v); 4002 } set_handler_name(ColumnType::handler_name::non_optional_type v)4003 void set_handler_name( 4004 ColumnType::handler_name::non_optional_type v) { 4005 return mutable_table()->mutable_handler_name()->Set(row_number_, v); 4006 } set_base64_proto(ColumnType::base64_proto::non_optional_type v)4007 void set_base64_proto( 4008 ColumnType::base64_proto::non_optional_type v) { 4009 return mutable_table()->mutable_base64_proto()->Set(row_number_, v); 4010 } set_base64_proto_id(ColumnType::base64_proto_id::non_optional_type v)4011 void set_base64_proto_id( 4012 ColumnType::base64_proto_id::non_optional_type v) { 4013 return mutable_table()->mutable_base64_proto_id()->Set(row_number_, v); 4014 } 4015 4016 private: mutable_table()4017 WindowManagerShellTransitionHandlersTable* mutable_table() const { 4018 return const_cast<WindowManagerShellTransitionHandlersTable*>(table()); 4019 } 4020 }; 4021 static_assert(std::is_trivially_destructible_v<RowReference>, 4022 "Inheritance used without trivial destruction"); 4023 4024 class ConstIterator; 4025 class ConstIterator : public macros_internal::AbstractConstIterator< 4026 ConstIterator, WindowManagerShellTransitionHandlersTable, RowNumber, ConstRowReference> { 4027 public: id()4028 ColumnType::id::type id() const { 4029 const auto& col = table()->id(); 4030 return col.GetAtIdx( 4031 iterator_.StorageIndexForColumn(col.index_in_table())); 4032 } type()4033 ColumnType::type::type type() const { 4034 const auto& col = table()->type(); 4035 return col.GetAtIdx( 4036 iterator_.StorageIndexForColumn(col.index_in_table())); 4037 } handler_id()4038 ColumnType::handler_id::type handler_id() const { 4039 const auto& col = table()->handler_id(); 4040 return col.GetAtIdx( 4041 iterator_.StorageIndexForColumn(col.index_in_table())); 4042 } handler_name()4043 ColumnType::handler_name::type handler_name() const { 4044 const auto& col = table()->handler_name(); 4045 return col.GetAtIdx( 4046 iterator_.StorageIndexForColumn(col.index_in_table())); 4047 } base64_proto()4048 ColumnType::base64_proto::type base64_proto() const { 4049 const auto& col = table()->base64_proto(); 4050 return col.GetAtIdx( 4051 iterator_.StorageIndexForColumn(col.index_in_table())); 4052 } base64_proto_id()4053 ColumnType::base64_proto_id::type base64_proto_id() const { 4054 const auto& col = table()->base64_proto_id(); 4055 return col.GetAtIdx( 4056 iterator_.StorageIndexForColumn(col.index_in_table())); 4057 } 4058 4059 protected: ConstIterator(const WindowManagerShellTransitionHandlersTable * table,Table::Iterator iterator)4060 explicit ConstIterator(const WindowManagerShellTransitionHandlersTable* table, 4061 Table::Iterator iterator) 4062 : AbstractConstIterator(table, std::move(iterator)) {} 4063 CurrentRowNumber()4064 uint32_t CurrentRowNumber() const { 4065 return iterator_.StorageIndexForLastOverlay(); 4066 } 4067 4068 private: 4069 friend class WindowManagerShellTransitionHandlersTable; 4070 friend class macros_internal::AbstractConstIterator< 4071 ConstIterator, WindowManagerShellTransitionHandlersTable, RowNumber, ConstRowReference>; 4072 }; 4073 class Iterator : public ConstIterator { 4074 public: row_reference()4075 RowReference row_reference() const { 4076 return {const_cast<WindowManagerShellTransitionHandlersTable*>(table()), CurrentRowNumber()}; 4077 } 4078 4079 private: 4080 friend class WindowManagerShellTransitionHandlersTable; 4081 Iterator(WindowManagerShellTransitionHandlersTable * table,Table::Iterator iterator)4082 explicit Iterator(WindowManagerShellTransitionHandlersTable* table, Table::Iterator iterator) 4083 : ConstIterator(table, std::move(iterator)) {} 4084 }; 4085 4086 struct IdAndRow { 4087 Id id; 4088 uint32_t row; 4089 RowReference row_reference; 4090 RowNumber row_number; 4091 }; 4092 GetColumns(WindowManagerShellTransitionHandlersTable * self,const macros_internal::MacroTable * parent)4093 static std::vector<ColumnLegacy> GetColumns( 4094 WindowManagerShellTransitionHandlersTable* self, 4095 const macros_internal::MacroTable* parent) { 4096 std::vector<ColumnLegacy> columns = 4097 CopyColumnsFromParentOrAddRootColumns(self, parent); 4098 uint32_t olay_idx = OverlayCount(parent); 4099 AddColumnToVector(columns, "handler_id", &self->handler_id_, ColumnFlag::handler_id, 4100 static_cast<uint32_t>(columns.size()), olay_idx); 4101 AddColumnToVector(columns, "handler_name", &self->handler_name_, ColumnFlag::handler_name, 4102 static_cast<uint32_t>(columns.size()), olay_idx); 4103 AddColumnToVector(columns, "base64_proto", &self->base64_proto_, ColumnFlag::base64_proto, 4104 static_cast<uint32_t>(columns.size()), olay_idx); 4105 AddColumnToVector(columns, "base64_proto_id", &self->base64_proto_id_, ColumnFlag::base64_proto_id, 4106 static_cast<uint32_t>(columns.size()), olay_idx); 4107 return columns; 4108 } 4109 WindowManagerShellTransitionHandlersTable(StringPool * pool)4110 PERFETTO_NO_INLINE explicit WindowManagerShellTransitionHandlersTable(StringPool* pool) 4111 : macros_internal::MacroTable( 4112 pool, 4113 GetColumns(this, nullptr), 4114 nullptr), 4115 handler_id_(ColumnStorage<ColumnType::handler_id::stored_type>::Create<false>()), 4116 handler_name_(ColumnStorage<ColumnType::handler_name::stored_type>::Create<false>()), 4117 base64_proto_(ColumnStorage<ColumnType::base64_proto::stored_type>::Create<false>()), 4118 base64_proto_id_(ColumnStorage<ColumnType::base64_proto_id::stored_type>::Create<false>()) 4119 , 4120 id_storage_layer_(new column::IdStorage()), 4121 type_storage_layer_( 4122 new column::StringStorage(string_pool(), &type_.vector())), 4123 handler_id_storage_layer_( 4124 new column::NumericStorage<ColumnType::handler_id::non_optional_stored_type>( 4125 &handler_id_.vector(), 4126 ColumnTypeHelper<ColumnType::handler_id::stored_type>::ToColumnType(), 4127 false)), 4128 handler_name_storage_layer_( 4129 new column::StringStorage(string_pool(), &handler_name_.vector())), 4130 base64_proto_storage_layer_( 4131 new column::StringStorage(string_pool(), &base64_proto_.vector())), 4132 base64_proto_id_storage_layer_( 4133 new column::NumericStorage<ColumnType::base64_proto_id::non_optional_stored_type>( 4134 &base64_proto_id_.non_null_vector(), 4135 ColumnTypeHelper<ColumnType::base64_proto_id::stored_type>::ToColumnType(), 4136 false)) 4137 , 4138 base64_proto_id_null_layer_(new column::NullOverlay(base64_proto_id_.bv())) { 4139 static_assert( 4140 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::handler_id::stored_type>( 4141 ColumnFlag::handler_id), 4142 "Column type and flag combination is not valid"); 4143 static_assert( 4144 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::handler_name::stored_type>( 4145 ColumnFlag::handler_name), 4146 "Column type and flag combination is not valid"); 4147 static_assert( 4148 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::base64_proto::stored_type>( 4149 ColumnFlag::base64_proto), 4150 "Column type and flag combination is not valid"); 4151 static_assert( 4152 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::base64_proto_id::stored_type>( 4153 ColumnFlag::base64_proto_id), 4154 "Column type and flag combination is not valid"); 4155 OnConstructionCompletedRegularConstructor( 4156 {id_storage_layer_,type_storage_layer_,handler_id_storage_layer_,handler_name_storage_layer_,base64_proto_storage_layer_,base64_proto_id_storage_layer_}, 4157 {{},{},{},{},{},base64_proto_id_null_layer_}); 4158 } 4159 ~WindowManagerShellTransitionHandlersTable() override; 4160 Name()4161 static const char* Name() { return "window_manager_shell_transition_handlers"; } 4162 ComputeStaticSchema()4163 static Table::Schema ComputeStaticSchema() { 4164 Table::Schema schema; 4165 schema.columns.emplace_back(Table::Schema::Column{ 4166 "id", SqlValue::Type::kLong, true, true, false, false}); 4167 schema.columns.emplace_back(Table::Schema::Column{ 4168 "type", SqlValue::Type::kString, false, false, false, false}); 4169 schema.columns.emplace_back(Table::Schema::Column{ 4170 "handler_id", ColumnType::handler_id::SqlValueType(), false, 4171 false, 4172 false, 4173 false}); 4174 schema.columns.emplace_back(Table::Schema::Column{ 4175 "handler_name", ColumnType::handler_name::SqlValueType(), false, 4176 false, 4177 false, 4178 false}); 4179 schema.columns.emplace_back(Table::Schema::Column{ 4180 "base64_proto", ColumnType::base64_proto::SqlValueType(), false, 4181 false, 4182 false, 4183 false}); 4184 schema.columns.emplace_back(Table::Schema::Column{ 4185 "base64_proto_id", ColumnType::base64_proto_id::SqlValueType(), false, 4186 false, 4187 false, 4188 false}); 4189 return schema; 4190 } 4191 IterateRows()4192 ConstIterator IterateRows() const { 4193 return ConstIterator(this, Table::IterateRows()); 4194 } 4195 IterateRows()4196 Iterator IterateRows() { return Iterator(this, Table::IterateRows()); } 4197 FilterToIterator(const Query & q)4198 ConstIterator FilterToIterator(const Query& q) const { 4199 return ConstIterator(this, QueryToIterator(q)); 4200 } 4201 FilterToIterator(const Query & q)4202 Iterator FilterToIterator(const Query& q) { 4203 return Iterator(this, QueryToIterator(q)); 4204 } 4205 ShrinkToFit()4206 void ShrinkToFit() { 4207 type_.ShrinkToFit(); 4208 handler_id_.ShrinkToFit(); 4209 handler_name_.ShrinkToFit(); 4210 base64_proto_.ShrinkToFit(); 4211 base64_proto_id_.ShrinkToFit(); 4212 } 4213 4214 ConstRowReference operator[](uint32_t r) const { 4215 return ConstRowReference(this, r); 4216 } 4217 RowReference operator[](uint32_t r) { return RowReference(this, r); } 4218 ConstRowReference operator[](RowNumber r) const { 4219 return ConstRowReference(this, r.row_number()); 4220 } 4221 RowReference operator[](RowNumber r) { 4222 return RowReference(this, r.row_number()); 4223 } 4224 FindById(Id find_id)4225 std::optional<ConstRowReference> FindById(Id find_id) const { 4226 std::optional<uint32_t> row = id().IndexOf(find_id); 4227 return row ? std::make_optional(ConstRowReference(this, *row)) 4228 : std::nullopt; 4229 } 4230 FindById(Id find_id)4231 std::optional<RowReference> FindById(Id find_id) { 4232 std::optional<uint32_t> row = id().IndexOf(find_id); 4233 return row ? std::make_optional(RowReference(this, *row)) : std::nullopt; 4234 } 4235 Insert(const Row & row)4236 IdAndRow Insert(const Row& row) { 4237 uint32_t row_number = row_count(); 4238 Id id = Id{row_number}; 4239 type_.Append(string_pool()->InternString(row.type())); 4240 mutable_handler_id()->Append(row.handler_id); 4241 mutable_handler_name()->Append(row.handler_name); 4242 mutable_base64_proto()->Append(row.base64_proto); 4243 mutable_base64_proto_id()->Append(row.base64_proto_id); 4244 UpdateSelfOverlayAfterInsert(); 4245 return IdAndRow{id, row_number, RowReference(this, row_number), 4246 RowNumber(row_number)}; 4247 } 4248 4249 4250 id()4251 const IdColumn<WindowManagerShellTransitionHandlersTable::Id>& id() const { 4252 return static_cast<const ColumnType::id&>(columns()[ColumnIndex::id]); 4253 } type()4254 const TypedColumn<StringPool::Id>& type() const { 4255 return static_cast<const ColumnType::type&>(columns()[ColumnIndex::type]); 4256 } handler_id()4257 const TypedColumn<int64_t>& handler_id() const { 4258 return static_cast<const ColumnType::handler_id&>(columns()[ColumnIndex::handler_id]); 4259 } handler_name()4260 const TypedColumn<StringPool::Id>& handler_name() const { 4261 return static_cast<const ColumnType::handler_name&>(columns()[ColumnIndex::handler_name]); 4262 } base64_proto()4263 const TypedColumn<StringPool::Id>& base64_proto() const { 4264 return static_cast<const ColumnType::base64_proto&>(columns()[ColumnIndex::base64_proto]); 4265 } base64_proto_id()4266 const TypedColumn<std::optional<uint32_t>>& base64_proto_id() const { 4267 return static_cast<const ColumnType::base64_proto_id&>(columns()[ColumnIndex::base64_proto_id]); 4268 } 4269 mutable_handler_id()4270 TypedColumn<int64_t>* mutable_handler_id() { 4271 return static_cast<ColumnType::handler_id*>( 4272 GetColumn(ColumnIndex::handler_id)); 4273 } mutable_handler_name()4274 TypedColumn<StringPool::Id>* mutable_handler_name() { 4275 return static_cast<ColumnType::handler_name*>( 4276 GetColumn(ColumnIndex::handler_name)); 4277 } mutable_base64_proto()4278 TypedColumn<StringPool::Id>* mutable_base64_proto() { 4279 return static_cast<ColumnType::base64_proto*>( 4280 GetColumn(ColumnIndex::base64_proto)); 4281 } mutable_base64_proto_id()4282 TypedColumn<std::optional<uint32_t>>* mutable_base64_proto_id() { 4283 return static_cast<ColumnType::base64_proto_id*>( 4284 GetColumn(ColumnIndex::base64_proto_id)); 4285 } 4286 4287 private: 4288 4289 4290 ColumnStorage<ColumnType::handler_id::stored_type> handler_id_; 4291 ColumnStorage<ColumnType::handler_name::stored_type> handler_name_; 4292 ColumnStorage<ColumnType::base64_proto::stored_type> base64_proto_; 4293 ColumnStorage<ColumnType::base64_proto_id::stored_type> base64_proto_id_; 4294 4295 RefPtr<column::StorageLayer> id_storage_layer_; 4296 RefPtr<column::StorageLayer> type_storage_layer_; 4297 RefPtr<column::StorageLayer> handler_id_storage_layer_; 4298 RefPtr<column::StorageLayer> handler_name_storage_layer_; 4299 RefPtr<column::StorageLayer> base64_proto_storage_layer_; 4300 RefPtr<column::StorageLayer> base64_proto_id_storage_layer_; 4301 4302 RefPtr<column::OverlayLayer> base64_proto_id_null_layer_; 4303 }; 4304 4305 4306 class WindowManagerTable : public macros_internal::MacroTable { 4307 public: 4308 static constexpr uint32_t kColumnCount = 6; 4309 4310 struct Id : public BaseId { 4311 Id() = default; IdId4312 explicit constexpr Id(uint32_t v) : BaseId(v) {} 4313 }; 4314 static_assert(std::is_trivially_destructible_v<Id>, 4315 "Inheritance used without trivial destruction"); 4316 4317 struct ColumnIndex { 4318 static constexpr uint32_t id = 0; 4319 static constexpr uint32_t type = 1; 4320 static constexpr uint32_t ts = 2; 4321 static constexpr uint32_t arg_set_id = 3; 4322 static constexpr uint32_t base64_proto = 4; 4323 static constexpr uint32_t base64_proto_id = 5; 4324 }; 4325 struct ColumnType { 4326 using id = IdColumn<WindowManagerTable::Id>; 4327 using type = TypedColumn<StringPool::Id>; 4328 using ts = TypedColumn<int64_t>; 4329 using arg_set_id = TypedColumn<uint32_t>; 4330 using base64_proto = TypedColumn<StringPool::Id>; 4331 using base64_proto_id = TypedColumn<std::optional<uint32_t>>; 4332 }; 4333 struct Row : public macros_internal::RootParentTable::Row { 4334 Row(int64_t in_ts = {}, 4335 uint32_t in_arg_set_id = {}, 4336 StringPool::Id in_base64_proto = {}, 4337 std::optional<uint32_t> in_base64_proto_id = {}, 4338 std::nullptr_t = nullptr) RowRow4339 : macros_internal::RootParentTable::Row(), 4340 ts(in_ts), 4341 arg_set_id(in_arg_set_id), 4342 base64_proto(in_base64_proto), 4343 base64_proto_id(in_base64_proto_id) { 4344 type_ = "__intrinsic_windowmanager"; 4345 } 4346 int64_t ts; 4347 uint32_t arg_set_id; 4348 StringPool::Id base64_proto; 4349 std::optional<uint32_t> base64_proto_id; 4350 4351 bool operator==(const WindowManagerTable::Row& other) const { 4352 return type() == other.type() && ColumnType::ts::Equals(ts, other.ts) && 4353 ColumnType::arg_set_id::Equals(arg_set_id, other.arg_set_id) && 4354 ColumnType::base64_proto::Equals(base64_proto, other.base64_proto) && 4355 ColumnType::base64_proto_id::Equals(base64_proto_id, other.base64_proto_id); 4356 } 4357 }; 4358 struct ColumnFlag { 4359 static constexpr uint32_t ts = static_cast<uint32_t>(ColumnLegacy::Flag::kSorted) | ColumnType::ts::default_flags(); 4360 static constexpr uint32_t arg_set_id = ColumnType::arg_set_id::default_flags(); 4361 static constexpr uint32_t base64_proto = ColumnType::base64_proto::default_flags(); 4362 static constexpr uint32_t base64_proto_id = ColumnType::base64_proto_id::default_flags(); 4363 }; 4364 4365 class RowNumber; 4366 class ConstRowReference; 4367 class RowReference; 4368 4369 class RowNumber : public macros_internal::AbstractRowNumber< 4370 WindowManagerTable, ConstRowReference, RowReference> { 4371 public: RowNumber(uint32_t row_number)4372 explicit RowNumber(uint32_t row_number) 4373 : AbstractRowNumber(row_number) {} 4374 }; 4375 static_assert(std::is_trivially_destructible_v<RowNumber>, 4376 "Inheritance used without trivial destruction"); 4377 4378 class ConstRowReference : public macros_internal::AbstractConstRowReference< 4379 WindowManagerTable, RowNumber> { 4380 public: ConstRowReference(const WindowManagerTable * table,uint32_t row_number)4381 ConstRowReference(const WindowManagerTable* table, uint32_t row_number) 4382 : AbstractConstRowReference(table, row_number) {} 4383 id()4384 ColumnType::id::type id() const { 4385 return table()->id()[row_number_]; 4386 } type()4387 ColumnType::type::type type() const { 4388 return table()->type()[row_number_]; 4389 } ts()4390 ColumnType::ts::type ts() const { 4391 return table()->ts()[row_number_]; 4392 } arg_set_id()4393 ColumnType::arg_set_id::type arg_set_id() const { 4394 return table()->arg_set_id()[row_number_]; 4395 } base64_proto()4396 ColumnType::base64_proto::type base64_proto() const { 4397 return table()->base64_proto()[row_number_]; 4398 } base64_proto_id()4399 ColumnType::base64_proto_id::type base64_proto_id() const { 4400 return table()->base64_proto_id()[row_number_]; 4401 } 4402 }; 4403 static_assert(std::is_trivially_destructible_v<ConstRowReference>, 4404 "Inheritance used without trivial destruction"); 4405 class RowReference : public ConstRowReference { 4406 public: RowReference(const WindowManagerTable * table,uint32_t row_number)4407 RowReference(const WindowManagerTable* table, uint32_t row_number) 4408 : ConstRowReference(table, row_number) {} 4409 set_ts(ColumnType::ts::non_optional_type v)4410 void set_ts( 4411 ColumnType::ts::non_optional_type v) { 4412 return mutable_table()->mutable_ts()->Set(row_number_, v); 4413 } set_arg_set_id(ColumnType::arg_set_id::non_optional_type v)4414 void set_arg_set_id( 4415 ColumnType::arg_set_id::non_optional_type v) { 4416 return mutable_table()->mutable_arg_set_id()->Set(row_number_, v); 4417 } set_base64_proto(ColumnType::base64_proto::non_optional_type v)4418 void set_base64_proto( 4419 ColumnType::base64_proto::non_optional_type v) { 4420 return mutable_table()->mutable_base64_proto()->Set(row_number_, v); 4421 } set_base64_proto_id(ColumnType::base64_proto_id::non_optional_type v)4422 void set_base64_proto_id( 4423 ColumnType::base64_proto_id::non_optional_type v) { 4424 return mutable_table()->mutable_base64_proto_id()->Set(row_number_, v); 4425 } 4426 4427 private: mutable_table()4428 WindowManagerTable* mutable_table() const { 4429 return const_cast<WindowManagerTable*>(table()); 4430 } 4431 }; 4432 static_assert(std::is_trivially_destructible_v<RowReference>, 4433 "Inheritance used without trivial destruction"); 4434 4435 class ConstIterator; 4436 class ConstIterator : public macros_internal::AbstractConstIterator< 4437 ConstIterator, WindowManagerTable, RowNumber, ConstRowReference> { 4438 public: id()4439 ColumnType::id::type id() const { 4440 const auto& col = table()->id(); 4441 return col.GetAtIdx( 4442 iterator_.StorageIndexForColumn(col.index_in_table())); 4443 } type()4444 ColumnType::type::type type() const { 4445 const auto& col = table()->type(); 4446 return col.GetAtIdx( 4447 iterator_.StorageIndexForColumn(col.index_in_table())); 4448 } ts()4449 ColumnType::ts::type ts() const { 4450 const auto& col = table()->ts(); 4451 return col.GetAtIdx( 4452 iterator_.StorageIndexForColumn(col.index_in_table())); 4453 } arg_set_id()4454 ColumnType::arg_set_id::type arg_set_id() const { 4455 const auto& col = table()->arg_set_id(); 4456 return col.GetAtIdx( 4457 iterator_.StorageIndexForColumn(col.index_in_table())); 4458 } base64_proto()4459 ColumnType::base64_proto::type base64_proto() const { 4460 const auto& col = table()->base64_proto(); 4461 return col.GetAtIdx( 4462 iterator_.StorageIndexForColumn(col.index_in_table())); 4463 } base64_proto_id()4464 ColumnType::base64_proto_id::type base64_proto_id() const { 4465 const auto& col = table()->base64_proto_id(); 4466 return col.GetAtIdx( 4467 iterator_.StorageIndexForColumn(col.index_in_table())); 4468 } 4469 4470 protected: ConstIterator(const WindowManagerTable * table,Table::Iterator iterator)4471 explicit ConstIterator(const WindowManagerTable* table, 4472 Table::Iterator iterator) 4473 : AbstractConstIterator(table, std::move(iterator)) {} 4474 CurrentRowNumber()4475 uint32_t CurrentRowNumber() const { 4476 return iterator_.StorageIndexForLastOverlay(); 4477 } 4478 4479 private: 4480 friend class WindowManagerTable; 4481 friend class macros_internal::AbstractConstIterator< 4482 ConstIterator, WindowManagerTable, RowNumber, ConstRowReference>; 4483 }; 4484 class Iterator : public ConstIterator { 4485 public: row_reference()4486 RowReference row_reference() const { 4487 return {const_cast<WindowManagerTable*>(table()), CurrentRowNumber()}; 4488 } 4489 4490 private: 4491 friend class WindowManagerTable; 4492 Iterator(WindowManagerTable * table,Table::Iterator iterator)4493 explicit Iterator(WindowManagerTable* table, Table::Iterator iterator) 4494 : ConstIterator(table, std::move(iterator)) {} 4495 }; 4496 4497 struct IdAndRow { 4498 Id id; 4499 uint32_t row; 4500 RowReference row_reference; 4501 RowNumber row_number; 4502 }; 4503 GetColumns(WindowManagerTable * self,const macros_internal::MacroTable * parent)4504 static std::vector<ColumnLegacy> GetColumns( 4505 WindowManagerTable* self, 4506 const macros_internal::MacroTable* parent) { 4507 std::vector<ColumnLegacy> columns = 4508 CopyColumnsFromParentOrAddRootColumns(self, parent); 4509 uint32_t olay_idx = OverlayCount(parent); 4510 AddColumnToVector(columns, "ts", &self->ts_, ColumnFlag::ts, 4511 static_cast<uint32_t>(columns.size()), olay_idx); 4512 AddColumnToVector(columns, "arg_set_id", &self->arg_set_id_, ColumnFlag::arg_set_id, 4513 static_cast<uint32_t>(columns.size()), olay_idx); 4514 AddColumnToVector(columns, "base64_proto", &self->base64_proto_, ColumnFlag::base64_proto, 4515 static_cast<uint32_t>(columns.size()), olay_idx); 4516 AddColumnToVector(columns, "base64_proto_id", &self->base64_proto_id_, ColumnFlag::base64_proto_id, 4517 static_cast<uint32_t>(columns.size()), olay_idx); 4518 return columns; 4519 } 4520 WindowManagerTable(StringPool * pool)4521 PERFETTO_NO_INLINE explicit WindowManagerTable(StringPool* pool) 4522 : macros_internal::MacroTable( 4523 pool, 4524 GetColumns(this, nullptr), 4525 nullptr), 4526 ts_(ColumnStorage<ColumnType::ts::stored_type>::Create<false>()), 4527 arg_set_id_(ColumnStorage<ColumnType::arg_set_id::stored_type>::Create<false>()), 4528 base64_proto_(ColumnStorage<ColumnType::base64_proto::stored_type>::Create<false>()), 4529 base64_proto_id_(ColumnStorage<ColumnType::base64_proto_id::stored_type>::Create<false>()) 4530 , 4531 id_storage_layer_(new column::IdStorage()), 4532 type_storage_layer_( 4533 new column::StringStorage(string_pool(), &type_.vector())), 4534 ts_storage_layer_( 4535 new column::NumericStorage<ColumnType::ts::non_optional_stored_type>( 4536 &ts_.vector(), 4537 ColumnTypeHelper<ColumnType::ts::stored_type>::ToColumnType(), 4538 true)), 4539 arg_set_id_storage_layer_( 4540 new column::NumericStorage<ColumnType::arg_set_id::non_optional_stored_type>( 4541 &arg_set_id_.vector(), 4542 ColumnTypeHelper<ColumnType::arg_set_id::stored_type>::ToColumnType(), 4543 false)), 4544 base64_proto_storage_layer_( 4545 new column::StringStorage(string_pool(), &base64_proto_.vector())), 4546 base64_proto_id_storage_layer_( 4547 new column::NumericStorage<ColumnType::base64_proto_id::non_optional_stored_type>( 4548 &base64_proto_id_.non_null_vector(), 4549 ColumnTypeHelper<ColumnType::base64_proto_id::stored_type>::ToColumnType(), 4550 false)) 4551 , 4552 base64_proto_id_null_layer_(new column::NullOverlay(base64_proto_id_.bv())) { 4553 static_assert( 4554 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::ts::stored_type>( 4555 ColumnFlag::ts), 4556 "Column type and flag combination is not valid"); 4557 static_assert( 4558 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::arg_set_id::stored_type>( 4559 ColumnFlag::arg_set_id), 4560 "Column type and flag combination is not valid"); 4561 static_assert( 4562 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::base64_proto::stored_type>( 4563 ColumnFlag::base64_proto), 4564 "Column type and flag combination is not valid"); 4565 static_assert( 4566 ColumnLegacy::IsFlagsAndTypeValid<ColumnType::base64_proto_id::stored_type>( 4567 ColumnFlag::base64_proto_id), 4568 "Column type and flag combination is not valid"); 4569 OnConstructionCompletedRegularConstructor( 4570 {id_storage_layer_,type_storage_layer_,ts_storage_layer_,arg_set_id_storage_layer_,base64_proto_storage_layer_,base64_proto_id_storage_layer_}, 4571 {{},{},{},{},{},base64_proto_id_null_layer_}); 4572 } 4573 ~WindowManagerTable() override; 4574 Name()4575 static const char* Name() { return "__intrinsic_windowmanager"; } 4576 ComputeStaticSchema()4577 static Table::Schema ComputeStaticSchema() { 4578 Table::Schema schema; 4579 schema.columns.emplace_back(Table::Schema::Column{ 4580 "id", SqlValue::Type::kLong, true, true, false, false}); 4581 schema.columns.emplace_back(Table::Schema::Column{ 4582 "type", SqlValue::Type::kString, false, false, false, false}); 4583 schema.columns.emplace_back(Table::Schema::Column{ 4584 "ts", ColumnType::ts::SqlValueType(), false, 4585 true, 4586 false, 4587 false}); 4588 schema.columns.emplace_back(Table::Schema::Column{ 4589 "arg_set_id", ColumnType::arg_set_id::SqlValueType(), false, 4590 false, 4591 false, 4592 false}); 4593 schema.columns.emplace_back(Table::Schema::Column{ 4594 "base64_proto", ColumnType::base64_proto::SqlValueType(), false, 4595 false, 4596 false, 4597 false}); 4598 schema.columns.emplace_back(Table::Schema::Column{ 4599 "base64_proto_id", ColumnType::base64_proto_id::SqlValueType(), false, 4600 false, 4601 false, 4602 false}); 4603 return schema; 4604 } 4605 IterateRows()4606 ConstIterator IterateRows() const { 4607 return ConstIterator(this, Table::IterateRows()); 4608 } 4609 IterateRows()4610 Iterator IterateRows() { return Iterator(this, Table::IterateRows()); } 4611 FilterToIterator(const Query & q)4612 ConstIterator FilterToIterator(const Query& q) const { 4613 return ConstIterator(this, QueryToIterator(q)); 4614 } 4615 FilterToIterator(const Query & q)4616 Iterator FilterToIterator(const Query& q) { 4617 return Iterator(this, QueryToIterator(q)); 4618 } 4619 ShrinkToFit()4620 void ShrinkToFit() { 4621 type_.ShrinkToFit(); 4622 ts_.ShrinkToFit(); 4623 arg_set_id_.ShrinkToFit(); 4624 base64_proto_.ShrinkToFit(); 4625 base64_proto_id_.ShrinkToFit(); 4626 } 4627 4628 ConstRowReference operator[](uint32_t r) const { 4629 return ConstRowReference(this, r); 4630 } 4631 RowReference operator[](uint32_t r) { return RowReference(this, r); } 4632 ConstRowReference operator[](RowNumber r) const { 4633 return ConstRowReference(this, r.row_number()); 4634 } 4635 RowReference operator[](RowNumber r) { 4636 return RowReference(this, r.row_number()); 4637 } 4638 FindById(Id find_id)4639 std::optional<ConstRowReference> FindById(Id find_id) const { 4640 std::optional<uint32_t> row = id().IndexOf(find_id); 4641 return row ? std::make_optional(ConstRowReference(this, *row)) 4642 : std::nullopt; 4643 } 4644 FindById(Id find_id)4645 std::optional<RowReference> FindById(Id find_id) { 4646 std::optional<uint32_t> row = id().IndexOf(find_id); 4647 return row ? std::make_optional(RowReference(this, *row)) : std::nullopt; 4648 } 4649 Insert(const Row & row)4650 IdAndRow Insert(const Row& row) { 4651 uint32_t row_number = row_count(); 4652 Id id = Id{row_number}; 4653 type_.Append(string_pool()->InternString(row.type())); 4654 mutable_ts()->Append(row.ts); 4655 mutable_arg_set_id()->Append(row.arg_set_id); 4656 mutable_base64_proto()->Append(row.base64_proto); 4657 mutable_base64_proto_id()->Append(row.base64_proto_id); 4658 UpdateSelfOverlayAfterInsert(); 4659 return IdAndRow{id, row_number, RowReference(this, row_number), 4660 RowNumber(row_number)}; 4661 } 4662 4663 4664 id()4665 const IdColumn<WindowManagerTable::Id>& id() const { 4666 return static_cast<const ColumnType::id&>(columns()[ColumnIndex::id]); 4667 } type()4668 const TypedColumn<StringPool::Id>& type() const { 4669 return static_cast<const ColumnType::type&>(columns()[ColumnIndex::type]); 4670 } ts()4671 const TypedColumn<int64_t>& ts() const { 4672 return static_cast<const ColumnType::ts&>(columns()[ColumnIndex::ts]); 4673 } arg_set_id()4674 const TypedColumn<uint32_t>& arg_set_id() const { 4675 return static_cast<const ColumnType::arg_set_id&>(columns()[ColumnIndex::arg_set_id]); 4676 } base64_proto()4677 const TypedColumn<StringPool::Id>& base64_proto() const { 4678 return static_cast<const ColumnType::base64_proto&>(columns()[ColumnIndex::base64_proto]); 4679 } base64_proto_id()4680 const TypedColumn<std::optional<uint32_t>>& base64_proto_id() const { 4681 return static_cast<const ColumnType::base64_proto_id&>(columns()[ColumnIndex::base64_proto_id]); 4682 } 4683 mutable_ts()4684 TypedColumn<int64_t>* mutable_ts() { 4685 return static_cast<ColumnType::ts*>( 4686 GetColumn(ColumnIndex::ts)); 4687 } mutable_arg_set_id()4688 TypedColumn<uint32_t>* mutable_arg_set_id() { 4689 return static_cast<ColumnType::arg_set_id*>( 4690 GetColumn(ColumnIndex::arg_set_id)); 4691 } mutable_base64_proto()4692 TypedColumn<StringPool::Id>* mutable_base64_proto() { 4693 return static_cast<ColumnType::base64_proto*>( 4694 GetColumn(ColumnIndex::base64_proto)); 4695 } mutable_base64_proto_id()4696 TypedColumn<std::optional<uint32_t>>* mutable_base64_proto_id() { 4697 return static_cast<ColumnType::base64_proto_id*>( 4698 GetColumn(ColumnIndex::base64_proto_id)); 4699 } 4700 4701 private: 4702 4703 4704 ColumnStorage<ColumnType::ts::stored_type> ts_; 4705 ColumnStorage<ColumnType::arg_set_id::stored_type> arg_set_id_; 4706 ColumnStorage<ColumnType::base64_proto::stored_type> base64_proto_; 4707 ColumnStorage<ColumnType::base64_proto_id::stored_type> base64_proto_id_; 4708 4709 RefPtr<column::StorageLayer> id_storage_layer_; 4710 RefPtr<column::StorageLayer> type_storage_layer_; 4711 RefPtr<column::StorageLayer> ts_storage_layer_; 4712 RefPtr<column::StorageLayer> arg_set_id_storage_layer_; 4713 RefPtr<column::StorageLayer> base64_proto_storage_layer_; 4714 RefPtr<column::StorageLayer> base64_proto_id_storage_layer_; 4715 4716 RefPtr<column::OverlayLayer> base64_proto_id_null_layer_; 4717 }; 4718 4719 } // namespace perfetto 4720 4721 #endif // SRC_TRACE_PROCESSOR_TABLES_WINSCOPE_TABLES_PY_H_ 4722