vdf.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <string>
#include <unordered_map>
#include <variant>
#include <vector>
#include <cstdint>
 
namespace Steam::Utils::VDF {
 
    struct VDFNode;

    using Object = std::unordered_map<std::string, VDFNode>;

    using Value = std::variant<
        std::string,
        int32_t,
        uint64_t,
        float,
        Object
    >;

    struct VDFNode {

        Value value;

        const VDFNode* get(const std::string& key) const {
            if (auto obj = std::get_if<Object>(&value)) {
                auto it = obj->find(key);
                if (it != obj->end())
                    return &it->second;
            }
            return nullptr;
        }

        VDFNode* get(const std::string& key) {
            if (auto obj = std::get_if<Object>(&value)) {
                auto it = obj->find(key);
                if (it != obj->end())
                    return &it->second;
            }
            return nullptr;
        }

        std::string get_string_or(const std::string& key, std::string def) const {
            if (auto node = get(key)) {
                if (auto val = std::get_if<std::string>(&node->value))
                    return *val;
            }
            return def;
        }

        int32_t get_int_or(const std::string& key, int32_t def) const {
            if (auto node = get(key)) {
                if (auto val = std::get_if<int32_t>(&node->value))
                    return *val;
            }
            return def;
        }

        uint64_t get_uint64_or(const std::string& key, uint64_t def) const {
            if (auto node = get(key)) {
                if (auto val = std::get_if<uint64_t>(&node->value))
                    return *val;
            }
            return def;
        }

        float get_float_or(const std::string& key, float def) const {
            if (auto node = get(key)) {
                if (auto val = std::get_if<float>(&node->value))
                    return *val;
            }
            return def;
        }

        const VDFNode* get_path(std::initializer_list<std::string> keys) const {
            const VDFNode* current = this;
 
            for (const auto& key : keys) {
                if (!current)
                    return nullptr;
 
                auto obj = std::get_if<Object>(&current->value);
                if (!obj)
                    return nullptr;
 
                auto it = obj->find(key);
                if (it == obj->end())
                    return nullptr;
 
                current = &it->second;
            }
 
            return current;
        }

        Object& as_object() {
            return std::get<Object>(value);
        }

        const Object& as_object() const {
            return std::get<Object>(value);
        }

        std::string& as_string() {
            return std::get<std::string>(value);
        }

        const std::string& as_string() const {
            return std::get<std::string>(value);
        }

        int32_t as_int() const {
            return std::get<int32_t>(value);
        }

        uint64_t as_uint64() const {
            return std::get<uint64_t>(value);
        }

        float as_float() const {
            return std::get<float>(value);
        }
    };

    Object parse_text(std::string_view text);

    Object parse_binary(const uint8_t* data, size_t size);

    static void stringify_object(const Object& obj, std::string& out, int indent = 0);

    inline std::string stringify(const Object& obj)
    {
        std::string out;
        stringify_object(obj, out, 0);
        return out;
    }
}