ui/base/metadata/metadata_macros_internal.h

// Copyright 2019 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifndef UI_BASE_METADATA_METADATA_MACROS_INTERNAL_H_
#define UI_BASE_METADATA_METADATA_MACROS_INTERNAL_H_

#include <string>
#include <string_view>
#include <utility>

#include "ui/base/metadata/metadata_types.h"
#include "ui/base/metadata/property_metadata.h"

// Internal Metadata Generation Helpers ---------------------------------------

#define METADATA_CLASS_NAME_INTERNAL(class_name) class_name##_MetaData

// TODO(kylixrd@): Remove kViewClassName[] from macros once all references to it
// have been eradicated and IsViewClass<T> is being used instead.

// Metadata Accessors ---------------------------------------------------------
#define METADATA_ACCESSORS_INTERNAL(class_name)        \
  using kMetadataTag = class_name;                     \
  [[maybe_unused]] static const char kViewClassName[]; \
  static ui::metadata::ClassMetaData* MetaData();      \
  /* Don't hide non-const base class version. */       \
  using MetaDataProvider::GetClassMetaData;            \
  const ui::metadata::ClassMetaData* GetClassMetaData() const override;

#define METADATA_ACCESSORS_INTERNAL_TEMPLATE(class_name)                       \
  using kMetadataTag = class_name;                                             \
  [[maybe_unused]] static const char kViewClassName[];                         \
  static ui::metadata::ClassMetaData* MetaData() {                             \
    if (!METADATA_CLASS_NAME_INTERNAL(class_name)::meta_data_) {               \
      METADATA_CLASS_NAME_INTERNAL(class_name)::meta_data_ =                   \
          ui::metadata::MakeAndRegisterClassInfo<METADATA_CLASS_NAME_INTERNAL( \
              class_name)>();                                                  \
    }                                                                          \
    return METADATA_CLASS_NAME_INTERNAL(class_name)::meta_data_;               \
  }                                                                            \
  /* Don't hide non-const base class version. */                               \
  using ui::metadata::MetaDataProvider::GetClassMetaData;                      \
  const ui::metadata::ClassMetaData* GetClassMetaData() const override {       \
    return MetaData();                                                         \
  }

// A version of METADATA_ACCESSORS_INTERNAL for View, the root of the metadata
// hierarchy; here GetClassName() is not declared as an override.
//
// This also introduces the ReinterpretToBaseClass(), which should exist at the
// root of the hierarchy on which the metadata will be attached. This will take
// the given void*, which should be some instance of a subclass of this base
// class, and return a properly typed class_name*. The body of this function
// does a reinterpret_cast<> of the void* to obtain a class_name*. Doing a
// direct static_cast<> from the void* may result in an incorrect
// pointer-to-instance, which may cause a crash. Using this intermediate step of
// reinterpret_cast<> provides more information to the compiler in order to
// obtain the proper result from the static_cast<>. See |AsClass(void* obj)|
// in property_metadata.h for additional info.
#define METADATA_ACCESSORS_INTERNAL_BASE(class_name)   \
  using kMetadataTag = class_name;                     \
  [[maybe_unused]] static const char kViewClassName[]; \
  std::string_view GetClassName() const;               \
  static ui::metadata::ClassMetaData* MetaData();      \
  class_name* ReinterpretToBaseClass(void* obj);       \
  /* Don't hide non-const base class version. */       \
  using MetaDataProvider::GetClassMetaData;            \
  const ui::metadata::ClassMetaData* GetClassMetaData() const override;

// Metadata Class -------------------------------------------------------------
#define METADATA_CLASS_INTERNAL(class_name, file, line)              \
  class METADATA_CLASS_NAME_INTERNAL(class_name)                     \
      : public ui::metadata::ClassMetaData {                         \
   public:                                                           \
    using TheClass = class_name;                                     \
    explicit METADATA_CLASS_NAME_INTERNAL(class_name)()              \
        : ClassMetaData(file, line) {                                \
      BuildMetaData();                                               \
    }                                                                \
    METADATA_CLASS_NAME_INTERNAL(class_name)                         \
    (const METADATA_CLASS_NAME_INTERNAL(class_name) &) = delete;     \
    METADATA_CLASS_NAME_INTERNAL(class_name) & operator=(            \
        const METADATA_CLASS_NAME_INTERNAL(class_name) &) = delete;  \
                                                                     \
   private:                                                          \
    friend class class_name;                                         \
    void BuildMetaData();                                            \
    [[maybe_unused]] static ui::metadata::ClassMetaData* meta_data_; \
  }

#define METADATA_CLASS_INTERNAL_TEMPLATE(class_name, file, line)     \
  class METADATA_CLASS_NAME_INTERNAL(class_name)                     \
      : public ui::metadata::ClassMetaData {                         \
   public:                                                           \
    using TheClass = class_name;                                     \
    explicit METADATA_CLASS_NAME_INTERNAL(class_name)()              \
        : ClassMetaData(file, line) {                                \
      BuildMetaData();                                               \
    }                                                                \
    METADATA_CLASS_NAME_INTERNAL(class_name)                         \
    (const METADATA_CLASS_NAME_INTERNAL(class_name) &) = delete;     \
    METADATA_CLASS_NAME_INTERNAL(class_name) & operator=(            \
        const METADATA_CLASS_NAME_INTERNAL(class_name) &) = delete;  \
                                                                     \
   private:                                                          \
    friend class class_name;                                         \
    void BuildMetaData();                                            \
    [[maybe_unused]] static ui::metadata::ClassMetaData* meta_data_; \
  }

#define METADATA_PROPERTY_TYPE_INTERNAL(property_type, property_name, ...) \
  ui::metadata::ObjectPropertyMetaData<                                    \
      TheClass, property_type, decltype(&TheClass::Set##property_name),    \
      &TheClass::Set##property_name,                                       \
      decltype(std::declval<TheClass>().Get##property_name()),             \
      &TheClass::Get##property_name, ##__VA_ARGS__>

#define METADATA_READONLY_PROPERTY_TYPE_INTERNAL(property_type, property_name, \
                                                 ...)                          \
  ui::metadata::ObjectPropertyReadOnlyMetaData<                                \
      TheClass, property_type,                                                 \
      decltype(std::declval<TheClass>().Get##property_name()),                 \
      &TheClass::Get##property_name, ##__VA_ARGS__>

#define METADATA_CLASS_PROPERTY_TYPE_INTERNAL(property_type, property_key, \
                                              ...)                         \
  ui::metadata::ClassPropertyMetaData<TheClass, decltype(property_key),    \
                                      property_type, ##__VA_ARGS__>

#define BEGIN_METADATA_INTERNAL(qualified_class_name, metadata_class_name,    \
                                parent_class_name)                            \
  ui::metadata::ClassMetaData*                                                \
      qualified_class_name::metadata_class_name::meta_data_ = nullptr;        \
                                                                              \
  ui::metadata::ClassMetaData* qualified_class_name::MetaData() {             \
    static_assert(std::is_base_of_v<parent_class_name, qualified_class_name>, \
                  "class not child of parent");                               \
    if (!qualified_class_name::metadata_class_name::meta_data_) {             \
      qualified_class_name::metadata_class_name::meta_data_ =                 \
          ui::metadata::MakeAndRegisterClassInfo<                             \
              qualified_class_name::metadata_class_name>();                   \
    }                                                                         \
    return qualified_class_name::metadata_class_name::meta_data_;             \
  }                                                                           \
                                                                              \
  const ui::metadata::ClassMetaData* qualified_class_name::GetClassMetaData() \
      const {                                                                 \
    return MetaData();                                                        \
  }                                                                           \
                                                                              \
  const char qualified_class_name::kViewClassName[] = #qualified_class_name;  \
                                                                              \
  void qualified_class_name::metadata_class_name::BuildMetaData() {           \
    SetTypeName(#qualified_class_name);

#define BEGIN_TEMPLATE_METADATA_INTERNAL(qualified_class_name,               \
                                         metadata_class_name)                \
  template <>                                                                \
  ui::metadata::ClassMetaData*                                               \
      qualified_class_name::metadata_class_name::meta_data_ = nullptr;       \
                                                                             \
  template <>                                                                \
  const char qualified_class_name::kViewClassName[] = #qualified_class_name; \
                                                                             \
  template <>                                                                \
  void qualified_class_name::metadata_class_name::BuildMetaData() {          \
    SetTypeName(#qualified_class_name);                                      \
    SetParentClassMetaData(kAncestorClass::MetaData());

#define BEGIN_METADATA_INTERNAL_BASE(qualified_class_name,                   \
                                     metadata_class_name, parent_class_name) \
  std::string_view qualified_class_name::GetClassName() const {              \
    return GetClassMetaData()->type_name();                                  \
  }                                                                          \
                                                                             \
  BEGIN_METADATA_INTERNAL(qualified_class_name, metadata_class_name,         \
                          parent_class_name)

// See the comment above on the METADATA_ACCESSORS_INTERNAL_BASE macro for more
// information. NOTE: This function should not be modified to access |this|,
// directly or indirectly. It should only do what is necessary to convert |obj|
// to a properly typed pointer.
#define METADATA_REINTERPRET_BASE_CLASS_INTERNAL(qualified_class_name, \
                                                 metadata_class_name)  \
  qualified_class_name* qualified_class_name::ReinterpretToBaseClass(  \
      void* obj) {                                                     \
    return reinterpret_cast<qualified_class_name*>(obj);               \
  }

#define METADATA_PARENT_CLASS_INTERNAL(parent_class_name) \
  SetParentClassMetaData(parent_class_name::MetaData());

#define DECLARE_TEMPLATE_METADATA_INTERNAL(qualified_class_name, \
                                           metadata_class_name)  \
  template <>                                                    \
  ui::metadata::ClassMetaData*                                   \
      qualified_class_name::metadata_class_name::meta_data_

#endif  // UI_BASE_METADATA_METADATA_MACROS_INTERNAL_H_