KV1Binary.h

Go to the documentation of this file.

#pragma once
 
#include <concepts>
#include <optional>
#include <span>
#include <string>
#include <string_view>
#include <variant>
#include <vector>
 
#include <BufferStream.h>
#include <sourcepp/parser/Text.h>
 
namespace kvpp {
 
enum class KV1BinaryValueType : uint8_t {
    CHILDREN,
    STRING,
    INT32,
    FLOAT,
    POINTER,
    WSTRING,
    COLOR_RGBA,
    UINT64,
    COUNT,
};
 
using KV1BinaryValue = std::variant<
    std::monostate,
    std::string,
    int32_t,
    float,
    void*,
    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, void*>
                                || 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;
 
    [[nodiscard]] uint64_t getChildCount() const;
 
    [[nodiscard]] uint64_t getChildCount(std::string_view childKey) const;
 
    [[nodiscard]] const std::vector<KV1BinaryElement>& getChildren() const;
 
    KV1BinaryElement& addChild(std::string_view key_);
 
    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(elem);
        return this->children.back();
    }
 
    [[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);
 
    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]] bool isInvalid() const;
 
    static const KV1BinaryElement& getInvalid();
 
protected:
    // NOLINTNEXTLINE(*-no-recursion)
    static void read(BufferStreamReadOnly& stream, std::vector<KV1BinaryElement>& elements, const sourcepp::parser::text::EscapeSequenceMap& escapeSequences);
 
    static void write(BufferStream& stream, const std::vector<KV1BinaryElement>& elements, const sourcepp::parser::text::EscapeSequenceMap& escapeSequences);
 
    std::string key;
    KV1BinaryValue value;
    std::vector<KV1BinaryElement> children;
};
 
class KV1Binary : public KV1BinaryElement {
public:
    explicit KV1Binary(std::span<const std::byte> kv1Data = {}, bool useEscapeSequences_ = false);
 
    [[nodiscard]] std::vector<std::byte> bake() const;
 
    void bake(const std::string& kv1Path) const;
 
    [[nodiscard]] std::string bakeText() const;
 
    void bakeText(const std::string& kv1Path) const;
 
protected:
    bool useEscapeSequences;
};
 
} // namespace kvpp