schema_blob.hpp

Go to the documentation of this file.

#pragma once

 
#include <cstddef>
#include <cstdint>
#include <optional>
#include <span>
#include <string>
#include <string_view>
 
#include <wowlib/core/client_version.hpp>
#include <wowlib/db/schema.hpp>
 
namespace wowlib::db::blob {
  inline constexpr std::uint32_t Magic = 0x53424457u;
  inline constexpr std::uint32_t FormatVersion = 2;

  inline constexpr std::size_t HeaderBytes = 28;
  inline constexpr std::size_t EraBytes = 12;
  inline constexpr std::size_t TableBytes = 16;
  inline constexpr std::size_t RangeBytes = 8;
  inline constexpr std::size_t ColumnBytes = 16;

  struct TableEntry {
    std::uint32_t nameOff = 0; 
    std::uint32_t diskNameOff = 0; 
    std::uint32_t firstRange = 0; 
    std::uint32_t rangeCount = 0; 
  };

  struct RangeEntry {
    std::uint32_t firstColumn = 0; 
    std::uint16_t columnCount = 0; 
    std::uint16_t eraMask = 0; 
  };

  struct ColumnEntry {
    std::uint32_t nameOff = 0; 
    std::uint32_t dbdNameOff = 0; 
    ColumnType type = ColumnType::Int; 
    std::uint8_t bits = 0; 
    bool isSigned = false; 
    bool isId = false; 
    bool isRelation = false; 
    bool noninline = false; 
    std::uint8_t localeCount = 0; 
    std::uint16_t arrayLen = 1; 
  };

  class View {
  public:
    explicit constexpr View(std::span<const unsigned char> bytes) : _bytes{bytes} {}

    constexpr bool valid() const {
      if (_bytes.size() < HeaderBytes || _u32(0) != Magic || _u32(4) != FormatVersion) return false;
      const std::size_t need = HeaderBytes + eraCount() * EraBytes + tableCount() * TableBytes + rangeCount() *
        RangeBytes + columnCount() * ColumnBytes + strpoolSize();
      if (_bytes.size() != need || strpoolSize() == 0) return false;
      // The pool must end in a terminator or stringAt would run off the end.
      return _bytes[_bytes.size() - 1] == 0u;
    }

    constexpr std::size_t eraCount() const { return _bytes[24]; }
    constexpr std::size_t tableCount() const { return _u32(8); }
    constexpr std::size_t rangeCount() const { return _u32(12); }
    constexpr std::size_t columnCount() const { return _u32(16); }
    constexpr std::size_t strpoolSize() const { return _u32(20); }

    constexpr ClientVersion era(std::size_t i) const {
      const std::size_t at = HeaderBytes + i * EraBytes;
      return ClientVersion{_u16(at), _u16(at + 2), _u16(at + 4), _u32(at + 8)};
    }

    constexpr TableEntry table(std::size_t i) const {
      const std::size_t at = _tablesOff() + i * TableBytes;
      return TableEntry{_u32(at), _u32(at + 4), _u32(at + 8), _u32(at + 12)};
    }

    constexpr RangeEntry range(std::size_t i) const {
      const std::size_t at = _rangesOff() + i * RangeBytes;
      return RangeEntry{_u32(at), _u16(at + 4), _u16(at + 6)};
    }

    constexpr ColumnEntry column(std::size_t i) const {
      const std::size_t at = _columnsOff() + i * ColumnBytes;
      const std::uint8_t flags = _bytes[at + 6];
      ColumnEntry out{};
      out.nameOff = _u32(at);
      out.type = static_cast<ColumnType>(_bytes[at + 4]);
      out.bits = _bytes[at + 5];
      out.isSigned = (flags & 1u) != 0;
      out.isId = (flags & 2u) != 0;
      out.isRelation = (flags & 4u) != 0;
      out.noninline = (flags & 8u) != 0;
      out.localeCount = _bytes[at + 7];
      out.arrayLen = _u16(at + 8);
      out.dbdNameOff = _u32(at + 12);
      return out;
    }

    std::string_view stringAt(std::uint32_t off) const {
      const char* base = reinterpret_cast<const char*>(_bytes.data()) + _strpoolOff() + off;
      return std::string_view{base};
    }

    constexpr std::string copyStringAt(std::uint32_t off) const {
      std::string out{};
      for (std::size_t at = _strpoolOff() + off; _bytes[at] != 0u; ++at) out += static_cast<char>(_bytes[at]);
      return out;
    }

    constexpr std::optional<std::size_t>
    findTable(std::string_view name) const {
      std::size_t lo = 0;
      std::size_t hi = tableCount();
      while (lo < hi) {
        const std::size_t mid = lo + (hi - lo) / 2;
        const int cmp = _comparePool(table(mid).nameOff, name);
        if (cmp == 0) return mid;
        if (cmp < 0) lo = mid + 1;
        else hi = mid;
      }
      return std::nullopt;
    }

    constexpr std::span<const unsigned char> bytes() const { return _bytes; }
 
  private:
    constexpr std::uint16_t _u16(std::size_t at) const {
      return static_cast<std::uint16_t>(_bytes[at] | (std::uint16_t{_bytes[at + 1]} << 8));
    }

    constexpr std::uint32_t _u32(std::size_t at) const {
      return _bytes[at] | (std::uint32_t{_bytes[at + 1]} << 8) | (std::uint32_t{_bytes[at + 2]} << 16) | (std::uint32_t{
        _bytes[at + 3]
      } << 24);
    }

    constexpr std::size_t _tablesOff() const {
      return HeaderBytes + eraCount() * EraBytes;
    }
 
    constexpr std::size_t _rangesOff() const {
      return _tablesOff() + tableCount() * TableBytes;
    }
 
    constexpr std::size_t _columnsOff() const {
      return _rangesOff() + rangeCount() * RangeBytes;
    }
 
    constexpr std::size_t _strpoolOff() const {
      return _columnsOff() + columnCount() * ColumnBytes;
    }

    constexpr int _comparePool(std::uint32_t off, std::string_view name) const {
      std::size_t at = _strpoolOff() + off;
      for (const char c : name) {
        const unsigned char p = _bytes[at];
        if (p == 0u || p < static_cast<unsigned char>(c)) return -1;
        if (p > static_cast<unsigned char>(c)) return 1;
        ++at;
      }
      return _bytes[at] == 0u ? 0 : 1;
    }
 
    std::span<const unsigned char> _bytes; 
  };
}