string.hpp

Go to the documentation of this file.

#pragma once
#include <stdarg.h>
#include <vector>
 
#include <common.hpp>
 
 
namespace rack {
namespace string {
 

__attribute__((format(printf, 1, 2)))
std::string f(const char* format, ...);
std::string fV(const char* format, va_list args);
 
// Converts std::string arguments of f() to `const char*`
template<typename T>
T convertFArg(const T& t) {return t;}
inline const char* convertFArg(const std::string& s) {return s.c_str();}
template<typename... Args>
std::string f(Args... args) {
    // Allows accessing the original f() above
    typedef std::string (*FType)(const char* format, ...);
    return FType(f)(convertFArg(args)...);
}

std::string lowercase(const std::string& s);
std::string uppercase(const std::string& s);
std::string trim(const std::string& s);
std::string truncate(const std::string& s, size_t maxCodepoints);
std::string truncatePrefix(const std::string& s, size_t maxCodepoints);
std::string ellipsize(const std::string& s, size_t maxCodepoints);
std::string ellipsizePrefix(const std::string& s, size_t maxCodepoints);
bool startsWith(const std::string& str, const std::string& prefix);
bool endsWith(const std::string& str, const std::string& suffix);
 
struct Location {
    size_t line;
    size_t column;
};

Location positionToLocation(const std::string& s, size_t pos);
size_t locationToPosition(const std::string& s, Location location);

std::string toBase64(const uint8_t* data, size_t dataLen);
std::string toBase64(const std::vector<uint8_t>& data);
std::vector<uint8_t> fromBase64(const std::string& str);
 
int strcasecmp(const char* s1, const char* s2);
 
struct CaseInsensitiveCompare {
    bool operator()(const std::string& a, const std::string& b) const;
};

template <typename TContainer>
std::string join(const TContainer& container, std::string seperator = "") {
    std::string s;
    bool first = true;
    for (const auto& c : container) {
        if (!first)
            s += seperator;
        first = false;
        s += c;
    }
    return s;
}

std::vector<std::string> split(const std::string& s, const std::string& seperator, size_t maxTokens = 0);

std::string formatTime(const char* format, double timestamp);
std::string formatTimeISO(double timestamp);
 
// Unicode functions
std::string UTF32toUTF8(const std::u32string& s32);
std::u32string UTF8toUTF32(const std::string& s8);
size_t UTF8NextCodepoint(const std::string& s8, size_t pos);
size_t UTF8PrevCodepoint(const std::string& s8, size_t pos);
size_t UTF8Length(const std::string& s8);
size_t UTF8CodepointIndex(const std::string& s8, size_t pos);
size_t UTF8CodepointPos(const std::string& s8, size_t index);
 
#if defined ARCH_WIN
std::string UTF16toUTF8(const std::wstring& w);
std::wstring UTF8toUTF16(const std::string& s);
#endif
 

struct Version {
    std::vector<std::string> parts;
 
    Version() {}
    Version(const std::string& s);
    Version(const char* s) : Version(std::string(s)) {}
    operator std::string() const;
    bool operator<(const Version& other);
 
    std::string getMajor() const {
        return get(parts, 0, "");
    }
    std::string getMinor() const {
        return get(parts, 1, "");
    }
    std::string getRevision() const {
        return get(parts, 2, "");
    }
};
 

std::string translate(const std::string& id);
std::string translate(const std::string& id, const std::string& language);
std::vector<std::string> getLanguages();
void init();
 
 
} // namespace string
} // namespace rack