node_reader.h

#pragma once
 
#include "pixelbullet/serialization/node.h"
#include "pixelbullet/serialization/serialization_result.h"
 
#include <glm/glm.hpp>
 
#include <charconv>
#include <cmath>
#include <concepts>
#include <cstddef>
#include <cstdint>
#include <limits>
#include <map>
#include <optional>
#include <string>
#include <string_view>
#include <system_error>
#include <type_traits>
#include <utility>
#include <vector>
 
namespace pixelbullet::serialization
{
[[nodiscard]] inline std::string NodeTypeName(const NodeType type)
{
    switch (type)
    {
    case NodeType::Null:
        return "null";
    case NodeType::Object:
        return "object";
    case NodeType::Array:
        return "array";
    case NodeType::String:
        return "string";
    case NodeType::Boolean:
        return "boolean";
    case NodeType::Integer:
        return "integer";
    case NodeType::Decimal:
        return "decimal";
    }
    return "unknown";
}
 
class NodeReader
{
public:
    explicit NodeReader(std::string root_path = {})
        : path_(std::move(root_path))
    {
    }
 
    class PathScope
    {
    public:
        PathScope(NodeReader& reader, std::string next_path)
            : reader_(reader)
            , previous_path_(std::move(reader.path_))
        {
            reader_.path_ = std::move(next_path);
        }
 
        PathScope(const PathScope&) = delete;
        PathScope& operator=(const PathScope&) = delete;
 
        ~PathScope()
        {
            reader_.path_ = std::move(previous_path_);
        }
 
    private:
        NodeReader& reader_;
        std::string previous_path_;
    };
 
    [[nodiscard]] PathScope PushProperty(const std::string_view property)
    {
        std::string next = path_.empty() ? std::string(property) : path_ + "." + std::string(property);
        return PathScope(*this, std::move(next));
    }
 
    [[nodiscard]] PathScope PushIndex(const std::size_t index)
    {
        std::string next = path_.empty() ? "[" + std::to_string(index) + "]" : path_ + "[" + std::to_string(index) + "]";
        return PathScope(*this, std::move(next));
    }
 
    [[nodiscard]] bool Fail(std::string message)
    {
        diagnostics_.push_back(SerializationDiagnostic{ .path = path_, .message = std::move(message) });
        return false;
    }
 
    [[nodiscard]] bool ExpectScalar(const Node& node)
    {
        if (node.type() == NodeType::Object || node.type() == NodeType::Array || node.type() == NodeType::Null)
        {
            return Fail("Expected scalar node, got " + NodeTypeName(node.type()) + ".");
        }
        return true;
    }
 
    [[nodiscard]] bool ExpectObjectOrNull(const Node& node)
    {
        if (node.type() != NodeType::Object && node.type() != NodeType::Null)
        {
            return Fail("Expected object node, got " + NodeTypeName(node.type()) + ".");
        }
        return true;
    }
 
    [[nodiscard]] bool ExpectArray(const Node& node)
    {
        if (node.type() != NodeType::Array)
        {
            return Fail("Expected array node, got " + NodeTypeName(node.type()) + ".");
        }
        return true;
    }
 
    [[nodiscard]] const std::vector<SerializationDiagnostic>& Diagnostics() const noexcept
    {
        return diagnostics_;
    }
 
    [[nodiscard]] bool HasErrors() const noexcept
    {
        return !diagnostics_.empty();
    }
 
    [[nodiscard]] SerializationResult ToResult() const
    {
        if (diagnostics_.empty())
        {
            return SerializationResult{ true, {} };
        }
 
        const SerializationDiagnostic& first = diagnostics_.front();
        std::string message = first.path.empty() ? first.message : first.path + ": " + first.message;
        return SerializationResult{ false, std::move(message), diagnostics_ };
    }
 
private:
    std::string path_;
    std::vector<SerializationDiagnostic> diagnostics_;
};
 
template <typename T>
[[nodiscard]] bool TryReadNode(const Node& node, T& value, NodeReader& reader)
    requires(std::is_integral_v<T> && !std::is_same_v<T, bool>)
{
    if (!reader.ExpectScalar(node))
    {
        return false;
    }
 
    const std::string& serialized = node.value();
    const char* begin = serialized.data();
    const char* end = begin + serialized.size();
    T parsed{};
    const auto result = std::from_chars(begin, end, parsed);
    if (result.ec != std::errc() || result.ptr != end)
    {
        return reader.Fail("Expected integer value, got '" + serialized + "'.");
    }
 
    value = parsed;
    return true;
}
 
template <typename T>
[[nodiscard]] bool TryReadNode(const Node& node, T& value, NodeReader& reader)
    requires std::is_floating_point_v<T>
{
    if (!reader.ExpectScalar(node))
    {
        return false;
    }
 
    const std::string& serialized = node.value();
    const char* begin = serialized.data();
    const char* end = begin + serialized.size();
    T parsed{};
    const auto result = std::from_chars(begin, end, parsed);
    if (result.ec != std::errc() || result.ptr != end || !std::isfinite(static_cast<long double>(parsed)))
    {
        return reader.Fail("Expected finite decimal value, got '" + serialized + "'.");
    }
 
    value = parsed;
    return true;
}
 
[[nodiscard]] inline bool TryReadNode(const Node& node, bool& value, NodeReader& reader)
{
    if (!reader.ExpectScalar(node))
    {
        return false;
    }
 
    const std::string& serialized = node.value();
    if (serialized == "true" || serialized == "1")
    {
        value = true;
        return true;
    }
    if (serialized == "false" || serialized == "0")
    {
        value = false;
        return true;
    }
 
    return reader.Fail("Expected boolean value, got '" + serialized + "'.");
}
 
[[nodiscard]] inline bool TryReadNode(const Node& node, std::string& value, NodeReader& reader)
{
    if (!reader.ExpectScalar(node))
    {
        return false;
    }
 
    value = node.value();
    return true;
}
 
[[nodiscard]] inline bool TryReadNode(const Node& node, glm::vec2& value, NodeReader& reader)
{
    if (!reader.ExpectArray(node))
    {
        return false;
    }
    if (node.properties().size() < 2)
    {
        return reader.Fail("Expected at least 2 array elements.");
    }
 
    glm::vec2 parsed{};
    bool ok = true;
    static constexpr std::string_view kComponents[] = { "x", "y" };
    for (std::size_t index = 0; index < 2; ++index)
    {
        auto scope = reader.PushProperty(kComponents[index]);
        ok &= TryReadNode(node.properties()[index].second, parsed[static_cast<int>(index)], reader);
    }
 
    if (ok)
    {
        value = parsed;
    }
    return ok;
}
 
[[nodiscard]] inline bool TryReadNode(const Node& node, glm::vec3& value, NodeReader& reader)
{
    if (!reader.ExpectArray(node))
    {
        return false;
    }
    if (node.properties().size() < 3)
    {
        return reader.Fail("Expected at least 3 array elements.");
    }
 
    glm::vec3 parsed{};
    bool ok = true;
    static constexpr std::string_view kComponents[] = { "x", "y", "z" };
    for (std::size_t index = 0; index < 3; ++index)
    {
        auto scope = reader.PushProperty(kComponents[index]);
        ok &= TryReadNode(node.properties()[index].second, parsed[static_cast<int>(index)], reader);
    }
 
    if (ok)
    {
        value = parsed;
    }
    return ok;
}
 
[[nodiscard]] inline bool TryReadNode(const Node& node, glm::vec4& value, NodeReader& reader)
{
    if (!reader.ExpectArray(node))
    {
        return false;
    }
    if (node.properties().size() < 4)
    {
        return reader.Fail("Expected at least 4 array elements.");
    }
 
    glm::vec4 parsed{};
    bool ok = true;
    static constexpr std::string_view kComponents[] = { "x", "y", "z", "w" };
    for (std::size_t index = 0; index < 4; ++index)
    {
        auto scope = reader.PushProperty(kComponents[index]);
        ok &= TryReadNode(node.properties()[index].second, parsed[static_cast<int>(index)], reader);
    }
 
    if (ok)
    {
        value = parsed;
    }
    return ok;
}
 
template <typename T>
[[nodiscard]] bool TryReadNode(const Node& node, std::vector<T>& value, NodeReader& reader)
{
    if (!reader.ExpectArray(node))
    {
        return false;
    }
 
    std::vector<T> parsed;
    parsed.reserve(node.properties().size());
    bool ok = true;
    std::size_t index = 0;
    for (const auto& [key, child] : node.properties())
    {
        (void)key;
        T item{};
        {
            auto scope = reader.PushIndex(index);
            ok &= TryReadNode(child, item, reader);
        }
        parsed.push_back(std::move(item));
        ++index;
    }
 
    if (ok)
    {
        value = std::move(parsed);
    }
    return ok;
}
 
template <typename T>
[[nodiscard]] bool TryReadNode(const Node& node, std::map<std::string, T>& value, NodeReader& reader)
{
    if (!reader.ExpectObjectOrNull(node))
    {
        return false;
    }
 
    std::map<std::string, T> parsed;
    bool ok = true;
    for (const auto& [key, child] : node.properties())
    {
        T item{};
        {
            auto scope = reader.PushProperty(key);
            ok &= TryReadNode(child, item, reader);
        }
        parsed.emplace(key, std::move(item));
    }
 
    if (ok)
    {
        value = std::move(parsed);
    }
    return ok;
}
 
template <typename T>
[[nodiscard]] bool TryReadNode(const Node& node, std::optional<T>& value, NodeReader& reader)
{
    if (node.type() == NodeType::Null || !node.is_valid())
    {
        value.reset();
        return true;
    }
 
    T parsed{};
    if (!TryReadNode(node, parsed, reader))
    {
        return false;
    }
 
    value = std::move(parsed);
    return true;
}
 
template <typename T, typename ParseFn>
[[nodiscard]] bool TryReadEnumToken(const Node& node, T& value, NodeReader& reader, ParseFn&& parse_fn, const std::string_view enum_name)
{
    std::string token;
    if (!TryReadNode(node, token, reader))
    {
        return false;
    }
 
    T parsed{};
    if (!parse_fn(token, parsed))
    {
        return reader.Fail("Unknown " + std::string(enum_name) + " token '" + token + "'.");
    }
 
    value = parsed;
    return true;
}
 
template <typename T>
[[nodiscard]] bool TryReadRequiredProperty(const Node& node, const std::string_view property, T& value, NodeReader& reader)
{
    if (!reader.ExpectObjectOrNull(node))
    {
        return false;
    }
 
    const Node* child = node.get_property(std::string(property));
    auto scope = reader.PushProperty(property);
    if (child == nullptr)
    {
        return reader.Fail("Missing required property.");
    }
    return TryReadNode(*child, value, reader);
}
 
template <typename T>
[[nodiscard]] bool TryReadOptionalProperty(const Node& node, const std::string_view property, T& value, NodeReader& reader)
{
    if (!reader.ExpectObjectOrNull(node))
    {
        return false;
    }
 
    const Node* child = node.get_property(std::string(property));
    if (child == nullptr)
    {
        return true;
    }
 
    auto scope = reader.PushProperty(property);
    return TryReadNode(*child, value, reader);
}
 
template <typename T>
[[nodiscard]] bool TryReadOptionalProperty(const Node& node, const std::string_view property, T& value, const T& default_value,
                                           NodeReader& reader)
{
    if (!reader.ExpectObjectOrNull(node))
    {
        return false;
    }
 
    if (!node.has_property(std::string(property)))
    {
        value = default_value;
        return true;
    }
    return TryReadOptionalProperty(node, property, value, reader);
}
 
template <typename T>
concept NodeReadable = requires(const Node& node, T& value, NodeReader& reader) {
    { TryReadNode(node, value, reader) } -> std::same_as<bool>;
};
} // namespace pixelbullet::serialization