string.hxx

Go to the documentation of this file.

#pragma once
 
// C++
#include <cctype>
#include <cstring>
#include <string>
#include <string_view>
#include <vector>
 
// cosmos
#include <cosmos/dso_export.h>
#include <cosmos/BitMask.hxx>
#include <cosmos/SysString.hxx>
 
namespace cosmos {
 
using StringVector     = std::vector<std::string>;
using StringViewVector = std::vector<std::string_view>;
using CStringVector    = std::vector<const char*>;
using SysStringVector  = std::vector<SysString>;
 
struct CompareCString {
        bool operator()(const char *a, const char *b) const {
                return std::strcmp(a, b) < 0;
        }
};
 
std::string COSMOS_API to_lower(const std::string_view s);
std::string COSMOS_API to_upper(const std::string_view s);
 
std::wstring COSMOS_API to_lower(const std::wstring_view s);
std::wstring COSMOS_API to_upper(const std::wstring_view s);
 
void COSMOS_API strip(std::string &s);
 
inline std::string stripped(const std::string_view s) {
        std::string ret{s};
        strip(ret);
        return ret;
}
 
void COSMOS_API strip(std::wstring &s);
 
inline std::wstring stripped(const std::wstring_view s) {
        std::wstring ret{s};
        strip(ret);
        return ret;
}
 
inline bool is_prefix(const std::string_view s, const std::string_view prefix) {
        // TODO: in C++20 string_view has a starts_with() member
        return s.substr(0, prefix.length()) == prefix;
}
 
inline bool is_suffix(const std::string_view s, const std::string_view suffix) {
        if (s.size() < suffix.size())
                return false;
        // TODO: in C++20 string_view has an ends_with() member
        return s.substr(s.size() - suffix.size()) == suffix;
}
 
 
inline std::string_view to_string_view(const char *s) {
        return s ? std::string_view{s} : std::string_view{};
}
 
 
template <typename CH>
inline bool printable(CH ch) {
        static_assert(sizeof(ch) == 1, "only character types of one byte size allowed");
        return std::isprint(static_cast<unsigned char>(ch));
}
 
enum class SplitFlag {
        STRIP_PARTS = 0x1,
        KEEP_EMPTY  = 0x2
};
 
using SplitFlags = BitMask<SplitFlag>;
 
 
template <typename CHAR>
COSMOS_API std::vector<std::basic_string<CHAR>> split(
                const std::basic_string_view<CHAR> str,
                const std::basic_string_view<CHAR> sep,
                const SplitFlags flags = SplitFlags{});
 
// overload of split avoid type deduction problems
inline std::vector<std::string> split(
                const std::string_view str,
                const std::string_view sep,
                const SplitFlags flags = SplitFlags{}) {
        return split<char>(str, sep, flags);
}
 
} // end ns