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 "shambase/exception.hpp"
#include "sham/format/format.hpp"
#include "sham/format/human_readable.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 {

    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) {
        auto res = sham::to_human_readable<false>(size);
        return sham::format("{:.2f} {}B", res.value, res.prefix);
    }

    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