node_asset_io_internal.h

#pragma once
 
#include "pixelbullet/core/assert.h"
#include "pixelbullet/filesystem/filesystem.h"
#include "pixelbullet/filesystem/native_path.h"
#include "pixelbullet/filesystem/virtual_path.h"
#include "pixelbullet/serialization/node.h"
#include "pixelbullet/serialization/node_file_io.h"
#include "pixelbullet/serialization/serialization_result.h"
 
#include <filesystem>
#include <string>
#include <string_view>
#include <system_error>
 
namespace pixelbullet::serialization_internal
{
inline std::string asset_label_string(const std::string_view asset_label)
{
    ASSERT(!asset_label.empty(), "Asset IO helper labels must not be empty");
    return std::string(asset_label);
}
 
inline SerializationResult resolve_virtual_asset_read_path(std::filesystem::path& physical_path, const Filesystem& filesystem,
                                                           const VirtualPath& path, const std::string_view asset_label)
{
    const std::string label = asset_label_string(asset_label);
    if (path.empty())
    {
        return { false, "Path for " + label + " is empty." };
    }
 
    const auto resolved_path = filesystem.try_resolve(path);
    if (!resolved_path)
    {
        return { false, label + " file '" + path.logical_path() + "' not found." };
    }
 
    physical_path = *resolved_path;
    return { true, {} };
}
 
inline SerializationResult prepare_virtual_asset_write_path(std::filesystem::path& physical_path, const Filesystem& filesystem,
                                                            const VirtualPath& path, const std::string_view asset_label)
{
    const std::string label = asset_label_string(asset_label);
    if (path.empty())
    {
        return { false, "Path for " + label + " is empty." };
    }
 
    physical_path = filesystem.resolve_writable(path);
    if (physical_path.empty())
    {
        return { false, "Failed to resolve " + label + " path '" + path.logical_path() + "'." };
    }
 
    const std::filesystem::path native_path = filesystem::to_native_file_io_path(physical_path);
    const std::filesystem::path parent = native_path.parent_path();
    if (!parent.empty())
    {
        std::error_code error_code;
        std::filesystem::create_directories(parent, error_code);
        if (error_code)
        {
            return {
                false,
                "Failed to create " + label + " parent directory '" + parent.string() + "': " + error_code.message(),
            };
        }
    }
 
    return { true, {} };
}
 
inline SerializationResult read_virtual_node_asset(Node& node, const Filesystem& filesystem, const VirtualPath& path,
                                                   const std::string_view asset_label)
{
    const std::string label = asset_label_string(asset_label);
    std::filesystem::path physical_path;
    const SerializationResult resolve_result = resolve_virtual_asset_read_path(physical_path, filesystem, path, label);
    if (!resolve_result)
    {
        return resolve_result;
    }
 
    const SerializationResult read_result = serialization::read_node_file(node, physical_path);
    if (!read_result)
    {
        return { false, "Failed to load " + label + " '" + path.logical_path() + "': " + read_result.error_message };
    }
 
    return read_result;
}
 
inline SerializationResult write_virtual_node_asset(const Node& node, const Filesystem& filesystem, const VirtualPath& path,
                                                    const std::string_view asset_label)
{
    const std::string label = asset_label_string(asset_label);
    std::filesystem::path physical_path;
    const SerializationResult prepare_result = prepare_virtual_asset_write_path(physical_path, filesystem, path, label);
    if (!prepare_result)
    {
        return prepare_result;
    }
 
    const SerializationResult write_result = serialization::write_node_file(node, physical_path);
    if (!write_result)
    {
        return { false, "Failed to save " + label + " '" + path.logical_path() + "': " + write_result.error_message };
    }
 
    return write_result;
}
} // namespace pixelbullet::serialization_internal