internal.hpp

Go to the documentation of this file.

#pragma once
 
#include "../misc.hpp"
#include "core.hpp"
#include "stdincludes.hpp"

namespace lipsum::internal
{

    enum class LogType : int
    {
        Trace = 0,
        Info,
        Warn,
        Error,
        Critical
    };
 
#ifndef LIPSUM_MIN_BUILD

    template <typename T>
    concept ToStringable = requires(const T& value) {
        { std::to_string(value) } -> std::convertible_to<std::string>;
    };

    template <typename T>
    concept Streamable = requires(std::ostream& outs, const T& value) {
        { outs << value } -> std::same_as<std::ostream&>;
    } && (!ToStringable<T>);
 
#endif
    template <typename T>
    concept IsInt =
            (std::integral<T> || std::unsigned_integral<T>) &&
            !(std::same_as<T, char>) && !(std::same_as<T, signed char>) &&
            !(std::same_as<T, unsigned char>) && !(std::same_as<T, bool>);

    template <typename T>
    concept UniformDistributionType = (IsInt<T> || std::floating_point<T>);

    LIPSUM_API std::string HandleHTMLEntity(char   letter,
                                            Format format = Format::HTML);

    template <typename... Args>
    void LogWarn([[maybe_unused]] LogType type,
                 [[maybe_unused]] const Args&... args)
    {
#ifndef LIPSUM_QUIET
        std::ostringstream oss;
        oss << "lipsum-cpp ";
        switch (type)
        {
            case LogType::Trace:
            {
                oss << "TRACE";
                break;
            }
            case LogType::Info:
            {
                oss << "INFO";
                break;
            }
            case LogType::Warn:
            {
                oss << "WARNING";
                break;
            }
            case LogType::Error:
            {
                oss << "ERROR";
                break;
            }
            case LogType::Critical:
            {
                oss << "CRITICAL";
                break;
            }
        }
        oss << " -- ";
        ((oss << args), ...);
        oss << '\n';
        std::string message = oss.str();
#    ifndef LIPSUM_MIN_BUILD
#        ifdef __EMSCRIPTEN__
        auto funcCalling = emscripten_console_warn;
        if (type == LogType::Trace || type == LogType::Info)
        {
            funcCalling = emscripten_console_log;
        }
        if (type == LogType::Error || type == LogType::Critical)
        {
            funcCalling = emscripten_console_error;
        }
        funcCalling(message.c_str());
#        elif defined(_WIN32)
        HANDLE hConsole   = GetStdHandle(STD_OUTPUT_HANDLE);
        int    colorUsing = 6; // yellow
        if (type == LogType::Trace)
        {
            colorUsing = 8; // gray
        }
        if (type == LogType::Info)
        {
            colorUsing = 2; // green
        }
        if (type == LogType::Error)
        {
            colorUsing = 12; // light red
        }
        if (type == LogType::Critical)
        {
            colorUsing = 4; // red
        }
        // yellow
        SetConsoleTextAttribute(hConsole, colorUsing);
        std::cerr << message;
        // default
        SetConsoleTextAttribute(hConsole, 7);
#        else
        int colorUsing = 33; // yellow
        if (type == LogType::Trace)
        {
            colorUsing = 90; // gray
        }
        if (type == LogType::Info)
        {
            colorUsing = 32; // green
        }
        if (type == LogType::Error)
        {
            colorUsing = 91; // light red
        }
        if (type == LogType::Critical)
        {
            colorUsing = 31; // red
        }
        std::cerr << "\033[" << colorUsing << "m" << message << "\033[0m";
#        endif
#    else
        std::cerr << message;
#    endif
#endif
    }
 
#ifndef LIPSUM_MIN_BUILD
    template <Streamable T> std::string ToString(const T& param)
    {
        // std::cout << "Using streamable\n";
        std::ostringstream oss;
        oss << param;
        return oss.str();
    }
 
    template <ToStringable T> std::string ToString(const T& param)
    {
        // std::cout << "Using to_string-able\n";
        return std::to_string(param);
    }

    template <typename T> T ToType(const std::string& input)
    {
        T res{};
 
        if constexpr (std::same_as<T, std::string>)
        {
            return input;
        }
        else if constexpr (std::same_as<T, bool>)
        {
            // std::cout << "bool ToType\n";
            return (input == "true" || input == "1");
        }
        else if constexpr (std::same_as<T, char>)
        {
            // std::cout << "char ToType\n";
            return input.empty() ? '\0' : input.at(0);
        }
        else if constexpr (IsInt<T>)
        {
            // std::cout << "integer ToType\n";
            auto [ptr, ec] = std::from_chars(input.data(),
                                             input.data() + input.size(),
                                             res);
            if (ec != std::errc{})
            {
                LogWarn(internal::LogType::Error,
                        "lpsm::internal::ToType: std::from_chars() failed; "
                        "invalidly formatted integer? Returning default T.");
                return T{};
            }
            return res;
        }
        else
        // assume streamable
        {
            // std::cout << "generic ToType\n";
            std::istringstream iss(input);
            iss >> res;
            return res;
        }
    }
 
#else
    template <typename T> std::string ToString(const T& param)
    {
        std::ostringstream oss;
        oss << param;
        return oss.str();
    }
 
    template <typename T> T ToType(const std::string& param)
    {
        T                  res;
        std::istringstream iss(param);
        iss >> std::boolalpha >> res;
        return res;
    }
#endif
} // namespace lipsum::internal