string.hpp

Go to the documentation of this file.

// -------------------------------------------------------//
//
// SHAMROCK code for hydrodynamics
// Copyright (c) 2021-2026 Timothée David--Cléris <tim.shamrock@proton.me>
// SPDX-License-Identifier: CeCILL Free Software License Agreement v2.1
// Shamrock is licensed under the CeCILL 2.1 License, see LICENSE for more information
//
// -------------------------------------------------------//
 
#pragma once
 
#include "shambase/aliases_int.hpp"
#include "exception.hpp"
#include <fmt/base.h>
#include <fmt/core.h>
#include <fmt/format.h>
#include <fmt/printf.h>
#include <fmt/ranges.h>
#include <string_view>
#include <array>
#include <fstream>
#include <vector>
 
namespace shambase {
 
    inline __attribute__((always_inline)) auto vformat(std::string_view fmt, fmt::format_args args)
        -> std::string {
        try {
            return fmt::vformat(fmt, args);
        } catch (const std::exception &e) {
 
            throw make_except_with_loc<std::invalid_argument>(
                "format failed : " + std::string(e.what()) + "\n fmt string : " + std::string(fmt));
        }
    }
 
    inline __attribute__((always_inline)) auto vformat(fmt::string_view fmt, fmt::format_args args)
        -> std::string {
        try {
            return fmt::vformat(fmt, args);
        } catch (const std::exception &e) {
 
            throw make_except_with_loc<std::invalid_argument>(
                "format failed : " + std::string(e.what())
                + "\n fmt string : " + fmt::to_string(fmt));
        }
    }
 
    template<typename... T>
    inline __attribute__((always_inline)) auto format(fmt::format_string<T...> fmt, T &&...args)
        -> std::string {
        return shambase::vformat(fmt, fmt::make_format_args(args...));
    }
 
    template<typename... T>
    inline std::string format_printf(std::string_view format, const T &...args) {
        try {
            return fmt::sprintf(format, args...);
        } catch (const std::exception &e) {
 
            throw make_except_with_loc<std::invalid_argument>(
                "format failed : " + std::string(e.what())
                + "\n fmt string : " + std::string(format));
        }
    }
 
    template<class It, typename... Tformat>
    inline std::string format_array(
        const It &iter, u32 len, u32 column_count, fmt::format_string<Tformat...> fmt) {
 
        std::string accum;
 
        for (u32 i = 0; i < len; i++) {
 
            if (i % column_count == 0) {
                if (i == 0) {
                    accum += shambase::format("{:8} : ", i);
                } else {
                    accum += shambase::format("\n{:8} : ", i);
                }
            }
 
            accum += shambase::format(fmt, iter[i]);
        }
 
        return accum;
    }
 
    inline std::string readable_sizeof(double size) {
 
        i32 i = 0;
 
        using namespace std::string_literals;
        const std::array units{"B"s, "kB"s, "MB"s, "GB"s, "TB"s, "PB"s, "EB"s, "ZB"s, "YB"s};
 
        if (size >= 0) {
            while (size > 1024) {
                size /= 1024;
                i++;
            }
        } else {
            i = 9;
        }
 
        if (i > 8) {
            return format_printf("%s", "err val");
        } else {
            return format_printf("%.2f %s", size, units[i]);
        }
    }
 
    inline void write_string_to_file(std::string filename, std::string s) {
        std::ofstream myfile(filename);
        myfile << s;
        myfile.close();
    }
 
    inline void replace_all(std::string &inout, std::string_view what, std::string_view with) {
        for (std::string::size_type pos{};
             inout.npos != (pos = inout.find(what.data(), pos, what.length()));
             pos += with.length()) {
            inout.replace(pos, what.length(), with.data(), with.length());
        }
    }
 
    inline std::string increase_indent(std::string in, std::string delim = "\n    ") {
        std::string out = in;
        replace_all(out, "\n", delim);
        return "    " + out;
    }
 
    inline std::string trunc_str(std::string s, u32 max_len) {
 
        if (max_len < 5)
            throw std::invalid_argument("max len should be above 4");
 
        if (s.size() > max_len) {
            return s.substr(0, max_len - 5) + " ...";
        } else {
            return s;
        }
    }
 
    inline std::string trunc_str_start(std::string s, u32 max_len) {
        if (max_len < 5)
            throw std::invalid_argument("max len should be above 4");
 
        if (s.size() > max_len) {
            return "... " + s.substr(s.size() - (max_len - 4), s.size());
        } else {
            return s;
        }
    }
 
    inline bool contain_substr(std::string str, std::string what) {
        return (str.find(what) != std::string::npos);
    }
 
    inline std::string shorten_string(std::string str, u32 len) {
        if (len > str.size()) {
            throw make_except_with_loc<std::invalid_argument>(
                "the string is too short to be shortened"
                "\n args : "
                + shambase::format("{} : {} \n {} : {}", "str", str, "len", len));
        }
        return str.substr(0, str.size() - len);
    }
 
    inline std::vector<std::string> split_str(std::string s, std::string delimiter) {
        std::vector<std::string> ret;
 
        size_t pos = 0;
        while ((pos = s.find(delimiter)) != std::string::npos) {
            std::string substr = s.substr(0, pos);
            if (substr.size() > 0)
                ret.push_back(substr);
            s.erase(0, pos + delimiter.length());
        }
        if (s.size() > 0)
            ret.push_back(s);
 
        return ret;
    }
 
} // namespace shambase