Conversion.hpp

#pragma once
 
#include "String.hpp"
 
#include <type_traits>
#include <utility>

namespace Melon::Conversion
{
        enum class Base
        {
                Binary          = 2,
                Octal           = 8,
                Decimal         = 10,
                Hexadecimal     = 16
        };

        template<typename T>
        struct BinaryValue
        {
                T value;
                static constexpr Base base = Base::Binary;
        };

        template<typename T>
        struct OctalValue
        {
                T value;
                static constexpr Base base = Base::Octal;
        };

        template<typename T>
        struct HexadecimalValue
        {
                T value;
                static constexpr Base base = Base::Hexadecimal;
        };

        template<typename T>
        BinaryValue<T> bin(T value)
        {
                return {value};
        }

        template<typename T>
        OctalValue<T> oct(T value)
        {
                return {value};
        }

        template<typename T>
        HexadecimalValue<T> hex(T value)
        {
                return {value};
        }

        const char *baseToString(Base base);

        template<typename T>
                requires std::is_signed_v<T>
        String::String intToString(T value, Base base)
        {
                String::String str;
                String::String digits = "0123456789abcdef";
 
                bool is_negative = false;
 
                if (value < 0) {
                        is_negative = true;
                        value = -value;
                }
 
                if (value == 0) {
                        str.appendChar('0');
                        return str;
                }
 
                while (value != 0) {
                        T remaining = value % std::to_underlying(base);
                        str.appendChar(digits[remaining]);
                        value = value / std::to_underlying(base);
                }
 
                if (is_negative)
                        str.appendChar('-');
 
                return str.reverse();
        }

        template<typename T>
                requires std::is_unsigned_v<T>
        String::String uintToString(T value, Base base)
        {
                String::String str;
                String::String digits = "0123456789abcdef";
 
                if (value == 0) {
                        str.appendChar('0');
                        return str;
                }
 
                while (value != 0) {
                        T remaining = value % std::to_underlying(base);
                        str.appendChar(digits[remaining]);
                        value = value / std::to_underlying(base);
                }
 
                return str.reverse();
        }
} // namespace Melon::Conversion