record_bridge.hpp

Go to the documentation of this file.

#pragma once

 
#include <array>
#include <cstddef>
#include <cstdint>
#include <span>
#include <string>
#include <string_view>
#include <type_traits>
#include <vector>
 
#include <meta>
 
#include <wowlib/db/codec.hpp>
#include <wowlib/db/schema.hpp>
 
namespace wowlib::db {
  namespace detail {
    enum class AccessKind : std::uint8_t {
      I8,
      U8,
      I16,
      U16,
      I32,
      U32,
      I64,
      U64, 
      F32, 
      Str, 
      LocStr 
    };

    struct ColumnAccess {
      std::uint32_t offset = 0; 
      std::uint32_t flagsOffset = 0; 
      std::uint16_t elemStride = 0; 
      AccessKind kind = AccessKind::U32; 
    };

    template <typename E>
    consteval AccessKind accessKindOf() {
      if constexpr (std::same_as<E, float>) return AccessKind::F32;
      else if constexpr (std::same_as<E, std::string>) return AccessKind::Str;
      else if constexpr (std::signed_integral<E>) {
        switch (sizeof(E)) {
        case 1: return AccessKind::I8;
        case 2: return AccessKind::I16;
        case 4: return AccessKind::I32;
        default: return AccessKind::I64;
        }
      }
      else {
        switch (sizeof(E)) {
        case 1: return AccessKind::U8;
        case 2: return AccessKind::U16;
        case 4: return AccessKind::U32;
        default: return AccessKind::U64;
        }
      }
    }

    template <typename Struct>
    consteval std::uint32_t memberOffset(std::string_view name) {
      for (auto m : std::meta::nonstatic_data_members_of(^^Struct, std::meta::access_context::unchecked()))
        if (std::meta::identifier_of(m) == name) return static_cast<std::uint32_t>(std::meta::offset_of(m).bytes);
      return 0;
    }

    template <typename Record>
    consteval auto columnAccessOf() {
      std::vector<ColumnAccess> out;
      static constexpr auto Members = recordMembers<Record>();
      template for (constexpr auto m : Members) {
        using M = [:std::meta::type_of(m):];
        using E = typename ElementTraits<M>::Element;
        ColumnAccess a{};
        a.offset = static_cast<std::uint32_t>(std::meta::offset_of(m).bytes);
        if constexpr (LocstringTraits<M>::Value) {
          a.kind = AccessKind::LocStr;
          a.elemStride = sizeof(std::string);
          a.flagsOffset = a.offset + memberOffset<M>("flags");
        }
        else {
          a.kind = accessKindOf<E>();
          a.elemStride = sizeof(E);
        }
        out.push_back(a);
      }
      return std::define_static_array(out);
    }

    struct RecordOps {
      std::span<const ColumnAccess> columns; 
      std::size_t idColumn = SIZE_MAX; 
 
      void (*clear)(void*) = nullptr;
      void (*reserve)(void*, std::size_t) = nullptr;
      std::size_t (*add)(void*) = nullptr; 
      std::size_t (*size)(const void*) = nullptr;
      std::byte* (*at)(void*, std::size_t) = nullptr; 
      const std::byte* (*cat)(const void*, std::size_t) = nullptr;
      void (*clonePush)(void*, std::size_t) = nullptr; 
      // The three below serve the binding-side live record views (a mutable
      // sequence over the typed vector, erased the same way the sink is).
      void (*pushCopy)(void*, const void*) = nullptr; 
      void (*assignAt)(void*, std::size_t, const void*) = nullptr; 
      void (*eraseAt)(void*, std::size_t) = nullptr; 
    };

    template <typename Record>
    consteval std::size_t idColumnOf() {
      std::size_t i = 0;
      for (const Column& col : schemaOf<Record>()) {
        if (col.isId) return i;
        ++i;
      }
      return SIZE_MAX;
    }

    template <typename Record>
    inline constexpr RecordOps RecordOpsFor{
      columnAccessOf<Record>(),
      idColumnOf<Record>(),
      [](void* v) { static_cast<std::vector<Record>*>(v)->clear(); },
      [](void* v, std::size_t n) {
        static_cast<std::vector<Record>*>(v)->reserve(n);
      },
      [](void* v) {
        auto& vec = *static_cast<std::vector<Record>*>(v);
        vec.emplace_back();
        return vec.size() - 1;
      },
      [](const void* v) {
        return static_cast<const std::vector<Record>*>(v)->size();
      },
      [](void* v, std::size_t i) {
        return reinterpret_cast<std::byte*>(&(*static_cast<std::vector<Record>*>(v))[i]);
      },
      [](const void* v, std::size_t i) {
        return reinterpret_cast<const std::byte*>(&(*static_cast<const std::vector<Record>*>(v))[i]);
      },
      [](void* v, std::size_t src) {
        auto& vec = *static_cast<std::vector<Record>*>(v);
        vec.push_back(vec[src]);
      },
      [](void* v, const void* src) {
        static_cast<std::vector<Record>*>(v)->push_back(*static_cast<const Record*>(src));
      },
      [](void* v, std::size_t i, const void* src) {
        (*static_cast<std::vector<Record>*>(v))[i] = *static_cast<const Record*>(src);
      },
      [](void* v, std::size_t i) {
        auto& vec = *static_cast<std::vector<Record>*>(v);
        vec.erase(vec.begin() + static_cast<std::ptrdiff_t>(i));
      }
    };
  }

  class ErasedRecordSink final : public RecordSink {
  public:
    template <typename Record>
    explicit ErasedRecordSink(std::vector<Record>& records)
      : _vec{&records}, _ops{&detail::RecordOpsFor<Record>} {}

    ErasedRecordSink(void* recordsVec, const detail::RecordOps* ops)
      : _vec{recordsVec}, _ops{ops} {}
 
    void clear() override;
    void reserve(std::size_t n) override;
    std::size_t add() override;
    std::size_t size() const override;
    std::uint32_t idOf(std::size_t record) const override;
 
    void setInt(std::size_t record, std::size_t column, std::size_t element, std::int64_t value) override;
    void setFloat(std::size_t record, std::size_t column, std::size_t element, float value) override;
    void setString(std::size_t record, std::size_t column, std::size_t element, std::string_view value) override;
 
    void cloneWithId(std::size_t src, std::uint32_t newId) override;
    std::size_t findById(std::uint32_t id) const override;
 
  private:
    void* _vec;
    const detail::RecordOps* _ops;
  };

  class ErasedRecordSource final : public RecordSource {
  public:
    template <typename Record>
    explicit ErasedRecordSource(const std::vector<Record>& records)
      : _vec{&records}, _ops{&detail::RecordOpsFor<Record>} {}

    ErasedRecordSource(const void* recordsVec, const detail::RecordOps* ops)
      : _vec{recordsVec}, _ops{ops} {}
 
    std::size_t size() const override;
    std::uint32_t idOf(std::size_t record) const override;
 
    std::int64_t getInt(std::size_t record, std::size_t column, std::size_t element) const override;
    std::uint32_t getSlot(std::size_t record, std::size_t column, std::size_t element) const override;
    std::string_view getString(std::size_t record, std::size_t column, std::size_t element) const override;
 
  private:
    const void* _vec;
    const detail::RecordOps* _ops;
  };
}