Fmt.hpp

#pragma once
 
#include "String.hpp"
#include "Conversion.hpp"
#include "Typing.hpp"
 
#include <concepts>
#include <type_traits>

namespace Melon::Fmt
{
        template<typename T>
        struct IsSpecialValue : std::false_type
        {};

        template<typename T>
        struct IsSpecialValue<Conversion::BinaryValue<T>> : std::true_type
        {};

        template<typename T>
        struct IsSpecialValue<Conversion::OctalValue<T>> : std::true_type
        {};

        template<typename T>
        struct IsSpecialValue<Conversion::HexadecimalValue<T>> : std::true_type
        {};

        template<typename T>
        inline constexpr bool IsSpecialValueV = IsSpecialValue<std::remove_cvref_t<T>>::value;

        template<typename T>
        concept Formattable =
                std::same_as<std::remove_cvref_t<T>, char>
                or std::same_as<std::remove_cvref_t<T>, String::String>
                or std::same_as<std::remove_cvref_t<T>, int>
                or std::same_as<std::remove_cvref_t<T>, long>
                or std::same_as<std::remove_cvref_t<T>, long long>
                or std::same_as<std::remove_cvref_t<T>, unsigned int>
                or std::same_as<std::remove_cvref_t<T>, unsigned long>
                or std::same_as<std::remove_cvref_t<T>, unsigned long long>
                or std::same_as<std::remove_cvref_t<T>, Typing::Int8>
                or std::same_as<std::remove_cvref_t<T>, Typing::Int16>
                or std::same_as<std::remove_cvref_t<T>, Typing::Int32>
                or std::same_as<std::remove_cvref_t<T>, Typing::Int64>
                or std::same_as<std::remove_cvref_t<T>, Typing::Uint8>
                or std::same_as<std::remove_cvref_t<T>, Typing::Uint16>
                or std::same_as<std::remove_cvref_t<T>, Typing::Uint32>
                or std::same_as<std::remove_cvref_t<T>, Typing::Uint64>
                or IsSpecialValueV<T>
        ;

        template<Formattable T, typename... ARGS>
        constexpr void formatArgs(String::String &out, const String::String &fmt, Typing::USize &idx, T &&arg, ARGS &&...args)
        {
                for (; idx < fmt.length(); ++idx) {
                        if (fmt[idx] != '{') {
                                out.appendChar(fmt[idx]);
                                continue;
                        }
 
                        ++idx;
                        if (idx >= fmt.length())
                                return;
 
                        if (fmt[idx] == '}') {
                                // "{}" found, so we expect a parameter
                                if constexpr (std::is_same<std::remove_cvref_t<T>, char>::value) {
                                        out.appendChar(arg);
                                } else if constexpr (std::is_same<std::remove_cvref_t<T>, String::String>::value)
                                        out += arg;
                                else if constexpr (
                                        std::is_same<std::remove_cvref_t<T>, int>::value
                                        or std::is_same<std::remove_cvref_t<T>, long>::value
                                        or std::is_same<std::remove_cvref_t<T>, long long>::value
                                ) {
                                        out += Conversion::intToString<std::remove_cvref_t<T>>(arg, Conversion::Base::Decimal);
                                } else if constexpr (
                                        std::is_same<std::remove_cvref_t<T>, unsigned int>::value
                                        or std::is_same<std::remove_cvref_t<T>, unsigned long>::value
                                        or std::is_same<std::remove_cvref_t<T>, unsigned long long>::value
                                ) {
                                        out += Conversion::uintToString<std::remove_cvref_t<T>>(arg, Conversion::Base::Decimal);
                                } else if constexpr (IsSpecialValueV<T>) {
                                        using InnerType = std::remove_cvref_t<decltype(arg.value)>;
                                        out += Conversion::uintToString<InnerType>(arg.value, std::remove_cvref_t<T>::base);
                                }
 
                                ++idx;
                                if constexpr (sizeof...(ARGS) > 0) {
                                        formatArgs(out, fmt, idx, static_cast<ARGS &&>(args)...);
                                } else {
                                        for (; idx < fmt.length(); ++idx)
                                                out.appendChar(fmt[idx]);
                                }
                                return;
                        }
                }
        }

        constexpr void formatArgs(String::String &out, const String::String &fmt, Typing::USize &idx)
        {
                for (; idx < fmt.length(); ++idx)
                        out.appendChar(fmt[idx]);
        }

        template<typename... ARGS>
        String::String formatString(const String::String &str, ARGS &&...args)
        {
                String::String new_str;
                Typing::USize idx = 0;
 
                formatArgs(new_str, str, idx, static_cast<ARGS &&>(args)...);
 
                return new_str;
        }
} // namespace Melon::Fmt