#include <cctype>
#include <cstring>
#include <string>
#include <string_view>
#include <vector>
#include <cosmos/dso_export.h>
#include <cosmos/BitMask.hxx>
#include <cosmos/SysString.hxx>

Classes
struct	cosmos::CompareCString
	Comparison type for std::map and similar containers with plain char* as keys. More...

Typedefs
using	cosmos::StringVector = std::vector<std::string>
	A vector of std::string.

using	cosmos::StringViewVector = std::vector<std::string_view>
	A vector of std::string_view.

using	cosmos::CStringVector = std::vector<const char*>
	A vector of plain `const char*`.

using	cosmos::SysStringVector = std::vector<SysString>
	A vector of c-string wrappers.

using	cosmos::SplitFlags = BitMask<SplitFlag>

Enumerations
enum class	cosmos::SplitFlag { STRIP_PARTS = 0x1 , KEEP_EMPTY = 0x2 }
	Bitmask for algorithm settings of the split() function. More...

Functions
std::string	cosmos::to_lower (const std::string_view s)
	Returns an all lower case version of `s`.

std::string	cosmos::to_upper (const std::string_view s)
	Returns an all upper case version of `s`.

std::wstring	cosmos::to_lower (const std::wstring_view s)
	Returns an all lower case version of `s`.

std::wstring	cosmos::to_upper (const std::wstring_view s)
	Returns an all upper case version of `s`.

void	cosmos::strip (std::string &s)
	Strips leading and trailing whitespace from the given string in-place.

std::string	cosmos::stripped (const std::string_view s)
	Returns a version of the given string with stripped off leading and trailing whitespace.

void	cosmos::strip (std::wstring &s)
	Wide string variant of strip(std::string &s)

std::wstring	cosmos::stripped (const std::wstring_view s)
	Wide string variant of stripped(const std::string_view)

bool	cosmos::is_prefix (const std::string_view s, const std::string_view prefix)
	Returns whether `prefix` is a prefix of `s`.

bool	cosmos::is_suffix (const std::string_view s, const std::string_view suffix)
	Returns whether `suffix` is a suffix of `s`.

std::string_view	cosmos::to_string_view (const char *s)
	Simple wrapper that creates a string_view from `s` and supports also nullptr.

template<typename CH >
bool	cosmos::printable (CH ch)
	Simple wrapper around std::isprint that implicitly casts to unsigned char.

template<typename CHAR >
COSMOS_API std::vector< std::basic_string< CHAR > >	cosmos::split (const std::basic_string_view< CHAR > str, const std::basic_string_view< CHAR > sep, const SplitFlags flags=SplitFlags{})
	Split a string at separator boundaries.

std::vector< std::string >	cosmos::split (const std::string_view str, const std::string_view sep, const SplitFlags flags=SplitFlags{})

Detailed Description

This header contains helper functions and types for dealing with std::string objects and general string processing topics.

Definition in file string.hxx.

Typedef Documentation

◆ CStringVector

using cosmos::CStringVector = std::vector<const char*>

A vector of plain const char*.

Definition at line 22 of file string.hxx.

◆ SplitFlags

using cosmos::SplitFlags = BitMask<SplitFlag>

Definition at line 114 of file string.hxx.

◆ StringVector

using cosmos::StringVector = std::vector<std::string>

A vector of std::string.

Definition at line 18 of file string.hxx.

◆ StringViewVector

using cosmos::StringViewVector = std::vector<std::string_view>

A vector of std::string_view.

Definition at line 20 of file string.hxx.

◆ SysStringVector

using cosmos::SysStringVector = std::vector<SysString>

A vector of c-string wrappers.

Definition at line 24 of file string.hxx.

Enumeration Type Documentation

◆ SplitFlag

enum class cosmos::SplitFlag

strong

Bitmask for algorithm settings of the split() function.

Enumerator
STRIP_PARTS	Strip each extracted part using strip().
KEEP_EMPTY	When multiple subsequent separators occur, keep empty parts in the result.

Definition at line 107 of file string.hxx.

                     {
        STRIP_PARTS = 0x1,
        KEEP_EMPTY  = 0x2
};

Function Documentation

◆ is_prefix()

bool cosmos::is_prefix	(	const std::string_view	s,
		const std::string_view	prefix )

inline

Returns whether prefix is a prefix of s.

Definition at line 71 of file string.hxx.

                                                                           {
        // TODO: in C++20 string_view has a starts_with() member
        return s.substr(0, prefix.length()) == prefix;
}

◆ is_suffix()

bool cosmos::is_suffix	(	const std::string_view	s,
		const std::string_view	suffix )

inline

Returns whether suffix is a suffix of s.

Definition at line 77 of file string.hxx.

                                                                           {
        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;
}

◆ printable()

template<typename CH >

bool cosmos::printable ( CH ch )

inline

Simple wrapper around std::isprint that implicitly casts to unsigned char.

std::isprint is undefined if the passed value is not an unsigned 8 bit type or EOF. Thus cast different character types to unsigned char in this wrapper to avoid this trap.

Definition at line 101 of file string.hxx.

                             {
        static_assert(sizeof(ch) == 1, "only character types of one byte size allowed");
        return std::isprint(static_cast<unsigned char>(ch));
}

◆ split() [1/2]

template<typename CHAR >

COSMOS_API std::vector< std::basic_string< CHAR > > cosmos::split	(	const std::basic_string_view< CHAR >	str,
		const std::basic_string_view< CHAR >	sep,
		const SplitFlags	flags = SplitFlags{} )

Split a string at separator boundaries.

The input string str will be split up at every occurrence of the sep substring. The resulting parts are returned as a vector. By default subsequent occurrences of sep are ignored. If SplitFlag::KEEP_EMPTY is set in flags then empty elements will be returned for these occurrences instead.

Definition at line 80 of file string.cxx.

                                        {
 
        using String = std::basic_string<CHAR>;
        std::vector<String> parts;
 
        // index of current start of token
        size_t pos1;
        // index of current end of token
        size_t pos2 = 0;
 
        while(true) {
                String token;
 
                pos1 = pos2;
 
                if (!flags[SplitFlag::KEEP_EMPTY]) {
                        while (str.substr(pos1, sep.size()) == sep)
                                pos1 += sep.size();
                }
 
                pos2 = str.find(sep, pos1);
 
                auto token_len = pos2 - pos1;
 
                if (token_len) {
                        token = str.substr(pos1, token_len);
 
                        if (flags[SplitFlag::STRIP_PARTS]) {
                                strip(token);
                        }
                }
 
                if (!token.empty() || flags[SplitFlag::KEEP_EMPTY]) {
                        parts.push_back(token);
                }
 
                if (pos2 == str.npos)
                        break;
 
                pos2 += sep.size();
        }
 
        return parts;
}

◆ split() [2/2]

std::vector< std::string > cosmos::split	(	const std::string_view	str,
		const std::string_view	sep,
		const SplitFlags	flags = SplitFlags{} )

inline

Definition at line 131 of file string.hxx.

                                                   {}) {
        return split<char>(str, sep, flags);
}

◆ strip() [1/2]

void COSMOS_API cosmos::strip ( std::string & s )

Strips leading and trailing whitespace from the given string in-place.

Definition at line 63 of file string.cxx.

                         {
        while (!s.empty() && std::isspace(s[0]))
                s.erase(s.begin());
 
        while (!s.empty() && std::isspace(s.back()))
                s.pop_back();
}

◆ strip() [2/2]

void COSMOS_API cosmos::strip ( std::wstring & s )

Wide string variant of strip(std::string &s)

Definition at line 71 of file string.cxx.

                          {
        while (!s.empty() && std::iswspace(s[0]))
                s.erase(s.begin());
 
        while (!s.empty() && std::iswspace(s.back()))
                s.pop_back();
}

◆ stripped() [1/2]

std::string cosmos::stripped ( const std::string_view s )

inline

Returns a version of the given string with stripped off leading and trailing whitespace.

Definition at line 54 of file string.hxx.

                                                  {
        std::string ret{s};
        strip(ret);
        return ret;
}

◆ stripped() [2/2]

std::wstring cosmos::stripped ( const std::wstring_view s )

inline

Wide string variant of stripped(const std::string_view)

Definition at line 64 of file string.hxx.

                                                    {
        std::wstring ret{s};
        strip(ret);
        return ret;
}

◆ to_lower() [1/2]

std::string COSMOS_API cosmos::to_lower ( const std::string_view s )

Returns an all lower case version of s.

Definition at line 11 of file string.cxx.

                                           {
        std::string ret;
        ret.resize(s.size());
        // put it all to lower case
        std::transform(
                s.begin(), s.end(),
                ret.begin(),
                ::tolower
        );
 
        return ret;
}

◆ to_lower() [2/2]

std::wstring COSMOS_API cosmos::to_lower ( const std::wstring_view s )

Returns an all lower case version of s.

Definition at line 37 of file string.cxx.

                                             {
        std::wstring ret;
        ret.resize(s.size());
        // put it all to lower case
        std::transform(
                s.begin(), s.end(),
                ret.begin(),
                std::towlower
        );
 
        return ret;
}

◆ to_string_view()

std::string_view cosmos::to_string_view ( const char * s )

inline

Simple wrapper that creates a string_view from s and supports also nullptr.

The std::string_view constructor does not allow a nullptr argument. This wrapper makes this limitation transparent by returning an empty string_view for nullptr C strings.

Definition at line 90 of file string.hxx.

                                                    {
        return s ? std::string_view{s} : std::string_view{};
}

◆ to_upper() [1/2]

std::string COSMOS_API cosmos::to_upper ( const std::string_view s )

Returns an all upper case version of s.

Definition at line 24 of file string.cxx.

                                           {
        std::string ret;
        ret.resize(s.size());
        // put it all to lower case
        std::transform(
                s.begin(), s.end(),
                ret.begin(),
                ::toupper
        );
 
        return ret;
}

◆ to_upper() [2/2]

std::wstring COSMOS_API cosmos::to_upper ( const std::wstring_view s )

Returns an all upper case version of s.

Definition at line 50 of file string.cxx.

                                             {
        std::wstring ret;
        ret.resize(s.size());
        // put it all to lower case
        std::transform(
                s.begin(), s.end(),
                ret.begin(),
                std::towupper
        );
 
        return ret;
}

Classes

Typedefs

Enumerations

Functions

Detailed Description

Typedef Documentation

◆ CStringVector

◆ SplitFlags

◆ StringVector

◆ StringViewVector

◆ SysStringVector

Enumeration Type Documentation

◆ SplitFlag

Function Documentation

◆ is_prefix()

◆ is_suffix()

◆ printable()

◆ split() [1/2]

◆ split() [2/2]

◆ strip() [1/2]

◆ strip() [2/2]

◆ stripped() [1/2]

◆ stripped() [2/2]

◆ to_lower() [1/2]

◆ to_lower() [2/2]

◆ to_string_view()

◆ to_upper() [1/2]

◆ to_upper() [2/2]