expected.hxx

#pragma once
 
#include <StormByte/type_traits.hxx>
 
#include <expected>
#include <format>
#include <type_traits>
#include <memory>
#include <string>
 
namespace StormByte {
    template <typename T, class E>
    using Expected = std::conditional_t<
        Type::Reference<T>,
        std::expected<std::reference_wrapper<std::remove_reference_t<T>>, std::shared_ptr<E>>,
        std::expected<T, std::shared_ptr<E>>
    >;
 
    template <typename E>
    auto Unexpected(std::shared_ptr<E> error_ptr) {
        return std::unexpected<std::shared_ptr<E>>(std::move(error_ptr));
    }
 
    template <typename E>
    auto Unexpected(E&& error) {
        return std::unexpected<std::shared_ptr<std::decay_t<E>>>(
            std::make_shared<std::decay_t<E>>(std::forward<E>(error))
        );
    }
 
    template <typename Base, typename Derived>
    auto Unexpected(Derived&& error) -> std::unexpected<std::shared_ptr<Base>>
    requires std::is_base_of_v<Base, std::decay_t<Derived>>
    {
        using DerivedT = std::decay_t<Derived>;
        return std::unexpected<std::shared_ptr<Base>>(std::static_pointer_cast<Base>(std::make_shared<DerivedT>(std::forward<Derived>(error))));
    }
 
    template <typename E, typename... Args>
    auto Unexpected(const std::string& fmt, Args&&... args) {
        std::string formatted_message;
 
        if constexpr (sizeof...(Args) == 0) {
            // No arguments provided, use the format string directly
            formatted_message = fmt;
        } else {
            // Create lvalue references for all arguments
            auto format_args = std::make_format_args(args...);
 
            // Use std::vformat for runtime formatting
            formatted_message = std::vformat(fmt, format_args);
        }
 
        // Construct the error instance with the formatted message
        return std::unexpected<std::shared_ptr<E>>(
            std::make_shared<E>(std::move(formatted_message))
        );
    }
}