KV1Binary.h

Go to the documentation of this file.

#pragma once
 
#include <concepts>
#include <filesystem>
#include <optional>
#include <span>
#include <string>
#include <string_view>
#include <variant>
#include <vector>
 
namespace kvpp {
 
enum class KV1BinaryValueType : uint8_t {
    CHILDREN,
    STRING,
    INT32,
    FLOAT,
    POINTER,
    WSTRING,
    COLOR_RGBA,
    UINT64,
    COUNT,
};
 
struct KV1BinaryPointer {
    static constexpr auto MAGIC_64_BIT = 31337; // Valve this is stupid as hell
 
    union {
        uint32_t v32;
        uint64_t v64;
    };
    bool is64Bit;
 
    explicit operator uint64_t() const noexcept {
        if (this->is64Bit) {
            return this->v64;
        }
        return this->v32;
    }
};
 
using KV1BinaryValue = std::variant<
    std::monostate,
    std::string,
    int32_t,
    float,
    KV1BinaryPointer,
    std::wstring,
    sourcepp::math::Vec4ui8,
    uint64_t
>;
 
template<typename V>
concept KV1BinaryValueNoChildren = std::same_as<V, std::string>
                                || std::same_as<V, int32_t>
                                || std::same_as<V, float>
                                || std::same_as<V, KV1BinaryPointer>
                                || std::same_as<V, std::wstring>
                                || std::same_as<V, sourcepp::math::Vec4ui8>
                                || std::same_as<V, uint64_t>;
 
class KV1BinaryElement {
public:
    KV1BinaryElement() = default;

    [[nodiscard]] std::string_view getKey() const;

    void setKey(std::string_view key_);

    [[nodiscard]] const KV1BinaryValue& getValue() const;

    template<KV1BinaryValueNoChildren V>
    [[nodiscard]] std::optional<V> getValue() const {
        if (!std::holds_alternative<V>(this->value)) {
            return std::nullopt;
        }
        return std::get<V>(this->value);
    }

    void setValue(KV1BinaryValue value_);

    KV1BinaryElement& operator=(KV1BinaryValue value_);

    template<KV1BinaryValueNoChildren V>
    void setValue(V value_) {
        this->value = std::move(value_);
    }

    template<KV1BinaryValueNoChildren V>
    KV1BinaryElement& operator=(V value_) {
        this->setValue(std::move(value_));
        return *this;
    }

    [[nodiscard]] bool hasChild(std::string_view childKey) const;

    KV1BinaryElement& addChild(std::string_view key_, KV1BinaryValue value_ = {});

    template<KV1BinaryValueNoChildren V>
    KV1BinaryElement& addChild(std::string_view key_, V value_ = {}) {
        KV1BinaryElement elem;
        elem.setKey(key_);
        elem.setValue(std::move(value_));
        this->children.push_back(std::move(elem));
        return this->children.back();
    }

    [[nodiscard]] uint64_t getChildCount() const;

    [[nodiscard]] uint64_t getChildCount(std::string_view childKey) const;

    [[nodiscard]] const std::vector<KV1BinaryElement>& getChildren() const;

    [[nodiscard]] std::vector<KV1BinaryElement>& getChildren();
 
    using iterator = std::vector<KV1BinaryElement>::iterator;
 
    [[nodiscard]] constexpr iterator begin() {
        return this->children.begin();
    }
 
    [[nodiscard]] constexpr iterator end() {
        return this->children.end();
    }
 
    using const_iterator = std::vector<KV1BinaryElement>::const_iterator;
 
    [[nodiscard]] constexpr const_iterator begin() const {
        return this->children.begin();
    }
 
    [[nodiscard]] constexpr const_iterator end() const {
        return this->children.end();
    }
 
    [[nodiscard]] constexpr const_iterator cbegin() const {
        return this->children.cbegin();
    }
 
    [[nodiscard]] constexpr const_iterator cend() const {
        return this->children.cend();
    }

    [[nodiscard]] const KV1BinaryElement& operator[](unsigned int n) const;

    [[nodiscard]] KV1BinaryElement& operator[](unsigned int n);

    [[nodiscard]] const KV1BinaryElement& operator[](std::string_view childKey) const;

    [[nodiscard]] KV1BinaryElement& operator[](std::string_view childKey);

    [[nodiscard]] const KV1BinaryElement& operator()(std::string_view childKey) const;

    [[nodiscard]] KV1BinaryElement& operator()(std::string_view childKey);

    [[nodiscard]] const KV1BinaryElement& operator()(std::string_view childKey, unsigned int n) const;

    [[nodiscard]] KV1BinaryElement& operator()(std::string_view childKey, unsigned int n);

    void removeChild(unsigned int n);

    void removeChild(std::string_view childKey, int n = -1);

    [[nodiscard]] bool isInvalid() const;
 
    static const KV1BinaryElement& getInvalid();
 
    [[nodiscard]] explicit operator bool() const;
 
protected:
    std::string key;
    KV1BinaryValue value;
    std::vector<KV1BinaryElement> children;
};
 
class KV1Binary : public KV1BinaryElement {
public:
    explicit KV1Binary(std::span<const std::byte> kv1Data = {}, bool use64BitPointers = true);
 
    explicit KV1Binary(const std::filesystem::path& kv1Path, bool use64BitPointers = true);
 
    [[nodiscard]] std::vector<std::byte> bake() const;
 
    void bake(const std::filesystem::path& kv1Path) const;
 
    [[nodiscard]] std::string bakeText() const;
 
    void bakeText(const std::filesystem::path& kv1Path) const;
};
 
} // namespace kvpp