Type Loopholes: решая нерешаемое. Рефлексия времени компиляции26.06.2024 04:00

Constexpr счётчик

Для реализации следующего нам понадобится счётчик, только вот его реализация не так проста, как кажется на первый взгляд.

template 
struct TagWithValue {};

template 
consteval auto CounterImpl() -> std::size_t {
  if constexpr(requires{Magic(Getter{}>{});}) {
    return CounterImpl();
  };
  return (std::ignore = Injector{}, 0>{}, I);
};

Такой подход работать не будет из-за того, что компиляторы C++ могут просто не вычислять значение после следующего вызова, а просто взять старое, из-за чего он и не будет работать.

Решается это просто прокидыванием извне уникального пака Ts, который будет гарантироваться, что будет заново вычисляться значение.

template 
consteval auto CounterImpl() -> std::size_t {
  if constexpr(requires{Magic(Getter{}>{});}) {
    return CounterImpl();
  };
  return (std::ignore = Injector{}, 0>{}, I);
};

Ну и обернуть в интерфейс без I

template ()>
consteval auto Counter() -> std::size_t {
  return R;
};

Проверяем:

static_assert(Counter() == 0);
static_assert(Counter() == 1);
static_assert(Counter() == 2);

Но вот это работать не будет:

static_assert(Counter() == 0);
static_assert(Counter() == 1);
static_assert(Counter() != Counter());

Но это нужно не везде, а там где такое нужно, легко достигается нужного эффекта.

Если вы инстанцируете шаблон функции Foo с параметром int, то в первый раз функция инстанцируется и как-бы добавится в конец кода, ей будет доступно всё что было до этого момента, но не то что после, а если снова попытаться её инстанцировать, то нового инстанса произведено не будет, а возьмётся тот, что уже есть выше.

Такая особенность это пример того, как имплементаця использует более широкую гарантию. Если бы шаблоны инстанцировались в разное от одного набора аргументов, то IFNDR.

Проще понять такую особенность можно на примере простой функции GetUnique (Ps: Не используйте лупхолы для таких функций, что реализуются через fold expressions, тимлид вам спасибо не скажет), которая убирает дубликаты из списка типов

Она использует как раз тот факт, что если попытаться инстанцировать уже инстанцированный шаблон, ничего более добавляться не будет. А значит, если мы просто будем просовывать в шаблоны параметры из пака, то оно будет записывать только уникальные значения.

Для того, чтобы функция не перестала работать после первого вызова, от того, что на одинаковый ключ будет записано 2 значения, мы создаём структуру, которая будет хранить тег (оригинальный список типов) и собственно нужный нам индекс.

template 
struct GetUniqueKey {};

Далее нужно реализовать саму функцию, для этого в начале нам нужно добавить в глобальный стейт нужные нам значения:

   ([]{
      constexpr auto I = Counter, Ts>();
      std::ignore = Injector, I>{}, kTypeList>{};
    }(), ...);

Ну и затем получить пак индексов для нашего нового пака типов, размер которого мы получаем от Counter с тем же тегом, но без параметров в Ts, а они там всегда были, поэтому мы гарантируем, что это будет новый инстанс и счётчик инкрементируется, а потому мы можем просто взять значение счётчика.

return [](std::index_sequence) {
}(std::make_index_sequence>()>());

А затем мы просто читаем данные с помощью этого пака индексов, вот что получилось:

template 
consteval auto GetUnique(TypeList) {
  ([]{
    constexpr auto I = Counter, Ts>();
    std::ignore = Injector, I>{}, TypeList{}>{};
  }(), ...);
  return [](std::index_sequence) {
    return TypeList, Is>{}>{}))::Type...>{};
  }(std::make_index_sequence>()>());
};

Интроспекция тел функций

Мотивация

Такое может пригодится при использовании паттерна Service Locator в Dependency Injection. С помощью такого можно определять зависимости классов, что пригодится для раннего диагностирования кольцевых зависимостей, применения топологической сорировки, или же при реализации параллельной инициализации компонентов.

В случае с использованием Stackfull корутин, можно легко подождать инициализации зависимого класса прямо в методе GetComponent, но со Stackless из C++20, конструктор не может быть корутиной и приходится ждать заранее, но на тот момент нам были неизвестны зависимости класса.

Решить это можно следующими путями:

• Использовать кодогенерацию и парсеры C++(LLVM), но есть минусы:
  — Усложняется сборка
  — Сложно реализовывать, если в команде нет людей, что работали с этими вещами

• Не интроспектировать и вынести информацию из тела

Но с лупхолами есть ещё один способ, хоть и ограниченный. Про ограничения:

• Всё что можно интроспектировать должно использовать входные шаблонные параметры и чтобы от них зависило, какая функция будет вызвана (ADL, методы)

• Функция должна быть объявлена как constexpr (При этом мочь обязательно выполниться в constexpr не обязательно)

• Можно инстроспектировать только то, что работает через шаблоны

Вот пример как это будет работать с лупхолами:

struct SomeImplA {
  template 
  auto Method(Args...) {}; // Интерфейс
};

struct Foo {
  constexpr Foo(auto& a) {
    a.template Method(42);
    std::println("");
  };
};

static_assert((Inject(), 1));

static_assert(std::same_as()), TypeList>);

static_assert(std::same_as()), TypeList>>);

Вот что получится с Foo, если не использовать лупхолы, а вынести из класса:

struct Foo {
  static constexpr auto kMethodData = kTypeList>;
  constexpr Foo(auto& a) {
    a.template Method(42);
    std::println("");
  };
};

Минусы такого подхода очевидны: очень легок ошибиться. Человек может добавить вызов в конструктор, забыв про kMethodData. Проверка же подобного будет только на рантайме, а об ошибках хотелось бы знать до запуска рантайма. Это лишний бойлерплейт, чего можно избежать.

Как это работает

Работает оно следующим образом: мы подменяем то что ожидала получить функция своим объектом. Этот объект будет записывать информацию, которая появляется при вызове метода (T и Args…), чтобы затем её считать и выцепить из неё нужное.

Для того чтобы сохранять информацию, нам понадобится ключ, с помощью которого мы будем сохранять значения

template 
struct InfoKey {};

Затем реализация самого класса, который будет отвечать за отправку данных в глобальное состояние. Благодаря лямбде и той её особенности, что её тип всегда уникален, можно сделать, чтобы оно записывало даже тогда, когда типы не уникальны.

Тут мы читаем эти T и Args…, а затем через счётчик смотрим, сколько данных уже было записано и куда нужно записать следующие, для этого мы передаём его тип (как тег) и считанные данные, чтобы было новое инстанцирование. А затем на это место через InfoKey мы записываем объединённые данные в виде T и Args… как список типов.

template 
struct InfoInjector;

template 
struct InfoInjector {
  template <
    typename T,
    typename... Args,
    std::size_t I = Counter(),     //                T, Args... должно быть 
    auto = Injector{}, kTypeList>{}  //  уникально, иначе не запишет
  >
  static auto Method(Args...) -> void;
};

template 
struct InfoInjector {
  template <
    typename T,
    typename... Args,
    auto f = []{},
    std::size_t I = Counter(), 
    auto = Injector{}, kTypeList>{}  // запишет всё
  >
  static auto Method(Args...) -> void;
};

Затем нам нужно собственно инстанцировать конструктор с нашим объектом, который запишет информацию

template 
inline constexpr auto Use() {
  std::ignore = T{Args...};
};

template 
consteval auto Ignore() {};

template 
consteval auto Inject() {
  Ignore{}>)>();
};

После того как мы добавили информацию в глобальное состояние, нам нужно его прочитать, читаем T, а для этого мы создаём пак из индексов, которые соответсвуют тем, которые использовались для записи данных, кол-во их мы получаем через Counter с тегом. Это значение, которое мы тут получили, будет такое же и в другой функции, вне зависимости от порядка вызова

  [](std::index_sequence){
  }(std::make_index_sequence()>());

Далее же нам остаётся просто получить данные из глобального состояния, а затем достать первый элемент из тайплиста, т.к. именно он отвечает за нужный нам T.

template 
consteval auto GetTFromMethod() {
  return [](std::index_sequence){
     return kTypeList(Magic(Getter{}>{})))...>;
  }(std::make_index_sequence()>());
};

Принцип работы GetArgsFromMethod аналогичен, только он берёт не T, а то, что отвечает за Args — всё что после T, для этого мы выкидываем T и берём всё остальное.

template 
consteval auto DropHead(TypeList) -> TypeList {
  return {};
};

template 
consteval auto GetArgsFromMethod() {
  return [](std::index_sequence) {
    return TypeList{}>{})))...>{};
  }(std::make_index_sequence()>());
};

Что получилось

#include 

template 
struct TypeList {};

template 
inline constexpr TypeList kTypeList;

namespace impl {

template 
struct IndexedType {};

template 
struct Caster {};

template 
struct Caster, Ts...> : IndexedType... {};



} // namespace impl

template 
consteval auto Get(TypeList) -> decltype(
  [](impl::IndexedType&&) -> T {
}(impl::Caster, Ts...>{}));


template 
struct Getter {
  friend constexpr auto Magic(Getter);
};

template 
struct Injector {
  friend constexpr auto Magic(Getter) {return Value;};
};

template 
struct TagWithValue {};

template 
consteval auto CounterImpl() -> std::size_t {
  if constexpr(requires{Magic(Getter{}>{});}) {
    return CounterImpl();
  };
  return (std::ignore = Injector{}, 0>{}, I);
};

template ()>
consteval auto Counter() -> std::size_t {
  return R;
};

template 
inline constexpr auto Use() {
  std::ignore = T{Args...};
};

template 
consteval auto Ignore() {};

template 
struct InfoKey {};


template 
struct InfoInjector;

template 
struct InfoInjector {
  template <
    typename T,
    typename... Args,
    std::size_t I = Counter(),     //                T, Args... должно быть 
    auto = Injector{}, kTypeList>{}  //  уникально, иначе не запишет
  >
  static auto Method(Args...) -> void;
};

template 
struct InfoInjector {
  template <
    typename T,
    typename... Args,
    auto f = []{},
    std::size_t I = Counter(), 
    auto = Injector{}, kTypeList>{}  // запишет всё
  >
  static auto Method(Args...) -> void;
};

template 
consteval auto Inject() {
  Ignore{}>)>();
};

template 
consteval auto GetTFromMethod() {
  return [](std::index_sequence){
     return TypeList(Magic(Getter{}>{})))...>{};
  }(std::make_index_sequence()>());
};

template 
consteval auto DropHead(TypeList) -> TypeList {
  return {};
};

template 
consteval auto GetArgsFromMethod() {
  return [](std::index_sequence) {
    return TypeList{}>{})))...>{};
  }(std::make_index_sequence()>());
};

constexpr auto array = std::array{kTypeId, kTypeId} | std::views::reverse;

static_assert(std::is_same_v, void>);

struct Types {};


template 
struct MetaInfoKey {};


template 
struct MetaInfo {
  static constexpr std::size_t kTypeId = Counter();
  using Type = T;
private: 
  static constexpr auto _ = Injector{}, TypeList{}>{};
};

template 
inline constexpr std::size_t kTypeId = MetaInfo::kTypeId;

template 
using GetMetaInfo = MetaInfo{}>{}))::Type>;

template 
using GetType = GetMetaInfo::Type;

#include 

template 
struct TypeList {};

template 
struct TypeList {
  using Type = T;
};

template 
struct Getter {
  friend constexpr auto Magic(Getter);
};

template 
struct Injector {
  friend constexpr auto Magic(Getter) {return Value;};
};

template 
struct TagWithValue {};

template 
consteval auto CounterImpl() -> std::size_t {
  if constexpr(requires{Magic(Getter{}>{});}) {
    return CounterImpl();
  };
  return (std::ignore = Injector{}, 0>{}, I);
};

template ()>
consteval auto Counter() -> std::size_t {
  return R;
};

struct Types {};


template 
struct MetaInfoKey {};


template 
struct MetaInfo {
  static constexpr std::size_t kTypeId = Counter();
  using Type = T;
private: 
  static constexpr auto _ = Injector{}, TypeList{}>{};
};

template 
inline constexpr std::size_t kTypeId = MetaInfo::kTypeId;

template 
using GetMetaInfo = MetaInfo{}>{}))::Type>;

template 
using GetType = GetMetaInfo::Type;