EntityLump.h

Go to the documentation of this file.

#pragma once
 
#include <concepts>
#include <format>
#include <string>
#include <string_view>
#include <vector>
 
#include <BufferStream.h>
#include <sourcepp/parser/Text.h>
#include <sourcepp/String.h>
 
namespace bsppp {
 
template<typename V>
concept BSPEntityKeyValueType = std::convertible_to<V, std::string_view>
                          || std::same_as<V, bool>
                          || std::same_as<V, int32_t>
                          || std::same_as<V, int64_t>
                          || std::same_as<V, float>;
 
class BSPEntityKeyValues {
public:
    class Element {
        friend class BSPEntityKeyValues;
 
    public:
        [[nodiscard]] std::string_view getKey() const;

        void setKey(std::string_view key_);

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

        template<BSPEntityKeyValueType V>
        [[nodiscard]] V getValue() const {
            if constexpr (std::convertible_to<V, std::string_view>) {
                return this->value;
            } else if constexpr (std::same_as<V, bool>) {
                return static_cast<bool>(this->getValue<int32_t>());
            } else if constexpr (std::same_as<V, int32_t>) {
                return std::stoi(std::string{this->value});
            } else if constexpr (std::same_as<V, int64_t>) {
                return std::stoll(std::string{this->value});
            } else if constexpr (std::same_as<V, float>) {
                return std::stof(std::string{this->value});
            }
            return V{};
        }

        template<BSPEntityKeyValueType V>
        void setValue(V value_) {
            if constexpr (std::convertible_to<V, std::string_view>) {
                this->value = std::string_view{value_};
            } else if constexpr (std::same_as<V, bool>) {
                this->setValue(std::format("{:b}", value_));
            } else {
                this->setValue(std::format("{}", value_));
            }
        }

        template<BSPEntityKeyValueType V>
        Element& operator=(V value_) {
            this->setValue(value_);
            return *this;
        }

        [[nodiscard]] bool isInvalid() const;
 
    protected:
        Element() = default;
 
        static const Element& getInvalid();
 
        std::string key;
        std::string value;
    };
 
    BSPEntityKeyValues() = default;

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

    [[nodiscard]] uint64_t getKeyValuesCount() const;

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

    [[nodiscard]] const std::vector<Element>& getKeyValues() const;

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

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

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

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

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

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

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

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

    template<BSPEntityKeyValueType V = std::string_view>
    Element& addKeyValue(std::string_view key_, V value_ = {}) {
        Element elem;
        elem.setKey(key_);
        elem.setValue(value_);
        this->keyvalues.push_back(elem);
        return this->keyvalues.back();
    }

    void removeKeyValue(std::string_view childKey, int n = -1);
 
    [[nodiscard]] std::string bake(bool useEscapes) const;
 
protected:
    std::vector<Element> keyvalues;
};
 
} // namespace bsppp