toolkit/include/toolkit.h

#ifndef TOOLKIT_H
#define TOOLKIT_H

#include <charconv>
#include <cstring>
#include <expected>
#include <type_traits>
#include <string>
#include <cstdlib>
#include <ios>

//use for to_chars
constexpr size_t buffer_size = 32;

template <typename T>
concept _num_type = requires {
    std::is_same_v<T, int> ||
    std::is_same_v<T, float> ||
    std::is_same_v<T, long> ||
    std::is_same_v<T, double>;
};

namespace toolkit{
    template<typename T>
    std::expected<std::string, std::string> to_string(T value){
        if constexpr (std::is_same_v<T, int> || std::is_same_v<T, float> || std::is_same_v<T, double>){
            char buffer[buffer_size];
            auto res = std::to_chars(buffer, buffer + buffer_size, value);
            if (res.ec != std::errc()) {
                return std::unexpected(std::make_error_code(res.ec).message());
            }
            return std::string(buffer, res.ptr - buffer);
        } else if constexpr (std::is_same_v<typename std::remove_const<T>::type,
                                            char *>) {
          return std::to_string(value);
        }
    }

    template<typename T = double>// requires std::is_same_v<T, std::string>
    std::expected<T, std::string> stoi(const std::string& str){
        T value;
        auto res = std::from_chars(str.c_str(), str.c_str() + str.size(), value);
        if(res.ec != std::errc()){
            return std::unexpected(std::make_error_code(res.ec).message());
        }
        return value;
    }

    template <typename T>
    requires std::is_same_v<std::string, T> || std::is_same_v<const char*, T>
    std::string replace_string(const std::string& str, T d, T e){
        std::string result = str;
        if(d == e){
            return result;
        }
        size_t len = 0;
        while(true){
            auto pos = result.find_first_of(d);
            if(pos == std::string::npos){
                return result;
            }
            if constexpr(std::is_same_v<T, const char*>){
                len = std::strlen(d);
            }else{
                len = d.length();
            }
            result = result.replace(pos, len ,e);
        }
    }
}

#endif