typed.hpp

Go to the documentation of this file.

#pragma once

 
#include <algorithm>
#include <bit>
#include <cstddef>
#include <cstdint>
#include <meta>
#include <span>
#include <string>
#include <string_view>
#include <type_traits>
#include <vector>
 
#include <wowlib/core/error.hpp>
#include <wowlib/db/dyn_table.hpp>
#include <wowlib/db/record_bridge.hpp>
#include <wowlib/db/schema.hpp>
#include <wowlib/db/schema_blob.hpp>
 
#if !defined(WOWLIB_DB_SCHEMA_EMBEDDED) || !WOWLIB_DB_SCHEMA_EMBEDDED
#error "wowlib/db/typed.hpp needs the embedded schema blob \
(WOWLIB_DB_SCHEMA=embedded|both): the consteval validation reads it"
#endif
 
namespace wowlib::db {
  namespace detail {
    inline constexpr unsigned char TypedSchemaBlob[] = {
#embed <wowlib_schema.wdbs>
    };

    struct TypedMismatch {
      const char* message;
    };

    consteval blob::RangeEntry typedRangeOf(std::string_view table, ClientVersion version) {
      const blob::View view{std::span<const unsigned char>{TypedSchemaBlob}};
      const auto at = view.findTable(table);
      if (!at) throw TypedMismatch{"the schema blob knows no table of this name"};
      std::size_t era = SIZE_MAX;
      for (std::size_t i = 0; i < view.eraCount(); ++i)
        if (view.era(i).major == version.major) era = i;
      if (era == SIZE_MAX)
        throw TypedMismatch{"no targeted era shares the struct's major version"};
      const blob::TableEntry entry = view.table(*at);
      for (std::size_t r = 0; r < entry.rangeCount; ++r) {
        const blob::RangeEntry range = view.range(entry.firstRange + r);
        if (range.eraMask & (std::uint16_t{1} << era)) return range;
      }
      throw TypedMismatch{"the table has no schema range covering the struct's era"};
    }

    consteval std::size_t typedColumnIndex(std::string_view table, ClientVersion version, std::string_view name) {
      const blob::View view{std::span<const unsigned char>{TypedSchemaBlob}};
      const blob::RangeEntry range = typedRangeOf(table, version);
      for (std::size_t c = 0; c < range.columnCount; ++c)
        if (view.copyStringAt(view.column(range.firstColumn + c).nameOff) == name) return c;
      throw TypedMismatch{"the era's schema has no column with this member's name"};
    }

    template <typename Record>
    consteval bool typedValidate() {
      const blob::View view{std::span<const unsigned char>{TypedSchemaBlob}};
      const blob::RangeEntry range = typedRangeOf(Record::TableName, Record::Version);
      for (const Column& member : schemaOf<Record>()) {
        const std::size_t at = typedColumnIndex(Record::TableName, Record::Version, member.nameView());
        const blob::ColumnEntry col = view.column(range.firstColumn + at);
        if (col.type != member.type)
          throw TypedMismatch{
            "the member's value class (Int/Float/String/" "LocString) differs from the DBD column's"
          };
        if (member.type == ColumnType::Int && (col.bits != member.bits || col.isSigned != member.isSigned))
          throw TypedMismatch{"the member's integer width or signedness " "differs from the DBD column's"};
        if (col.arrayLen != member.arrayLen)
          throw TypedMismatch{"the member's array length differs from the DBD column's"};
        if (member.type == ColumnType::LocString && col.localeCount != member.localeCount)
          throw TypedMismatch{"the member's LocString locale count differs " "from the DBD column's (wrong era?)"};
      }
      return true;
    }

    template <typename Record>
    consteval auto typedProjection() {
      std::vector<std::size_t> map;
      for (const Column& member : schemaOf<Record>())
        map.push_back(typedColumnIndex(Record::TableName, Record::Version, member.nameView()));
      return std::define_static_array(map);
    }

    template <std::size_t N>
    struct FixedString {
      char text[N] = {};
      consteval FixedString(const char (&s)[N]) { std::copy_n(s, N, text); }
      consteval std::string_view view() const { return {text, N - 1}; }
    };
  }

  template <TableRecord Record>
  class TypedTable {
    static_assert(detail::typedValidate<Record>());
 
  public:
    static Result<TypedTable> open() {
      return DynTable::open(Record::TableName, Record::Version).transform([](DynTable&& table) {
        TypedTable out{};
        out._table = std::move(table);
        return out;
      });
    }

    DynTable& table() { return _table; }
    const DynTable& table() const { return _table; }

    Result<void> read(std::span<const std::byte> data) {
      return _table.read(data);
    }

    Result<FileBuffer> write(EncryptedPolicy policy = EncryptedPolicy::Preserve) const {
      return _table.write(policy);
    }

    std::vector<Record> load() const {
      std::vector < Record > out(_table.rowCount());
      ErasedRecordSink sink{out};
      static constexpr auto Schema = schemaOf<Record>();
      static constexpr auto Projection = detail::typedProjection<Record>();
      for (std::size_t r = 0; r < out.size(); ++r)
        for (std::size_t m = 0; m < Schema.size(); ++m) _copyCellIn(sink, r, m, Projection[m], Schema[m]);
      return out;
    }

    void writeBack(const std::vector<Record>& records) requires(schemaOf<Record>().size() == detail::typedRangeOf(
      Record::TableName, Record::Version).columnCount) {
      _table.clearRows();
      const ErasedRecordSource source{records};
      static constexpr auto Schema = schemaOf<Record>();
      static constexpr auto Projection = detail::typedProjection<Record>();
      for (std::size_t r = 0; r < records.size(); ++r) {
        _table.appendRow();
        for (std::size_t m = 0; m < Schema.size(); ++m) _copyCellOut(source, r, m, Projection[m], Schema[m]);
      }
    }

    template <detail::FixedString Name>
    auto column() const {
      static constexpr auto Members = detail::recordMembers<Record>();
      constexpr std::size_t index = []() consteval {
        for (std::size_t i = 0; i < Members.size(); ++i)
          if (std::meta::identifier_of(Members[i]) == Name.view()) return i;
        throw detail::TypedMismatch{"no member of this record has that name"};
      }();
      using F = [:std::meta::type_of(Members[index]):];
      static_assert(std::is_arithmetic_v<F> && !std::is_same_v<F, bool>,
                    "column<\"name\">() serves scalar arithmetic columns; "
                    "load() or the generic accessors cover the rest");
      static constexpr auto Projection = detail::typedProjection<Record>();
      const auto view = _table.podColumn(Projection[index]);
      // add_const_t, not `const F`: gcc-16 drops a bare const applied to a
      // dependent splice alias (the span would come out span<F>).
      using CF = std::add_const_t<F>;
      CF* data = reinterpret_cast<CF*>(view->bytes.data());
      const std::size_t count = view->bytes.size() / sizeof(F);
      return std::span<CF>(data, count);
    }
 
  private:
    TypedTable() = default;

    void _copyCellIn(ErasedRecordSink& sink,
                      std::size_t r,
                      std::size_t m,
                      std::size_t col,
                      const Column& shape) const {
      switch (shape.type) {
      case ColumnType::Int:
        for (std::size_t e = 0; e < shape.arrayLen; ++e) sink.setInt(r, m, e, _table.getInt(r, col, e).value());
        break;
      case ColumnType::Float:
        for (std::size_t e = 0; e < shape.arrayLen; ++e) sink.setFloat(r, m, e, _table.getFloat(r, col, e).value());
        break;
      case ColumnType::String:
        for (std::size_t e = 0; e < shape.arrayLen; ++e) sink.
          setString(r, m, e, _table.getString(r, col, e).value());
        break;
      case ColumnType::LocString:
        for (std::size_t e = 0; e < shape.localeCount; ++e) sink.setString(
          r, m, e, _table.getString(r, col, e).value());
        sink.setInt(r, m, 0, _table.locstringFlags(r, col).value());
        break;
      }
    }

    void _copyCellOut(const ErasedRecordSource& source,
                       std::size_t r,
                       std::size_t m,
                       std::size_t col,
                       const Column& shape) {
      switch (shape.type) {
      case ColumnType::Int:
        for (std::size_t e = 0; e < shape.arrayLen; ++e) _table.setInt(r, col, source.getInt(r, m, e), e).value();
        break;
      case ColumnType::Float:
        for (std::size_t e = 0; e < shape.arrayLen; ++e)
          _table.setFloat(r, col, std::bit_cast<float>(source.getSlot(r, m, e)), e).value();
        break;
      case ColumnType::String:
        for (std::size_t e = 0; e < shape.arrayLen; ++e) _table.setString(r, col, source.getString(r, m, e), e).
                                                                 value();
        break;
      case ColumnType::LocString:
        for (std::size_t e = 0; e < shape.localeCount; ++e) _table.setString(r, col, source.getString(r, m, e), e).
                                                                    value();
        _table.setLocstringFlags(r, col, static_cast<std::uint32_t>(source.getInt(r, m, 0))).value();
        break;
      }
    }
 
    DynTable _table{};
  };
}