strings.hh

Go to the documentation of this file.

#pragma once
 
#include "lix/libutil/error.hh"
#include "lix/libutil/types.hh"
 
#include <vector>
#include <boost/container/small_vector.hpp>
 
namespace nix {

constexpr char treeConn[] = "├───";
constexpr char treeLast[] = "└───";
constexpr char treeLine[] = "│   ";
constexpr char treeNull[] = "    ";

std::vector<char *> stringsToCharPtrs(const Strings & ss);
 
 
MakeError(FormatError, Error);
 

template<class C> C tokenizeString(std::string_view s, std::string_view separators = " \t\n\r");

template<class C>
std::string concatStringsSep(const std::string_view sep, const C & ss)
{
    size_t size = 0;
    // need a cast to string_view since this is also called with Symbols
    for (const auto & s : ss) size += sep.size() + std::string_view(s).size();
    std::string s;
    s.reserve(size);
    for (auto & i : ss) {
        if (s.size() != 0) s += sep;
        s += i;
    }
    return s;
}
 
template<class ... Parts>
auto concatStrings(Parts && ... parts)
    -> std::enable_if_t<(... && std::is_convertible_v<Parts, std::string_view>), std::string>
{
    std::string_view views[sizeof...(parts)] = { parts... };
    return concatStringsSep({}, views);
}
 

template<class C, class F>
std::string concatMapStringsSep(std::string_view separator, const C & iterable, F fn)
{
    boost::container::small_vector<std::string, 64> strings;
    strings.reserve(iterable.size());
    for (const auto & elem : iterable) {
        strings.push_back(fn(elem));
    }
    return concatStringsSep(separator, strings);
}
 
 

template<class C> Strings quoteStrings(const C & c)
{
    Strings res;
    for (auto & s : c)
        res.push_back("'" + s + "'");
    return res;
}

std::string chomp(std::string_view s);
 

std::string trim(std::string_view s, std::string_view whitespace = " \n\r\t");
 

std::string replaceStrings(
    std::string s,
    std::string_view from,
    std::string_view to);
 

class Rewriter
{
private:
    std::string initials;
    std::map<std::string, std::string> rewrites;
 
public:
    explicit Rewriter(std::map<std::string, std::string> rewrites);
 
    std::string operator()(std::string s);
};
 
inline std::string rewriteStrings(std::string s, const StringMap & rewrites)
{
    return Rewriter(rewrites)(s);
}
 
 

template<class N>
std::optional<N> string2Int(const std::string_view s);

template<class N>
N string2IntWithUnitPrefix(std::string_view s)
{
    N multiplier = 1;
    if (!s.empty()) {
        char u = std::toupper(*s.rbegin());
        if (std::isalpha(u)) {
            if (u == 'K') multiplier = 1ULL << 10;
            else if (u == 'M') multiplier = 1ULL << 20;
            else if (u == 'G') multiplier = 1ULL << 30;
            else if (u == 'T') multiplier = 1ULL << 40;
            else throw UsageError("invalid unit specifier '%1%'", u);
            s.remove_suffix(1);
        }
    }
    if (auto n = string2Int<N>(s))
        return *n * multiplier;
    throw UsageError("'%s' is not an integer", s);
}

template<class N>
std::optional<N> string2Float(const std::string_view s);
 

std::string toLower(const std::string & s);
 

std::string shellEscape(const std::string_view s);

std::string base64Encode(std::string_view s);
std::string base64Decode(std::string_view s);
 

std::string stripIndentation(std::string_view s);

std::pair<std::string_view, std::string_view> getLine(std::string_view s);
 
std::string showBytes(uint64_t bytes);
 

inline std::string operator + (const std::string & s1, std::string_view s2)
{
    auto s = s1;
    s.append(s2);
    return s;
}
 
inline std::string operator + (std::string && s, std::string_view s2)
{
    s.append(s2);
    return std::move(s);
}
 
inline std::string operator + (std::string_view s1, const char * s2)
{
    std::string s;
    s.reserve(s1.size() + strlen(s2));
    s.append(s1);
    s.append(s2);
    return s;
}
 
}