schema.hpp

Go to the documentation of this file.

#pragma once

 
#include <meta>
 
#include <algorithm>
#include <array>
#include <ranges>
#include <span>
#include <concepts>
#include <cstddef>
#include <cstdint>
#include <optional>
#include <string>
#include <string_view>
#include <utility>
#include <type_traits>
#include <vector>
 
#include <wowlib/core/client_version.hpp>
#include <wowlib/db/annotations.hpp>
#include <wowlib/db/locstring.hpp>
 
namespace wowlib::db {
  enum class [[
      =welder::weld,
      =welder::doc("The logical value class of a table column.")
    ]] ColumnType : std::uint8_t {
    Int, 
    Float, 
    String, 
    LocString 
  };

      view of the world, not the expanded on-disk field list. */
  struct [[
      =welder::weld,
      =welder::doc("One column of a table schema: its name, value class, "
        "integer shape, array length and key roles.")
    ]] Column {
    [[=welder::mark::no_reassign,
      =welder::doc("The column name: the snake_case spelling of the WoWDBDefs "
        "column ('MapName' -> 'map_name'). This spelling is a stable "
        "cross-release contract on every binding surface.")]]
    const char* name = nullptr; 
    [[=welder::mark::no_reassign,
      =welder::doc("The verbatim WoWDBDefs spelling of the column "
        "('MapName_lang'); column_index accepts it as an alias. Empty for "
        "columns without a DBD identity (reflection-derived schemas).")]]
    // nullptr, not "": schemaOf's columns live in reflect_constant, where a
    // pointer into a string literal is not a usable constant.
    const char* dbdName = nullptr; 
    [[=welder::doc("The logical value class.")]]
    ColumnType type = ColumnType::Int;
    [[=welder::doc("Integer element width in bits; 32 for float/string refs.")]]
    std::uint8_t bits = 0;
    [[=welder::doc("Integer signedness; false for non-Int columns.")]]
    bool isSigned = false;
    [[=welder::doc("Element count; 1 for scalar columns.")]]
    std::uint16_t arrayLen = 1;
    [[=welder::doc("LocString language slots (8 or 16); 0 otherwise.")]]
    std::uint8_t localeCount = 0;
    [[=welder::doc("Whether this is the table's primary key ($id$).")]]
    bool isId = false;
    [[=welder::doc("Whether this is a relationship key ($relation$).")]]
    bool isRelation = false;
    [[=welder::doc("Whether the column holds no bytes inside the record "
      "image ($noninline$).")]]
    bool noninline = false;

        would otherwise synthesize a field-wise constructor, and its
        `const char* name` parameter would store a pointer into the
        marshalling temporary — Column is read-only schema metadata, never
        constructed from a bound language. */
    Column() = default;

        @return the interned column name. */
    constexpr std::string_view nameView() const { return name; }

    constexpr std::string_view dbdNameView() const {
      return dbdName ? std::string_view{dbdName} : std::string_view{};
    }


    constexpr std::size_t inlineBytes() const {
      if (noninline) return 0;
      switch (type) {
      case ColumnType::Int: return static_cast<std::size_t>(bits) / 8 * arrayLen;
      case ColumnType::Float:
      case ColumnType::String: return std::size_t{4} * arrayLen;
      case ColumnType::LocString: return (static_cast<std::size_t>(localeCount) + 1) * 4;
      }
      return 0;
    }

        language slot plus the flags field, noninline columns count zero.
        @return the field slot count. */
    constexpr std::uint32_t fieldSlots() const {
      if (noninline) return 0;
      if (type == ColumnType::LocString) return static_cast<std::uint32_t>(localeCount) + 1;
      return arrayLen;
    }

                count; 0 otherwise. */
    constexpr std::size_t stringSlots() const {
      if (noninline) return 0;
      if (type == ColumnType::String) return arrayLen;
      if (type == ColumnType::LocString) return localeCount;
      return 0;
    }
  };
 
  namespace detail {
    template <typename T>
    struct LocstringTraits {
      static constexpr bool Value = false;
    };
 
    template <std::size_t N>
    struct LocstringTraits<LocString<N>> {
      static constexpr bool Value = true;
      static constexpr std::size_t Langs = N;
    };

    template <typename T>
    struct ElementTraits {
      using Element = T;
      static constexpr std::size_t Extent = 1;
      static constexpr bool IsArray = false;
    };
 
    template <typename T, std::size_t N>
    struct ElementTraits<std::array<T, N>> {
      using Element = T;
      static constexpr std::size_t Extent = N;
      static constexpr bool IsArray = true;
    };

        @return true when all bytes are zero. */
    inline bool allZero(std::span<const std::byte> bytes) {
      return std::ranges::all_of(bytes, [](std::byte b) {
        return b == std::byte{0};
      });
    }

    template <typename Spec, std::meta::info M>
    consteval std::optional<Spec> annotation() {
      auto anns = std::meta::annotations_of_with_type(M, ^^Spec);
      if (anns.empty()) return std::nullopt;
      return std::meta::extract<Spec>(anns[0]);
    }

    template <typename Member>
    consteval Column classifyMember() {
      using Elem = typename ElementTraits<Member>::Element;
      Column col{};
      col.arrayLen = static_cast<std::uint16_t>(ElementTraits<Member>::Extent);
      if constexpr (LocstringTraits<Member>::Value) {
        col.type = ColumnType::LocString;
        col.bits = 32;
        col.localeCount = static_cast<std::uint8_t>(LocstringTraits<Member>::Langs);
      }
      else if constexpr (std::same_as<Elem, std::string>) {
        col.type = ColumnType::String;
        col.bits = 32;
      }
      else if constexpr (std::same_as<Elem, float>) {
        col.type = ColumnType::Float;
        col.bits = 32;
      }
      else if constexpr (std::integral<Elem> && !std::same_as<Elem, bool>) {
        col.type = ColumnType::Int;
        col.bits = static_cast<std::uint8_t>(sizeof(Elem) * 8);
        col.isSigned = std::is_signed_v<Elem>;
      }
      else static_assert(false, "unsupported record column type");
      return col;
    }

    template <typename Record>
    consteval auto recordMembers() {
      std::vector<std::meta::info> out;
      for (auto m : std::meta::nonstatic_data_members_of(^^Record, std::meta::access_context::unchecked())) out.
        push_back(m);
      return std::define_static_array(out);
    }
  }

  template <typename Record>
  consteval auto schemaOf() {
    std::vector<Column> cols;
    static constexpr auto Members = detail::recordMembers<Record>();
    template for (constexpr auto m : Members) {
      using M = [:std::meta::type_of(m):];
      Column col = detail::classifyMember<M>();
      col.name = std::define_static_string(std::meta::identifier_of(m));
      col.isId = detail::annotation<detail::IdSpec, m>().has_value();
      col.isRelation = detail::annotation<detail::RelationSpec, m>().has_value();
      col.noninline = detail::annotation<detail::NoninlineSpec, m>().has_value();
      cols.push_back(col);
    }
    return std::define_static_array(cols);
  }

  template <typename Record>
  consteval std::size_t recordStride() {
    std::size_t bytes = 0;
    for (const Column& col : schemaOf<Record>()) bytes += col.inlineBytes();
    return bytes;
  }

  template <typename Record>
  consteval std::uint32_t fieldSlotCount() {
    std::uint32_t slots = 0;
    for (const Column& col : schemaOf<Record>()) slots += col.fieldSlots();
    return slots;
  }

      the engine's per-record original-offset journal.
      @tparam Record the record type.
      @return the per-record string slot count. */
  template <typename Record>
  consteval std::size_t stringSlotCount() {
    std::size_t slots = 0;
    for (const Column& col : schemaOf<Record>()) slots += col.stringSlots();
    return slots;
  }

  template <typename R> concept TableRecord = std::is_class_v<R> && std::default_initializable<R> && requires {
    { R::Version } -> std::convertible_to<ClientVersion>; { std::string_view{R::TableName} };
  };
}