/*
 * Copyright (C) 2019 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef SRC_TRACE_PROCESSOR_TABLES_MACROS_INTERNAL_H_
#define SRC_TRACE_PROCESSOR_TABLES_MACROS_INTERNAL_H_

#include <type_traits>

#include "perfetto/ext/base/small_vector.h"
#include "src/trace_processor/db/table.h"
#include "src/trace_processor/db/typed_column.h"

namespace perfetto {
namespace trace_processor {
namespace macros_internal {

// We define this class to allow the table macro below to compile without
// needing templates; in reality none of the methods will be called because the
// pointer to this class will always be null.
class RootParentTable : public Table {
 public:
  struct Row {
   public:
    Row(std::nullptr_t = nullptr) {}

    const char* type() const { return type_; }

   protected:
    const char* type_ = nullptr;
  };
  // This class only exists to allow typechecking to work correctly in Insert
  // below. If we had C++17 and if constexpr, we could statically verify that
  // this was never created but for now, we still need to define it to satisfy
  // the typechecker.
  struct IdAndRow {
    uint32_t id;
  };
  struct RowNumber {
    uint32_t row_number() { PERFETTO_FATAL("Should not be called"); }
  };
  IdAndRow Insert(const Row&) { PERFETTO_FATAL("Should not be called"); }

 private:
  explicit RootParentTable(std::nullptr_t);
};

// IdHelper is used to figure out the Id type for a table.
//
// We do this using templates with the following algorithm:
// 1. If the parent class is anything but RootParentTable, the Id of the
//    table is the same as the Id of the parent.
// 2. If the parent class is RootParentTable (i.e. the table is a root
//    table), then the Id is the one defined in the table itself.
// The net result of this is that all tables in the hierarchy get the
// same type of Id - the one defined in the root table of that hierarchy.
//
// Reasoning: We do this because using uint32_t is very overloaded and
// having a wrapper type for ids is very helpful to avoid confusion with
// row indices (especially because ids and row indices often appear in
// similar places in the codebase - that is at insertion in parsers and
// in trackers).
template <typename ParentClass, typename Class>
struct IdHelper {
  using Id = typename ParentClass::Id;
};
template <typename Class>
struct IdHelper<RootParentTable, Class> {
  using Id = typename Class::DefinedId;
};

// The parent class for all macro generated tables.
// This class is used to extract common code from the macro tables to reduce
// code size.
class MacroTable : public Table {
 protected:
  // Constructors for tables created by the regular constructor.
  MacroTable(StringPool* pool, const Table* parent = nullptr)
      : Table(pool), allow_inserts_(true), parent_(parent) {
    if (!parent) {
      overlays_.emplace_back();
      columns_.emplace_back(Column::IdColumn(this, 0, 0));
      columns_.emplace_back(
          Column("type", &type_, Column::kNonNull, this, 1, 0));
      return;
    }

    overlays_.resize(parent->overlays().size() + 1);
    for (const Column& col : parent->columns()) {
      columns_.emplace_back(col, this, col.index_in_table(),
                            col.overlay_index());
    }
  }

  // Constructor for tables created by SelectAndExtendParent.
  MacroTable(StringPool* pool,
             const Table& parent,
             const RowMap& parent_overlay)
      : Table(pool), allow_inserts_(false) {
    row_count_ = parent_overlay.size();
    for (const auto& rm : parent.overlays()) {
      overlays_.emplace_back(rm.SelectRows(parent_overlay));
      PERFETTO_DCHECK(overlays_.back().size() == row_count_);
    }
    overlays_.emplace_back(ColumnStorageOverlay(row_count_));

    for (const Column& col : parent.columns()) {
      columns_.emplace_back(col, this, col.index_in_table(),
                            col.overlay_index());
    }
  }
  ~MacroTable() override;

  // We don't want a move or copy constructor because we store pointers to
  // fields of macro tables which will be invalidated if we move/copy them.
  MacroTable(const MacroTable&) = delete;
  MacroTable& operator=(const MacroTable&) = delete;

  MacroTable(MacroTable&&) = delete;
  MacroTable& operator=(MacroTable&&) noexcept = delete;

  void UpdateOverlaysAfterParentInsert() {
    // Add the last inserted row in each of the parent row maps to the
    // corresponding row map in the child.
    for (uint32_t i = 0; i < parent_->overlays().size(); ++i) {
      const ColumnStorageOverlay& parent_rm = parent_->overlays()[i];
      overlays_[i].Insert(parent_rm.Get(parent_rm.size() - 1));
    }
  }

  void UpdateSelfOverlayAfterInsert() {
    // Also add the index of the new row to the identity row map and increment
    // the size.
    overlays_.back().Insert(row_count_++);
  }

  std::vector<ColumnStorageOverlay> FilterAndApplyToOverlays(
      const std::vector<Constraint>& cs,
      RowMap::OptimizeFor optimize_for) const {
    RowMap rm = FilterToRowMap(cs, optimize_for);
    std::vector<ColumnStorageOverlay> overlays;
    overlays.reserve(overlays_.size());
    for (uint32_t i = 0; i < overlays_.size(); ++i) {
      overlays.emplace_back(overlays_[i].SelectRows(rm));
    }
    return overlays;
  }

  // Stores whether inserts are allowed into this macro table; by default
  // inserts are allowed but they are disallowed when a parent table is extended
  // with |ExtendParent|; the rationale for this is that extensions usually
  // happen in dynamic tables and they should not be allowed to insert rows into
  // the real (static) tables.
  bool allow_inserts_ = true;

  // Stores the most specific "derived" type of this row in the table.
  //
  // For example, suppose a row is inserted into the gpu_slice table. This will
  // also cause a row to be inserted into the slice table. For users querying
  // the slice table, they will want to know the "real" type of this slice (i.e.
  // they will want to see that the type is gpu_slice). This sparse vector
  // stores precisely the real type.
  //
  // Only relevant for parentless tables. Will be empty and unreferenced by
  // tables with parents.
  ColumnStorage<StringPool::Id> type_;

 private:
  const Table* parent_ = nullptr;
};

// Abstract iterator class for macro tables.
// Extracted to allow sharing with view code.
template <typename Iterator,
          typename MacroTable,
          typename RowNumber,
          typename ConstRowReference>
class AbstractConstIterator {
 public:
  explicit operator bool() const { return its_[0]; }

  Iterator& operator++() {
    for (ColumnStorageOverlay::Iterator& it : its_) {
      it.Next();
    }
    return *this_it();
  }

  // Returns a RowNumber for the current row.
  RowNumber row_number() const {
    return RowNumber(this_it()->CurrentRowNumber());
  }

  // Returns a ConstRowReference to the current row.
  ConstRowReference row_reference() const {
    return ConstRowReference(table_, this_it()->CurrentRowNumber());
  }

 protected:
  explicit AbstractConstIterator(const MacroTable* table,
                                 std::vector<ColumnStorageOverlay> overlays)
      : overlays_(std::move(overlays)), table_(table) {
    static_assert(std::is_base_of<Table, MacroTable>::value,
                  "Template param should be a subclass of Table.");

    for (const auto& rm : overlays_) {
      its_.emplace_back(rm.IterateRows());
    }
  }

  // Must not be modified as |its_| contains pointers into this vector.
  std::vector<ColumnStorageOverlay> overlays_;
  std::vector<ColumnStorageOverlay::Iterator> its_;

  const MacroTable* table_;

 private:
  Iterator* this_it() { return static_cast<Iterator*>(this); }
  const Iterator* this_it() const { return static_cast<const Iterator*>(this); }
};

// Abstract RowNumber class for macro tables.
// Extracted to allow sharing with view code.
template <typename MacroTable,
          typename ConstRowReference,
          typename RowReference = void>
class AbstractRowNumber {
 public:
  // Converts this RowNumber to a RowReference for the given |table|.
  template <
      typename RR = RowReference,
      typename = typename std::enable_if<!std::is_same<RR, void>::value>::type>
  RR ToRowReference(MacroTable* table) const {
    return RR(table, row_number_);
  }

  // Converts this RowNumber to a ConstRowReference for the given |table|.
  ConstRowReference ToRowReference(const MacroTable& table) const {
    return ConstRowReference(&table, row_number_);
  }

  // Converts this object to the underlying int value.
  uint32_t row_number() const { return row_number_; }

  // Allows sorting + storage in a map/set.
  bool operator<(const AbstractRowNumber& other) const {
    return row_number_ < other.row_number_;
  }

 protected:
  explicit AbstractRowNumber(uint32_t row_number) : row_number_(row_number) {}

 private:
  uint32_t row_number_ = 0;
};

// Abstract ConstRowReference class for macro tables.
// Extracted to allow sharing with view code.
template <typename MacroTable, typename RowNumber>
class AbstractConstRowReference {
 public:
  // Converts this RowReference to a RowNumber object which is more memory
  // efficient to store.
  RowNumber ToRowNumber() { return RowNumber(row_number_); }

 protected:
  AbstractConstRowReference(const MacroTable* table, uint32_t row_number)
      : table_(table), row_number_(row_number) {}

  const MacroTable* table_ = nullptr;
  uint32_t row_number_ = 0;
};

}  // namespace macros_internal

// Ignore GCC warning about a missing argument for a variadic macro parameter.
#if defined(__GNUC__) || defined(__clang__)
#pragma GCC system_header
#endif

// Basic helper macros.
#define PERFETTO_TP_NOOP(...)

// Gets the class name from a table definition.
#define PERFETTO_TP_EXTRACT_TABLE_CLASS(class_name, ...) class_name
#define PERFETTO_TP_TABLE_CLASS(DEF) \
  DEF(PERFETTO_TP_EXTRACT_TABLE_CLASS, PERFETTO_TP_NOOP, PERFETTO_TP_NOOP)

// Gets the table name from the table definition.
#define PERFETTO_TP_EXTRACT_TABLE_NAME(_, table_name) table_name
#define PERFETTO_TP_TABLE_NAME(DEF) \
  DEF(PERFETTO_TP_EXTRACT_TABLE_NAME, PERFETTO_TP_NOOP, PERFETTO_TP_NOOP)

// Gets the parent definition from a table definition.
#define PERFETTO_TP_EXTRACT_PARENT_DEF(PARENT_DEF, _) PARENT_DEF
#define PERFETTO_TP_PARENT_DEF(DEF) \
  DEF(PERFETTO_TP_NOOP, PERFETTO_TP_EXTRACT_PARENT_DEF, PERFETTO_TP_NOOP)

// Invokes FN on each column in the definition of the table. We define a
// recursive macro as we need to walk up the hierarchy until we hit the root.
// Currently, we hardcode 5 levels but this can be increased as necessary.
#define PERFETTO_TP_ALL_COLUMNS_0(DEF, arg) \
  static_assert(false, "Macro recursion depth exceeded");
#define PERFETTO_TP_ALL_COLUMNS_1(DEF, arg) \
  DEF(PERFETTO_TP_NOOP, PERFETTO_TP_ALL_COLUMNS_0, arg)
#define PERFETTO_TP_ALL_COLUMNS_2(DEF, arg) \
  DEF(PERFETTO_TP_NOOP, PERFETTO_TP_ALL_COLUMNS_1, arg)
#define PERFETTO_TP_ALL_COLUMNS_3(DEF, arg) \
  DEF(PERFETTO_TP_NOOP, PERFETTO_TP_ALL_COLUMNS_2, arg)
#define PERFETTO_TP_ALL_COLUMNS_4(DEF, arg) \
  DEF(PERFETTO_TP_NOOP, PERFETTO_TP_ALL_COLUMNS_3, arg)
#define PERFETTO_TP_ALL_COLUMNS(DEF, arg) \
  DEF(PERFETTO_TP_NOOP, PERFETTO_TP_ALL_COLUMNS_4, arg)

// Invokes FN on each column in the table definition.
#define PERFETTO_TP_TABLE_COLUMNS(DEF, FN) \
  DEF(PERFETTO_TP_NOOP, PERFETTO_TP_NOOP, FN)

// Invokes FN on each column in every ancestor of the table.
#define PERFETTO_TP_PARENT_COLUMNS(DEF, FN) \
  PERFETTO_TP_ALL_COLUMNS(PERFETTO_TP_PARENT_DEF(DEF), FN)

// Basic macros for extracting column info from a schema.
#define PERFETTO_TP_NAME_COMMA(type, name, ...) name,
#define PERFETTO_TP_TYPE_NAME_COMMA(type, name, ...) type name,

// Constructor parameters of Table::Row.
// We name this name_c to avoid a clash with the field names of
// Table::Row.
#define PERFETTO_TP_ROW_CONSTRUCTOR(type, name, ...) type name##_c = {},

// Constructor parameters for parent of Row.
#define PERFETTO_TP_PARENT_ROW_CONSTRUCTOR(type, name, ...) name##_c,

// Initializes the members of Table::Row.
#define PERFETTO_TP_ROW_INITIALIZER(type, name, ...) name = name##_c;

// Defines the variable in Table::Row.
#define PERFETTO_TP_ROW_DEFINITION(type, name, ...) type name = {};

// Used to generate an equality implementation on Table::Row.
#define PERFETTO_TP_ROW_EQUALS(type, name, ...) \
  TypedColumn<type>::Equals(other.name, name)&&

// Defines the parent row field in Insert.
#define PERFETTO_TP_PARENT_ROW_INSERT(type, name, ...) row.name,

// Defines the member variable in the Table.
#define PERFETTO_TP_TABLE_MEMBER(type, name, ...) \
  ColumnStorage<TypedColumn<type>::stored_type> name##_;

#define PERFETTO_TP_COLUMN_FLAG_HAS_FLAG_COL(type, name, flags)               \
  static constexpr uint32_t name##_flags() {                                  \
    return static_cast<uint32_t>(flags) | TypedColumn<type>::default_flags(); \
  }

#define PERFETTO_TP_COLUMN_FLAG_NO_FLAG_COL(type, name) \
  static constexpr uint32_t name##_flags() {            \
    return TypedColumn<type>::default_flags();          \
  }

#define PERFETTO_TP_PARENT_COLUMN_FLAG_HAS_FLAG_COL(type, name, flags) \
  static constexpr uint32_t name##_flags() {                           \
    return (static_cast<uint32_t>(flags) |                             \
            TypedColumn<type>::default_flags()) &                      \
           ~Column::kNoCrossTableInheritFlags;                         \
  }

#define PERFETTO_TP_PARENT_COLUMN_FLAG_NO_FLAG_COL(type, name) \
  static constexpr uint32_t name##_flags() {                   \
    return TypedColumn<type>::default_flags() &                \
           ~Column::kNoCrossTableInheritFlags;                 \
  }

#define PERFETTO_TP_COLUMN_FLAG_CHOOSER(type, name, maybe_flags, fn, ...) fn

// MSVC has slightly different rules about __VA_ARGS__ expansion. This makes it
// behave similarly to GCC/Clang.
// See https://stackoverflow.com/q/5134523/14028266 .
#define PERFETTO_TP_EXPAND_VA_ARGS(x) x

#define PERFETTO_TP_COLUMN_FLAG(...)                          \
  PERFETTO_TP_EXPAND_VA_ARGS(PERFETTO_TP_COLUMN_FLAG_CHOOSER( \
      __VA_ARGS__, PERFETTO_TP_COLUMN_FLAG_HAS_FLAG_COL,      \
      PERFETTO_TP_COLUMN_FLAG_NO_FLAG_COL)(__VA_ARGS__))

#define PERFETTO_TP_PARENT_COLUMN_FLAG(...)                     \
  PERFETTO_TP_EXPAND_VA_ARGS(PERFETTO_TP_COLUMN_FLAG_CHOOSER(   \
      __VA_ARGS__, PERFETTO_TP_PARENT_COLUMN_FLAG_HAS_FLAG_COL, \
      PERFETTO_TP_PARENT_COLUMN_FLAG_NO_FLAG_COL)(__VA_ARGS__))

// Creates the sparse vector with the given flags.
#define PERFETTO_TP_TABLE_CONSTRUCTOR_SV(type, name, ...)        \
  name##_(ColumnStorage<TypedColumn<type>::stored_type>::Create< \
          (name##_flags() & Column::Flag::kDense) != 0>()),

// Invokes the chosen column constructor by passing the given args.
#define PERFETTO_TP_TABLE_CONSTRUCTOR_COLUMN(type, name, ...)   \
  columns_.emplace_back(#name, &name##_, name##_flags(), this,  \
                        static_cast<uint32_t>(columns_.size()), \
                        static_cast<uint32_t>(overlays_.size()) - 1);

// Inserts the value into the corresponding column.
#define PERFETTO_TP_COLUMN_APPEND(type, name, ...) \
  mutable_##name()->Append(std::move(row.name));

// Creates a schema entry for the corresponding column.
#define PERFETTO_TP_COLUMN_SCHEMA(type, name, ...)               \
  schema.columns.emplace_back(Table::Schema::Column{             \
      #name, TypedColumn<type>::SqlValueType(), false,           \
      static_cast<bool>(name##_flags() & Column::Flag::kSorted), \
      static_cast<bool>(name##_flags() & Column::Flag::kHidden), \
      static_cast<bool>(name##_flags() & Column::Flag::kSetId)});

// Defines the immutable accessor for a column.
#define PERFETTO_TP_TABLE_COL_GETTER(type, name, ...)                          \
  const TypedColumn<type>& name() const {                                      \
    return static_cast<const TypedColumn<type>&>(columns_[ColumnIndex::name]); \
  }

// Defines the accessors for a column.
#define PERFETTO_TP_TABLE_MUTABLE_COL_GETTER(type, name, ...)             \
  TypedColumn<type>* mutable_##name() {                                   \
    return static_cast<TypedColumn<type>*>(&columns_[ColumnIndex::name]); \
  }

// Defines the accessors for a column.
#define PERFETTO_TP_TABLE_STATIC_ASSERT_FLAG(type, name, ...)                \
  static_assert(Column::IsFlagsAndTypeValid<TypedColumn<type>::stored_type>( \
                    name##_flags()),                                         \
                "Column type and flag combination is not valid");

// Defines the parameter for the |ExtendParent| function.
#define PERFETTO_TP_TABLE_EXTEND_PARAM(type, name, ...) \
  ColumnStorage<TypedColumn<type>::stored_type> name,

// Defines the parameter passing for the |ExtendParent| function.
#define PERFETTO_TP_TABLE_EXTEND_PARAM_PASSING(type, name, ...) std::move(name),

// Sets the table nullable vector to the parameter passed in the
// |SelectAndExtendParent| function.
#define PERFETTO_TP_TABLE_EXTEND_SET_NV(type, name, ...) \
  PERFETTO_DCHECK(name.size() == parent_overlay.size()); \
  name##_ = std::move(name);

// Definition used as the parent of root tables.
#define PERFETTO_TP_ROOT_TABLE_PARENT_DEF(NAME, PARENT, C) \
  NAME(macros_internal::RootParentTable, "root")

// Defines the getter for the column value in the RowReference.
#define PERFETTO_TP_TABLE_CONST_ROW_REF_GETTER(type, name, ...) \
  type name() const { return table_->name()[row_number_]; }

// Defines the accessor for the column value in the RowReference.
#define PERFETTO_TP_TABLE_ROW_REF_SETTER(type, name, ...)          \
  void set_##name(TypedColumn<type>::non_optional_type v) const {  \
    return mutable_table()->mutable_##name()->Set(row_number_, v); \
  }

// Defines the getter for the column value in the ConstIterator.
#define PERFETTO_TP_TABLE_CONST_IT_GETTER(type, name, ...)  \
  type name() const {                                       \
    const auto& col = table_->name();                       \
    return col.GetAtIdx(its_[col.overlay_index()].index()); \
  }

// Defines the setter for the column value in the Iterator.
#define PERFETTO_TP_TABLE_IT_SETTER(type, name, ...)        \
  void set_##name(TypedColumn<type>::non_optional_type v) { \
    auto* col = mutable_table_->mutable_##name();           \
    col->SetAtIdx(its_[col->overlay_index()].index(), v);   \
  }

// Defines the column index constexpr declaration.
#define PERFETTO_TP_COLUMN_INDEX(type, name, ...) \
  static constexpr uint32_t name = static_cast<uint32_t>(ColumnIndexEnum::name);

// Defines an alias for column type for each column.
#define PERFETTO_TP_COLUMN_TYPE_USING(type, name, ...) \
  using name = TypedColumn<type>;

// Calls ShrinkToFit on each column.
#define PERFETTO_TP_COLUMN_SHRINK_TO_FIT(type, name, ...) name##_.ShrinkToFit();

// For more general documentation, see PERFETTO_TP_TABLE in macros.h.
#define PERFETTO_TP_TABLE_INTERNAL(table_name, class_name, parent_class_name, \
                                   DEF)                                       \
  class class_name : public macros_internal::MacroTable {                     \
   public:                                                                    \
    /* Forward declaration to allow free usage below. */                      \
    class ConstRowReference;                                                  \
    class RowReference;                                                       \
    class RowNumber;                                                          \
    class ConstIterator;                                                      \
                                                                              \
   private:                                                                   \
    /*                                                                        \
     * Allows IdHelper to access DefinedId for root tables.                   \
     * Needs to be defined here to allow the public using declaration of Id   \
     * below to work correctly.                                               \
     */                                                                       \
    friend struct macros_internal::IdHelper<parent_class_name, class_name>;   \
                                                                              \
    /* Whether or not this is a root table */                                 \
    static constexpr bool kIsRootTable =                                      \
        std::is_same<parent_class_name,                                       \
                     macros_internal::RootParentTable>::value;                \
                                                                              \
    /* Aliases to reduce clutter in class defintions below. */                \
    using AbstractRowNumber = macros_internal::                               \
        AbstractRowNumber<class_name, ConstRowReference, RowReference>;       \
    using AbstractConstRowReference =                                         \
        macros_internal::AbstractConstRowReference<class_name, RowNumber>;    \
    using AbstractConstIterator =                                             \
        macros_internal::AbstractConstIterator<ConstIterator,                 \
                                               class_name,                    \
                                               RowNumber,                     \
                                               ConstRowReference>;            \
                                                                              \
    enum class ColumnIndexEnum {                                              \
      id,                                                                     \
      type, /* Expands to col1, col2, ... */                                  \
      PERFETTO_TP_ALL_COLUMNS(DEF, PERFETTO_TP_NAME_COMMA) kNumCols           \
    };                                                                        \
                                                                              \
    /*                                                                        \
     * Defines a new id type for a hierarchy of tables.                       \
     * We define it here as we need this type to be visible for the public    \
     * using declaration of Id below.                                         \
     * Note: This type will only used if this table is a root table.          \
     */                                                                       \
    struct DefinedId : public BaseId {                                        \
      DefinedId() = default;                                                  \
      explicit constexpr DefinedId(uint32_t v) : BaseId(v) {}                 \
    };                                                                        \
    static_assert(std::is_trivially_destructible<DefinedId>::value,           \
                  "Inheritance used without trivial destruction");            \
                                                                              \
    static constexpr uint32_t id_flags() { return Column::kIdFlags; }         \
    static constexpr uint32_t type_flags() { return Column::kNoFlag; }        \
    PERFETTO_TP_PARENT_COLUMNS(DEF, PERFETTO_TP_PARENT_COLUMN_FLAG)           \
    PERFETTO_TP_TABLE_COLUMNS(DEF, PERFETTO_TP_COLUMN_FLAG)                   \
                                                                              \
   public:                                                                    \
    /*                                                                        \
     * This defines the type of the id to be the type of the root             \
     * table of the hierarchy - see IdHelper for more details.                \
     */                                                                       \
    using Id = macros_internal::IdHelper<parent_class_name, class_name>::Id;  \
                                                                              \
    struct ColumnIndex {                                                      \
      static constexpr uint32_t id =                                          \
          static_cast<uint32_t>(ColumnIndexEnum::id);                         \
      static constexpr uint32_t type =                                        \
          static_cast<uint32_t>(ColumnIndexEnum::type);                       \
      PERFETTO_TP_ALL_COLUMNS(DEF, PERFETTO_TP_COLUMN_INDEX)                  \
    };                                                                        \
                                                                              \
    struct ColumnType {                                                       \
      using id = IdColumn<Id>;                                                \
      using type = TypedColumn<StringPool::Id>;                               \
      PERFETTO_TP_ALL_COLUMNS(DEF, PERFETTO_TP_COLUMN_TYPE_USING)             \
    };                                                                        \
                                                                              \
    struct Row : parent_class_name::Row {                                     \
      /*                                                                      \
       * Expands to Row(col_type1 col1_c, std::optional<col_type2> col2_c,    \
       * ...)                                                                 \
       */                                                                     \
      Row(PERFETTO_TP_ALL_COLUMNS(DEF, PERFETTO_TP_ROW_CONSTRUCTOR)           \
              std::nullptr_t = nullptr)                                       \
          : parent_class_name::Row(PERFETTO_TP_PARENT_COLUMNS(                \
                DEF,                                                          \
                PERFETTO_TP_PARENT_ROW_CONSTRUCTOR) nullptr) {                \
        type_ = table_name;                                                   \
                                                                              \
        /*                                                                    \
         * Expands to                                                         \
         * col1 = col1_c;                                                     \
         * ...                                                                \
         */                                                                   \
        PERFETTO_TP_TABLE_COLUMNS(DEF, PERFETTO_TP_ROW_INITIALIZER)           \
      }                                                                       \
                                                                              \
      bool operator==(const class_name::Row& other) const {                   \
        return PERFETTO_TP_ALL_COLUMNS(DEF, PERFETTO_TP_ROW_EQUALS) true;     \
      }                                                                       \
                                                                              \
      /*                                                                      \
       * Expands to                                                           \
       * col_type1 col1 = {};                                                 \
       * ...                                                                  \
       */                                                                     \
      PERFETTO_TP_TABLE_COLUMNS(DEF, PERFETTO_TP_ROW_DEFINITION)              \
    };                                                                        \
    static_assert(std::is_trivially_destructible<Row>::value,                 \
                  "Inheritance used without trivial destruction");            \
                                                                              \
    /*                                                                        \
     * Reference to a row which exists in the table.                          \
     *                                                                        \
     * Allows caller code to store and instances of this object without       \
     * having to interact with row numbers.                                   \
     */                                                                       \
    class ConstRowReference : public AbstractConstRowReference {              \
     public:                                                                  \
      ConstRowReference(const class_name* table, uint32_t row_number)         \
          : AbstractConstRowReference(table, row_number) {}                   \
                                                                              \
      PERFETTO_TP_TABLE_CONST_ROW_REF_GETTER(Id, id)                          \
      PERFETTO_TP_TABLE_CONST_ROW_REF_GETTER(StringPool::Id, type)            \
                                                                              \
      /*                                                                      \
       * Expands to                                                           \
       * col1_type col1() const { return table_->col1()[row_]; }              \
       * ...                                                                  \
       */                                                                     \
      PERFETTO_TP_ALL_COLUMNS(DEF, PERFETTO_TP_TABLE_CONST_ROW_REF_GETTER)    \
    };                                                                        \
    static_assert(std::is_trivially_destructible<ConstRowReference>::value,   \
                  "Inheritance used without trivial destruction");            \
                                                                              \
    /*                                                                        \
     * Reference to a row which exists in the table.                          \
     *                                                                        \
     * Allows caller code to store and instances of this object without       \
     * having to interact with row numbers.                                   \
     */                                                                       \
    class RowReference : public ConstRowReference {                           \
     public:                                                                  \
      RowReference(class_name* table, uint32_t row_number)                    \
          : ConstRowReference(table, row_number) {}                           \
                                                                              \
      /*                                                                      \
       * Expands to                                                           \
       * void set_col1(col1_type v) { table_->mutable_col1()->Set(row, v); }  \
       * ...                                                                  \
       */                                                                     \
      PERFETTO_TP_ALL_COLUMNS(DEF, PERFETTO_TP_TABLE_ROW_REF_SETTER)          \
                                                                              \
     private:                                                                 \
      class_name* mutable_table() const {                                     \
        return const_cast<class_name*>(table_);                               \
      }                                                                       \
    };                                                                        \
    static_assert(std::is_trivially_destructible<RowReference>::value,        \
                  "Inheritance used without trivial destruction");            \
                                                                              \
    /*                                                                        \
     * Strongly typed wrapper around the row index. Prefer storing this over  \
     * storing RowReference to reduce memory usage                            \
     */                                                                       \
    class RowNumber : public AbstractRowNumber {                              \
     public:                                                                  \
      explicit RowNumber(uint32_t row_number)                                 \
          : AbstractRowNumber(row_number) {}                                  \
    };                                                                        \
    static_assert(std::is_trivially_destructible<RowNumber>::value,           \
                  "Inheritance used without trivial destruction");            \
                                                                              \
    /* Return value of Insert giving access to id and row number */           \
    struct IdAndRow {                                                         \
      Id id;                                                                  \
      uint32_t row;                                                           \
      RowReference row_reference;                                             \
      RowNumber row_number;                                                   \
    };                                                                        \
                                                                              \
    /*                                                                        \
     * Strongly typed const iterator for this macro table.                    \
     *                                                                        \
     * Allows efficient retrieval of values from this table without having to \
     * deal with row numbers, ColumnStorageOverlays or indices.               \
     */                                                                       \
    class ConstIterator : public AbstractConstIterator {                      \
     public:                                                                  \
      PERFETTO_TP_TABLE_CONST_IT_GETTER(Id, id)                               \
      PERFETTO_TP_TABLE_CONST_IT_GETTER(StringPool::Id, type)                 \
                                                                              \
      /*                                                                      \
       * Expands to                                                           \
       * col1_type col1() const { return table_->col1().GetAtIdx(i); }        \
       * ...                                                                  \
       */                                                                     \
      PERFETTO_TP_ALL_COLUMNS(DEF, PERFETTO_TP_TABLE_CONST_IT_GETTER)         \
                                                                              \
     protected:                                                               \
      /*                                                                      \
       * Must not be public to avoid buggy code because of inheritance        \
       * without virtual destructor.                                          \
       */                                                                     \
      explicit ConstIterator(const class_name* table,                         \
                             std::vector<ColumnStorageOverlay> overlays)      \
          : AbstractConstIterator(table, std::move(overlays)) {}              \
                                                                              \
      uint32_t CurrentRowNumber() const {                                     \
        /*                                                                    \
         * Because the last ColumnStorageOverlay belongs to this table it     \
         * will be dense (i.e. every row in the table will be part of this    \
         * ColumnStorageOverlay + will be represented with a range). This     \
         * means that the index() of the last ColumnStorageOverlay iterator   \
         * is precisely the row number in table!                              \
         */                                                                   \
        return its_.back().index();                                           \
      }                                                                       \
                                                                              \
     private:                                                                 \
      friend class class_name;                                                \
      friend class AbstractConstIterator;                                     \
    };                                                                        \
                                                                              \
    /*                                                                        \
     * Strongly typed iterator for this macro table.                          \
     *                                                                        \
     * Enhances ConstIterator by also allowing values in the table to be set  \
     * as well as retrieved.                                                  \
     */                                                                       \
    class Iterator : public ConstIterator {                                   \
     public:                                                                  \
      /*                                                                      \
       * Expands to                                                           \
       * void set_col1(col1_type v) { table_->mut_col1()->SetAtIdx(i, v); }   \
       * ...                                                                  \
       */                                                                     \
      PERFETTO_TP_ALL_COLUMNS(DEF, PERFETTO_TP_TABLE_IT_SETTER)               \
                                                                              \
      /*                                                                      \
       * Returns a RowReference to the current row.                           \
       */                                                                     \
      RowReference row_reference() const {                                    \
        return RowReference(mutable_table_, CurrentRowNumber());              \
      }                                                                       \
                                                                              \
     private:                                                                 \
      friend class class_name;                                                \
                                                                              \
      /*                                                                      \
       * Must not be public to avoid buggy code because of inheritance        \
       * without virtual destructor.                                          \
       */                                                                     \
      explicit Iterator(class_name* table,                                    \
                        std::vector<ColumnStorageOverlay> overlays)           \
          : ConstIterator(table, std::move(overlays)),                        \
            mutable_table_(table) {}                                          \
                                                                              \
      class_name* mutable_table_ = nullptr;                                   \
    };                                                                        \
                                                                              \
    class_name(StringPool* pool, parent_class_name* parent)                   \
        : macros_internal::MacroTable(pool, parent),                          \
          PERFETTO_TP_TABLE_COLUMNS(DEF, PERFETTO_TP_TABLE_CONSTRUCTOR_SV)    \
              parent_(parent) {                                               \
      PERFETTO_CHECK(kIsRootTable == (parent == nullptr));                    \
                                                                              \
      PERFETTO_TP_ALL_COLUMNS(DEF, PERFETTO_TP_TABLE_STATIC_ASSERT_FLAG)      \
                                                                              \
      /*                                                                      \
       * Expands to                                                           \
       * columns_.emplace_back("col1", col1_, Column::kNoFlag, this,          \
       *                       static_cast<uint32_t>(columns_.size()),        \
       *                       static_cast<uint32_t>(overlays_.size()) - 1);  \
       * ...                                                                  \
       */                                                                     \
      PERFETTO_TP_TABLE_COLUMNS(DEF, PERFETTO_TP_TABLE_CONSTRUCTOR_COLUMN);   \
    }                                                                         \
    ~class_name() override;                                                   \
                                                                              \
    IdAndRow Insert(const Row& row) {                                         \
      PERFETTO_DCHECK(allow_inserts_);                                        \
                                                                              \
      Id id;                                                                  \
      uint32_t row_number = row_count();                                      \
      if (kIsRootTable) {                                                     \
        id = Id{row_number};                                                  \
        type_.Append(string_pool_->InternString(row.type()));                 \
      } else {                                                                \
        PERFETTO_DCHECK(parent_);                                             \
        id = Id{parent_->Insert(row).id};                                     \
        UpdateOverlaysAfterParentInsert();                                    \
      }                                                                       \
                                                                              \
      /*                                                                      \
       * Expands to                                                           \
       * col1_.Append(row.col1);                                              \
       * ...                                                                  \
       */                                                                     \
      PERFETTO_TP_TABLE_COLUMNS(DEF, PERFETTO_TP_COLUMN_APPEND);              \
                                                                              \
      UpdateSelfOverlayAfterInsert();                                         \
      return {id, row_number, RowReference(this, row_number),                 \
              RowNumber(row_number)};                                         \
    }                                                                         \
                                                                              \
    static Table::Schema ComputeStaticSchema() {                              \
      Table::Schema schema;                                                   \
      schema.columns.emplace_back(Table::Schema::Column{                      \
          "id", SqlValue::Type::kLong, true, true, false, false});            \
      schema.columns.emplace_back(Table::Schema::Column{                      \
          "type", SqlValue::Type::kString, false, false, false, false});      \
      PERFETTO_TP_ALL_COLUMNS(DEF, PERFETTO_TP_COLUMN_SCHEMA);                \
      return schema;                                                          \
    }                                                                         \
                                                                              \
    void ShrinkToFit() {                                                      \
      type_.ShrinkToFit();                                                    \
      PERFETTO_TP_TABLE_COLUMNS(DEF, PERFETTO_TP_COLUMN_SHRINK_TO_FIT);       \
    }                                                                         \
                                                                              \
    /* Iterates the table. */                                                 \
    ConstIterator IterateRows() const {                                       \
      return ConstIterator(this, CopyOverlays());                             \
    }                                                                         \
                                                                              \
    /* Iterates the table. */                                                 \
    Iterator IterateRows() { return Iterator(this, CopyOverlays()); }         \
                                                                              \
    /* Filters the Table using the specified filter constraints. */           \
    ConstIterator FilterToIterator(                                           \
        const std::vector<Constraint>& cs,                                    \
        RowMap::OptimizeFor opt = RowMap::OptimizeFor::kMemory) const {       \
      return ConstIterator(this, FilterAndApplyToOverlays(cs, opt));          \
    }                                                                         \
                                                                              \
    /* Filters the Table using the specified filter constraints. */           \
    Iterator FilterToIterator(                                                \
        const std::vector<Constraint>& cs,                                    \
        RowMap::OptimizeFor opt = RowMap::OptimizeFor::kMemory) {             \
      return Iterator(this, FilterAndApplyToOverlays(cs, opt));               \
    }                                                                         \
                                                                              \
    /* Returns a ConstRowReference to the row pointed to by |find_id|. */     \
    std::optional<ConstRowReference> FindById(Id find_id) const {             \
      std::optional<uint32_t> row = id().IndexOf(find_id);                    \
      if (!row)                                                               \
        return std::nullopt;                                                  \
      return ConstRowReference(this, *row);                                   \
    }                                                                         \
                                                                              \
    /* Returns a RowReference to the row pointed to by |find_id|. */          \
    std::optional<RowReference> FindById(Id find_id) {                        \
      std::optional<uint32_t> row = id().IndexOf(find_id);                    \
      if (!row)                                                               \
        return std::nullopt;                                                  \
      return RowReference(this, *row);                                        \
    }                                                                         \
                                                                              \
    const IdColumn<Id>& id() const {                                          \
      return static_cast<const IdColumn<Id>&>(                                \
          columns_[static_cast<uint32_t>(ColumnIndex::id)]);                  \
    }                                                                         \
    PERFETTO_TP_TABLE_COL_GETTER(StringPool::Id, type)                        \
                                                                              \
    /* Returns the name of the table */                                       \
    static constexpr const char* Name() { return table_name; }                \
                                                                              \
    /*                                                                        \
     * Creates a filled instance of this class by selecting all rows in       \
     * parent and filling the table columns with the provided vectors.        \
     */                                                                       \
    static std::unique_ptr<Table> ExtendParent(                               \
        const parent_class_name& parent,                                      \
        PERFETTO_TP_TABLE_COLUMNS(DEF, PERFETTO_TP_TABLE_EXTEND_PARAM)        \
            std::nullptr_t = nullptr) {                                       \
      return std::unique_ptr<Table>(new class_name(                           \
          parent.string_pool(), parent, RowMap(0, parent.row_count()),        \
          PERFETTO_TP_TABLE_COLUMNS(                                          \
              DEF, PERFETTO_TP_TABLE_EXTEND_PARAM_PASSING) nullptr));         \
    }                                                                         \
                                                                              \
    /*                                                                        \
     * Creates a filled instance of this class by first selecting all rows in \
     * parent given by |rows| and filling the table columns with the provided \
     * vectors.                                                               \
     */                                                                       \
    static std::unique_ptr<Table> SelectAndExtendParent(                      \
        const parent_class_name& parent,                                      \
        std::vector<parent_class_name::RowNumber> parent_row_overlay,         \
        PERFETTO_TP_TABLE_COLUMNS(DEF, PERFETTO_TP_TABLE_EXTEND_PARAM)        \
            std::nullptr_t = nullptr) {                                       \
      std::vector<uint32_t> prs_untyped(parent_row_overlay.size());           \
      for (uint32_t i = 0; i < parent_row_overlay.size(); ++i) {              \
        prs_untyped[i] = parent_row_overlay[i].row_number();                  \
      }                                                                       \
      return std::unique_ptr<Table>(new class_name(                           \
          parent.string_pool(), parent, RowMap(std::move(prs_untyped)),       \
          PERFETTO_TP_TABLE_COLUMNS(                                          \
              DEF, PERFETTO_TP_TABLE_EXTEND_PARAM_PASSING) nullptr));         \
    }                                                                         \
                                                                              \
    /*                                                                        \
     * Expands to                                                             \
     * const TypedColumn<col1_type>& col1() { return col1_; }                 \
     * ...                                                                    \
     */                                                                       \
    PERFETTO_TP_ALL_COLUMNS(DEF, PERFETTO_TP_TABLE_COL_GETTER)                \
                                                                              \
    /*                                                                        \
     * Expands to                                                             \
     * TypedColumn<col1_type>* mutable_col1() { return &col1_; }              \
     * ...                                                                    \
     */                                                                       \
    PERFETTO_TP_ALL_COLUMNS(DEF, PERFETTO_TP_TABLE_MUTABLE_COL_GETTER)        \
                                                                              \
   private:                                                                   \
    class_name(StringPool* pool,                                              \
               const parent_class_name& parent,                               \
               RowMap parent_overlay,                                         \
               PERFETTO_TP_TABLE_COLUMNS(DEF, PERFETTO_TP_TABLE_EXTEND_PARAM) \
                   std::nullptr_t = nullptr)                                  \
        : macros_internal::MacroTable(pool, parent, parent_overlay) {         \
      PERFETTO_TP_ALL_COLUMNS(DEF, PERFETTO_TP_TABLE_STATIC_ASSERT_FLAG)      \
      PERFETTO_TP_TABLE_COLUMNS(DEF, PERFETTO_TP_TABLE_EXTEND_SET_NV)         \
                                                                              \
      /*                                                                      \
       * Expands to                                                           \
       * columns_.emplace_back("col1", col1_, Column::kNoFlag, this,          \
       *                       static_cast<uint32_t>(columns_.size()),        \
       *                       static_cast<uint32_t>(overlays_.size()) - 1);  \
       * ...                                                                  \
       */                                                                     \
      PERFETTO_TP_TABLE_COLUMNS(DEF, PERFETTO_TP_TABLE_CONSTRUCTOR_COLUMN);   \
    }                                                                         \
                                                                              \
    /*                                                                        \
     * Expands to                                                             \
     * NullableVector<col1_type> col1_;                                       \
     * ...                                                                    \
     */                                                                       \
    PERFETTO_TP_TABLE_COLUMNS(DEF, PERFETTO_TP_TABLE_MEMBER)                  \
                                                                              \
    parent_class_name* parent_ = nullptr;                                     \
  }

}  // namespace trace_processor
}  // namespace perfetto

#endif  // SRC_TRACE_PROCESSOR_TABLES_MACROS_INTERNAL_H_