codec.hpp

Go to the documentation of this file.

#pragma once

 
#include <cstddef>
#include <cstdint>
#include <span>
#include <string>
#include <string_view>
#include <vector>
 
#include <welder/vocabulary.hpp>
 
#include <wowlib/core/client_version.hpp>
#include <wowlib/db/schema.hpp>
#include <wowlib/formats/common/string_block.hpp>
 
namespace wowlib::db {
  enum class [[
      =welder::weld,
      =welder::doc(R"(
        How a client-database write handles keyless encrypted sections: Preserve
        re-emits the file's original bytes verbatim (encrypted content intact,
        edits to decoded rows NOT applied); Drop writes only the decoded rows as
        a plain unencrypted table, discarding the rows behind missing keys.)")
    ]] EncryptedPolicy {
    Preserve, 
    Drop 
  };

  struct [[
      =welder::weld,
      =welder::doc(
        "An encrypted WDC section: its records are behind a TACT key "
        "wowlib does not hold, so they are absent from records.")
    ]] EncryptedSection {
    [[=welder::doc(
      "The section's TACT key lookup hash (names the missing key).")]]
    std::uint64_t keyHash = 0;
 
    [[=welder::doc("How many records the encrypted section holds.")]]
    std::uint32_t recordCount = 0;
 
    [[=welder::doc(
      "The ids of the encrypted records, when the file lists them.")]]
    std::vector<std::uint32_t> ids;
  };

      (diagnostics), and the runtime schema. Every other derived quantity —
      record stride, field-slot count, inline column count, the id column's
      inline index / non-inline flag — the codecs compute from @ref schema. */
  struct TableInfo {
    ClientVersion version{}; 
    std::string_view name; 
    std::span<const Column> schema; 
  };

  struct TableState {
    std::uint32_t sourceMagic = 0; 
    std::uint32_t fieldCount = 0; 
    std::uint32_t recordSize = 0; 
    formats::StringBlock strings; 

    std::vector<std::uint32_t> stringOffsets;
 
    std::vector<std::byte> wdb2Header; 
    std::vector<std::byte> wdb2Index; 
    std::vector<std::byte> wdb2Copy; 
 
    std::vector<EncryptedSection> encrypted; 
    std::uint32_t wdcTableHash = 0; 
    std::uint32_t wdcLayoutHash = 0; 
    std::uint32_t wdcLocale = 0; 
    std::vector<std::byte> wdcOriginal; 
    std::vector<std::uint8_t> wdcKinds; 
    std::vector<std::byte> wdc5Prefix; 


    void reset() {
      strings = {};
      stringOffsets.clear();
      wdb2Header.clear();
      wdb2Index.clear();
      wdb2Copy.clear();
      encrypted.clear();
      wdcOriginal.clear();
      wdcKinds.clear();
      wdc5Prefix.clear();
    }
  };

  class RecordSink {
  public:
    virtual ~RecordSink() = default;
    virtual void clear() = 0;
    virtual void reserve(std::size_t n) = 0;
    virtual std::size_t add() = 0;
    virtual std::size_t size() const = 0;
    virtual std::uint32_t idOf(std::size_t record) const = 0;
    virtual void setInt(std::size_t record, std::size_t column, std::size_t element, std::int64_t value) = 0;
    virtual void setFloat(std::size_t record, std::size_t column, std::size_t element, float value) = 0;
    virtual void setString(std::size_t record, std::size_t column, std::size_t element, std::string_view value) = 0;
        (WDC copy-table materialization). */
    virtual void cloneWithId(std::size_t src, std::uint32_t newId) = 0;
    virtual std::size_t findById(std::uint32_t id) const = 0;
  };


      implements it over a const std::vector<Record>&. */
  class RecordSource {
  public:
    virtual ~RecordSource() = default;
    virtual std::size_t size() const = 0;
    virtual std::uint32_t idOf(std::size_t record) const = 0;
    virtual std::int64_t getInt(std::size_t record, std::size_t column, std::size_t element) const = 0;
    virtual std::uint32_t getSlot(std::size_t record, std::size_t column, std::size_t element) const = 0;
    virtual std::string_view getString(std::size_t record, std::size_t column, std::size_t element) const = 0;
  };
 
  namespace detail {

    inline std::size_t recordStride(std::span<const Column> schema) {
      std::size_t bytes = 0;
      for (const Column& col : schema) bytes += col.inlineBytes();
      return bytes;
    }


    inline std::uint32_t fieldSlotCount(std::span<const Column> schema) {
      std::uint32_t slots = 0;
      for (const Column& col : schema) slots += col.fieldSlots();
      return slots;
    }


    inline std::size_t stringSlotCount(std::span<const Column> schema) {
      std::size_t slots = 0;
      for (const Column& col : schema) slots += col.stringSlots();
      return slots;
    }


    inline std::size_t inlineColumnCount(std::span<const Column> schema) {
      std::size_t n = 0;
      for (const Column& col : schema) n += col.noninline ? 0 : 1;
      return n;
    }

    inline bool idIsNoninline(std::span<const Column> schema) {
      for (const Column& col : schema)
        if (col.isId) return col.noninline;
      return false;
    }

    inline std::uint16_t idFieldIndex(std::span<const Column> schema) {
      std::uint16_t idx = 0;
      for (const Column& col : schema) {
        if (col.noninline) continue;
        if (col.isId) return idx;
        ++idx;
      }
      return 0;
    }
  }
}