静的リフレクション [P2996R13](C++26)

#include <meta>
#include <print>
#include <string>

struct Point {
  int x;
  int y;
  std::string name;
};

int main() {
  Point p{10, 20, "origin"};

  template for (constexpr auto m :
      std::define_static_array(std::meta::nonstatic_data_members_of(^^Point,
          std::meta::access_context::unchecked()))) {
    std::println("{}: {}", std::meta::identifier_of(m), p.[:m:]);
  }
}

#include <meta>
#include <print>
#include <string_view>
#include <type_traits>

enum class Color { red, green, blue };

template <typename E>
  requires std::is_enum_v<E>
constexpr std::string_view to_string(E value) {
  template for (constexpr auto e : std::define_static_array(std::meta::enumerators_of(^^E))) {
    if (value == [:e:]) {
      return std::meta::identifier_of(e);
    }
  }
  return "<unknown>";
}

int main() {
  std::println("{}", to_string(Color::red));
  std::println("{}", to_string(Color::green));
  std::println("{}", to_string(Color::blue));
}

#include <meta>
#include <print>

void process(int id, double value, const char* name) {}

int main() {
  template for (constexpr auto p : std::define_static_array(std::meta::parameters_of(^^process))) {
    std::println("パラメータ: {} (型: {})",
      std::meta::identifier_of(p),
      std::meta::display_string_of(std::meta::type_of(p)));
  }
}

#include <meta>
#include <functional>
#include <string>
#include <print>
#include <concepts>
#include <cstddef>

// std::hash<T>が使用可能かを判定するコンセプト
template <class T>
concept has_std_hash = requires(const T& x) {
  { std::hash<T>{}(x) } -> std::convertible_to<std::size_t>;
};

template <class T>
constexpr std::size_t hash_value(const T& obj) {
  if constexpr (has_std_hash<T>) {
    // std::hashが特殊化されていれば利用する
    return std::hash<T>{}(obj);
  } else {
    // 特殊化されていなければ、各メンバのハッシュ値を再帰的に計算してXORで合成
    std::size_t result = 0;
    template for (constexpr auto m :
        std::define_static_array(std::meta::nonstatic_data_members_of(^^T,
            std::meta::access_context::unchecked()))) {
      result ^= hash_value(obj.[:m:]);
    }
    return result;
  }
}

struct Inner {
  int a;
  std::string b;
};

struct Outer {
  int x;
  Inner inner;  // ネストしたクラス型も再帰的にハッシュ化される
};

int main() {
  Outer o1{10, {1, "hello"}};
  Outer o2{10, {1, "hello"}};
  Outer o3{10, {2, "hello"}};

  std::println("hash(o1) == hash(o2): {}", hash_value(o1) == hash_value(o2));
  std::println("hash(o1) == hash(o3): {}", hash_value(o1) == hash_value(o3));
}

#include <meta>
#include <cstdio>
#include <format>
#include <print>
#include <stdexcept>
#include <string_view>

// 値の範囲を表すアノテーションクラス
struct IntRange {
  int min_value;
  int max_value;
};

struct FloatRange {
  double min_value;
  double max_value;
};

struct Config {
  [[=IntRange{1, 65535}]] int port;
  [[=IntRange{1, 300}]] int timeout_seconds;
  [[=FloatRange{0.0, 1.0}]] double sampling_rate;
  int retry_count;  // アノテーションがないメンバ変数は検証しない
};

// IntRangeとFloatRangeのどちらにも使える検証処理
template <class R, class T>
void check_range(std::string_view name, T value, R range) {
  if (value < range.min_value || range.max_value < value) {
    throw std::out_of_range{
      std::format("{}: {}は{}以上{}以下でなければならない",
                  name,
                  value,
                  range.min_value,
                  range.max_value)};
  }
}

// 範囲のアノテーションが付加されたメンバ変数の値を検証する
template <class T>
void validate(const T& obj) {
  template for (constexpr auto m :
      std::define_static_array(std::meta::nonstatic_data_members_of(^^T,
          std::meta::access_context::unchecked()))) {
    static constexpr auto int_annotations = std::define_static_array(
      std::meta::annotations_of_with_type(m, ^^IntRange));
    static constexpr auto float_annotations = std::define_static_array(
      std::meta::annotations_of_with_type(m, ^^FloatRange));

    // アノテーションは値のリフレクションではないため、
    // constant_of()で値を取り出してからスプライスする
    if constexpr (int_annotations.size() > 0) {
      check_range(std::meta::identifier_of(m), obj.[:m:],
                  [:std::meta::constant_of(int_annotations[0]):]);
    }
    else if constexpr (float_annotations.size() > 0) {
      check_range(std::meta::identifier_of(m), obj.[:m:],
                  [:std::meta::constant_of(float_annotations[0]):]);
    }
  }
}

int main() {
  // すべて範囲内なので、例外は送出されない
  validate(Config{
    .port = 8080,
    .timeout_seconds = 30,
    .sampling_rate = 0.5,
    .retry_count = 3
  });

  try {
    // portが範囲外
    validate(Config{
      .port = 0,
      .timeout_seconds = 30,
      .sampling_rate = 0.5,
      .retry_count = 3
    });
  } catch (const std::out_of_range& e) {
    std::println(stderr, "{}", e.what());
  }

  try {
    // sampling_rateが範囲外
    validate(Config{
      .port = 8080,
      .timeout_seconds = 30,
      .sampling_rate = 1.5,
      .retry_count = 3
    });
  } catch (const std::out_of_range& e) {
    std::println(stderr, "{}", e.what());
  }
}

#include <meta>
#include <format>
#include <print>
#include <stdexcept>
#include <string>
#include <string_view>

// オプションの短縮名を表すアノテーション
struct Short {
  char name;
};

// オプションの説明を表すアノテーション
struct Help {
  const char* text;
};

struct Args {
  [[=Short{'n'}, =Help{std::define_static_string("挨拶する相手の名前")}]]
  std::string name;

  [[=Short{'c'}, =Help{std::define_static_string("挨拶を繰り返す回数")}]]
  int count = 1;
};

void assign(std::string& member, std::string_view value) {
  member = value;
}

void assign(int& member, std::string_view value) {
  member = std::stoi(std::string{value});
}

// アノテーションからヘルプメッセージを生成する
template <class T>
void print_help() {
  std::println("オプション:");
  template for (constexpr auto m :
      std::define_static_array(std::meta::nonstatic_data_members_of(^^T,
          std::meta::access_context::unchecked()))) {
    static constexpr auto shorts = std::define_static_array(
      std::meta::annotations_of_with_type(m, ^^Short));
    static constexpr auto helps = std::define_static_array(
      std::meta::annotations_of_with_type(m, ^^Help));

    std::println("  -{}, --{:<8} {}",
                 [:std::meta::constant_of(shorts[0]):].name,
                 std::meta::identifier_of(m),
                 [:std::meta::constant_of(helps[0]):].text);
  }
}

// アノテーションをもとにコマンドライン引数を解析する
template <class T>
T parse(int argc, const char* const* argv) {
  T args{};
  for (int i = 1; i < argc; ++i) {
    std::string_view arg = argv[i];
    bool matched = false;

    template for (constexpr auto m :
        std::define_static_array(std::meta::nonstatic_data_members_of(^^T,
            std::meta::access_context::unchecked()))) {
      static constexpr auto shorts = std::define_static_array(
        std::meta::annotations_of_with_type(m, ^^Short));
      constexpr std::string_view long_name = std::meta::identifier_of(m);
      constexpr char short_name = [:std::meta::constant_of(shorts[0]):].name;

      bool is_long = arg.starts_with("--") && arg.substr(2) == long_name;
      bool is_short = arg.size() == 2 && arg[0] == '-' && arg[1] == short_name;

      if (is_long || is_short) {
        if (++i == argc) {
          throw std::invalid_argument{std::format("{}: 値が指定されていない", arg)};
        }
        assign(args.[:m:], argv[i]);
        matched = true;
        break;
      }
    }

    if (!matched) {
      throw std::invalid_argument{std::format("{}: 不明なオプション", arg)};
    }
  }
  return args;
}

int main() {
  print_help<Args>();

  // コマンドライン引数を模したデータ
  const char* argv[] = {"greet", "--name", "wg21", "-c", "3"};
  Args args = parse<Args>(5, argv);

  for (int i = 0; i < args.count; ++i) {
    std::println("Hello {}", args.name);
  }
}

#include <meta>
#include <concepts>
#include <format>
#include <print>
#include <string>
#include <string_view>

// JSONのキー名を変更するアノテーション
struct Rename {
  const char* name;
};

// シリアライズの対象から外すアノテーション
struct Skip {};

struct Address {
  std::string city;
  int postal_code;
};

struct Person {
  [[=Rename{std::define_static_string("first name")}]] std::string first;
  [[=Rename{std::define_static_string("last name")}]] std::string last;
  int age;
  Address address;                    // ネストしたクラスも再帰的に変換される
  [[=Skip{}]] std::string password;   // シリアライズしない
};

template <class T>
std::string to_json(const T& value) {
  if constexpr (std::integral<T> || std::floating_point<T>) {
    return std::format("{}", value);
  }
  else if constexpr (std::convertible_to<T, std::string_view>) {
    return std::format("\"{}\"", value);
  }
  else {
    std::string result = "{";
    bool is_first = true;

    template for (constexpr auto m :
        std::define_static_array(std::meta::nonstatic_data_members_of(^^T,
            std::meta::access_context::unchecked()))) {
      static constexpr auto skips = std::define_static_array(
        std::meta::annotations_of_with_type(m, ^^Skip));

      if constexpr (skips.size() == 0) {
        static constexpr auto renames = std::define_static_array(
          std::meta::annotations_of_with_type(m, ^^Rename));

        // Renameアノテーションがあればその名前を、なければメンバ変数名をキーにする
        constexpr std::string_view key = [] {
          if constexpr (renames.size() > 0) {
            return std::string_view{[:std::meta::constant_of(renames[0]):].name};
          }
          else {
            return std::meta::identifier_of(m);
          }
        }();

        if (!is_first) {
          result += ',';
        }
        is_first = false;
        result += std::format("\"{}\":{}", key, to_json(value.[:m:]));
      }
    }
    return result + '}';
  }
}

int main() {
  Person person{
    .first = "Taro",
    .last = "Yamada",
    .age = 30,
    .address = {.city = "Tokyo", .postal_code = 1000001},
    .password = "secret"
  };

  std::println("{}", to_json(person));
}