node.h

#pragma once
 
#include "pixelbullet/core/assert.h"
 
#include <algorithm>
#include <charconv>
#include <cstdint>
#include <map>
#include <sstream>
#include <string>
#include <string_view>
#include <type_traits>
#include <vector>
 
namespace YAML
{
class Node;
}
 
namespace pixelbullet
{
enum class NodeType : uint8_t
{
    Null,
    Object,
    Array,
    String,
    Boolean,
    Integer,
    Decimal
};
 
using NodeValue = std::string;
using NodeProperty = std::pair<std::string, class Node>;
using NodeProperties = std::vector<NodeProperty>;
 
class Node
{
public:
    struct Format
    {
        int8_t spacesPerIndent; 
        char newLine;           
        char space;             
        bool inlineArrays;      
 
        constexpr Format(int8_t s, char nl, char spc, bool inlineArr)
            : spacesPerIndent(s)
            , newLine(nl)
            , space(spc)
            , inlineArrays(inlineArr)
        {
        }
 
        std::string GetIndentation(int8_t indentLevel) const
        {
            return std::string(spacesPerIndent * indentLevel, ' ');
        }
 
        static const Format beautified; 
        static const Format minified;   
    };
 
    Node() = default;
    Node(const Node&) = default;
    Node(Node&&) noexcept = default;
    Node& operator=(const Node&) = default;
    Node& operator=(Node&&) noexcept = default;
    ~Node() = default;
 
    [[nodiscard]] const NodeValue& GetValue() const noexcept;
    void SetValue(const NodeValue& value);
    void SetValue(NodeValue&& value);
 
    [[nodiscard]] NodeType GetType() const noexcept;
    void SetType(NodeType type);
 
    void Clear();
 
    [[nodiscard]] bool IsValid() const noexcept;
 
    [[nodiscard]] const NodeProperties& GetProperties() const noexcept;
    NodeProperties& GetProperties();
 
    [[nodiscard]] bool HasProperty(const std::string& name) const;
    [[nodiscard]] const Node* GetProperty(const std::string& name) const;
    void SetProperty(const std::string& name, const Node& node);
    bool RemoveProperty(const std::string& name);
 
    // For object-style indexing
    Node& operator[](const std::string& key);
    const Node& operator[](const std::string& key) const;
 
    // For array-style indexing
    Node& operator[](size_t index);
    const Node& operator[](size_t index) const;
 
    // Convenience functions for type conversion.
    template <typename T>
    T As() const
    {
        T out{};
        (*this) >> out;
        return out;
    }
 
    template <typename T>
    void Set(const T& in)
    {
        (*this) << in;
    }
 
    // Iterators to properties
    auto begin()
    {
        return properties_.begin();
    }
    auto end()
    {
        return properties_.end();
    }
    auto begin() const
    {
        return properties_.begin();
    }
    auto end() const
    {
        return properties_.end();
    }
 
    // Optional: returns the number of properties (useful for arrays/objects)
    [[nodiscard]] size_t Size() const noexcept
    {
        return properties_.size();
    }
 
    friend const Node& operator>>(const Node& node, Node& out)
    {
        out = node;
        return node;
    }
 
    friend Node& operator<<(Node& node, const Node& in)
    {
        node = in;
        return node;
    }
 
    friend const Node& operator>>(const Node& node, bool& b)
    {
        if (node.value_ == "true" || node.value_ == "1")
        {
            b = true;
        }
        else if (node.value_ == "false" || node.value_ == "0")
        {
            b = false;
        }
        else
        {
            ASSERT(false, "Invalid boolean value: {}", node.value_);
            b = false;
        }
        return node;
    }
 
    friend Node& operator<<(Node& node, bool b)
    {
        node.SetValue(b ? "true" : "false");
        node.SetType(NodeType::Boolean);
        return node;
    }
 
    static bool ParseYAML(Node& node, std::string_view str);
    static bool WriteYAML(const Node& node, std::ostream& stream, const Format& format = Format::minified);
 
private:
    void EnsureObjectStateForMutation();
    static Node YAMLToNode(const YAML::Node& yaml);
 
    NodeProperties properties_;      
    NodeValue value_;                
    NodeType type_ = NodeType::Null; 
};
 
// --- Free Conversion Operators ---
 
// Arithmetic conversion using C++20 requires clause.
template <typename T>
requires std::is_arithmetic_v<T> Node& operator<<(Node& node, const T& value)
{
    char buffer[64]{};
    auto [ptr, ec] = std::to_chars(buffer, buffer + sizeof(buffer), value);
    ASSERT(ec == std::errc(), "Conversion to string failed");
    node.SetValue(std::string(buffer, ptr));
    if constexpr (std::is_integral_v<T>)
    {
        node.SetType(NodeType::Integer);
    }
    else if constexpr (std::is_floating_point_v<T>)
    {
        node.SetType(NodeType::Decimal);
    }
    return node;
}
 
template <typename T>
requires std::is_arithmetic_v<T>
void operator>>(const Node& node, T& value)
{
    const std::string& s = node.GetValue();
    auto result = std::from_chars(s.data(), s.data() + s.size(), value);
    ASSERT(result.ec == std::errc(), "Conversion failed for value: {}", s);
}
 
inline Node& operator<<(Node& node, const std::string& value)
{
    node.SetValue(value);
    node.SetType(NodeType::String);
    return node;
}
 
inline const Node& operator>>(const Node& node, std::string& value)
{
    value = node.GetValue();
    return node;
}
 
template <typename T>
Node& operator<<(Node& node, const std::vector<T>& vec)
{
    node.SetType(NodeType::Array);
    auto& props = node.GetProperties();
    props.clear();
    for (const T& item : vec)
    {
        Node child;
        child << item;
        props.emplace_back("", child);
    }
    return node;
}
 
template <typename T>
void operator>>(const Node& node, std::vector<T>& vec)
{
    ASSERT(node.GetType() == NodeType::Array, "Node is not an array");
    vec.clear();
    for (const auto& [key, child] : node.GetProperties())
    {
        T item;
        child >> item;
        vec.push_back(std::move(item));
    }
}
 
template <typename T>
Node& operator<<(Node& node, const std::map<std::string, T>& mapData)
{
    node.SetType(NodeType::Object);
    auto& props = node.GetProperties();
    props.clear();
    for (const auto& [key, value] : mapData)
    {
        Node child;
        child << value;
        props.emplace_back(key, child);
    }
    return node;
}
 
template <typename T>
void operator>>(const Node& node, std::map<std::string, T>& mapData)
{
    ASSERT(node.GetType() == NodeType::Object, "Node is not an object");
    mapData.clear();
    for (const auto& [key, child] : node.GetProperties())
    {
        T item;
        child >> item;
        mapData.emplace(key, std::move(item));
    }
}
 
inline bool operator==(const Node& lhs, const Node& rhs)
{
    return lhs.GetType() == rhs.GetType() && lhs.GetValue() == rhs.GetValue() && lhs.GetProperties() == rhs.GetProperties();
}
 
inline bool operator!=(const Node& lhs, const Node& rhs)
{
    return !(lhs == rhs);
}
 
inline bool operator<(const Node& lhs, const Node& rhs)
{
    if (lhs.GetType() != rhs.GetType())
    {
        return lhs.GetType() < rhs.GetType();
    }
    if (lhs.GetValue() != rhs.GetValue())
    {
        return lhs.GetValue() < rhs.GetValue();
    }
    return lhs.GetProperties() < rhs.GetProperties();
}
 
// Enum conversions – now enabled only for enums.
template <typename T>
requires std::is_enum_v<T>
const Node& operator>>(const Node& node, T& object)
{
    using Underlying = std::underlying_type_t<T>;
    Underlying value{};
    node >> value;
    object = static_cast<T>(value);
    return node;
}
 
template <typename T>
requires std::is_enum_v<T> Node& operator<<(Node& node, T object)
{
    return node << static_cast<std::underlying_type_t<T>>(object);
}
 
inline const Node& operator>>(const Node& node, std::pair<std::string, std::string>& p)
{
    ASSERT(node.GetType() == NodeType::Object, "Expected object type for a pair");
    const auto& props = node.GetProperties();
    ASSERT(props.size() == 1, "Expected exactly one property for a pair");
    p.first = props[0].first;
    props[0].second >> p.second;
    return node;
}
 
inline Node& operator<<(Node& node, const std::pair<std::string, std::string>& p)
{
    node.SetType(NodeType::Object);
    auto& props = node.GetProperties();
    props.clear();
    Node valueNode;
    valueNode << p.second;
    props.emplace_back(p.first, valueNode);
    return node;
}
} // namespace pixelbullet