node.h

#pragma once
 
#include "pixelbullet/core/assert.h"
#include "pixelbullet/math/validation.h"
 
#include <algorithm>
#include <charconv>
#include <cstddef>
#include <cstdint>
#include <iosfwd>
#include <map>
#include <string>
#include <string_view>
#include <system_error>
#include <type_traits>
#include <utility>
#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
    {
        int spaces_per_indent; 
        char new_line;         
        char space;            
        bool inline_arrays;    
 
        constexpr Format(int s, char nl, char spc, bool inline_arr)
            : spaces_per_indent(s)
            , new_line(nl)
            , space(spc)
            , inline_arrays(inline_arr)
        {
        }
 
        std::string indentation(const int indent_level) const
        {
            ASSERT(indent_level >= 0, "Negative indentation level");
            ASSERT(spaces_per_indent >= 0, "Negative spaces per indent");
            return std::string(static_cast<std::size_t>(spaces_per_indent * indent_level), ' ');
        }
 
        static const Format authoring;  
        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& value() const noexcept;
    void set_value(const NodeValue& value);
    void set_value(NodeValue&& value);
 
    [[nodiscard]] NodeType type() const noexcept;
    void set_type(NodeType type);
 
    void clear();
 
    [[nodiscard]] bool is_valid() const noexcept;
 
    [[nodiscard]] const NodeProperties& properties() const noexcept;
    NodeProperties& properties();
 
    [[nodiscard]] bool has_property(const std::string& name) const;
    [[nodiscard]] const Node* get_property(const std::string& name) const;
    void set_property(const std::string& name, const Node& node);
    bool remove_property(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[](std::size_t index);
    const Node& operator[](std::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]] std::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.set_value(b ? "true" : "false");
        node.set_type(NodeType::Boolean);
        return node;
    }
 
    static bool parse_yaml(Node& node, std::string_view str);
    static bool write_yaml(const Node& node, std::ostream& stream, const Format& format = Format::minified);
 
private:
    void EnsureObjectStateForMutation();
 
    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]{};
    if constexpr (std::is_floating_point_v<T>)
    {
        ASSERT(pixelbullet::math::is_finite(static_cast<long double>(value)), "Cannot serialize non-finite floating-point value");
    }
 
    const auto [ptr, ec] = std::to_chars(buffer, buffer + sizeof(buffer), value);
    ASSERT(ec == std::errc(), "Conversion to string failed");
    node.set_value(std::string(buffer, ptr));
    if constexpr (std::is_integral_v<T>)
    {
        node.set_type(NodeType::Integer);
    }
    else if constexpr (std::is_floating_point_v<T>)
    {
        node.set_type(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.value();
    const char* begin = s.data();
    const char* end = s.data() + s.size();
    const auto result = std::from_chars(begin, end, value);
    ASSERT(result.ec == std::errc() && result.ptr == end, "Conversion failed for value: {}", s);
}
 
inline Node& operator<<(Node& node, const std::string& value)
{
    node.set_value(value);
    node.set_type(NodeType::String);
    return node;
}
 
inline Node& operator<<(Node& node, const char* value)
{
    ASSERT(value != nullptr, "Cannot serialize null C string");
    node.set_value(value);
    node.set_type(NodeType::String);
    return node;
}
 
inline const Node& operator>>(const Node& node, std::string& value)
{
    value = node.value();
    return node;
}
 
template <typename T>
Node& operator<<(Node& node, const std::vector<T>& vec)
{
    node.set_type(NodeType::Array);
    auto& props = node.properties();
    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.type() == NodeType::Array, "Node is not an array");
    vec.clear();
    for (const auto& [key, child] : node.properties())
    {
        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.set_type(NodeType::Object);
    auto& props = node.properties();
    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.type() == NodeType::Object, "Node is not an object");
    mapData.clear();
    for (const auto& [key, child] : node.properties())
    {
        T item;
        child >> item;
        mapData.emplace(key, std::move(item));
    }
}
 
inline bool operator==(const Node& lhs, const Node& rhs)
{
    return lhs.type() == rhs.type() && lhs.value() == rhs.value() && lhs.properties() == rhs.properties();
}
 
inline bool operator!=(const Node& lhs, const Node& rhs)
{
    return !(lhs == rhs);
}
 
inline bool operator<(const Node& lhs, const Node& rhs)
{
    if (lhs.type() != rhs.type())
    {
        return lhs.type() < rhs.type();
    }
    if (lhs.value() != rhs.value())
    {
        return lhs.value() < rhs.value();
    }
    return lhs.properties() < rhs.properties();
}
 
// 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.type() == NodeType::Object, "Expected object type for a pair");
    const auto& props = node.properties();
    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.set_type(NodeType::Object);
    auto& props = node.properties();
    props.clear();
    Node valueNode;
    valueNode << p.second;
    props.emplace_back(p.first, valueNode);
    return node;
}
} // namespace pixelbullet