string_util.h

Go to the documentation of this file.

 
#ifndef GUL17_STRING_UTIL_H_
#define GUL17_STRING_UTIL_H_
 
#include <array>
#include <iterator>
#include <string_view>
#include <string>
 
#include "gul17/internal.h"
#include "gul17/traits.h"
 
namespace gul17 {
 
namespace detail {
 
// Check if an object has a emplace_back() member function
template <typename T, typename = int>
struct HasEmplaceBack : std::false_type { };
template <typename T>
struct HasEmplaceBack<T, typename std::enable_if_t<true,
    decltype(std::declval<T>().emplace_back(), 0)>> : std::true_type { };
 
// Add an element to (the back of) a container using emplace_back()
// if availabe or emplace() if not.
template <typename Container, typename Element>
auto emplace_back(Container& c, Element e)
    -> std::enable_if_t<HasEmplaceBack<Container>::value>
{
    c.emplace_back(std::move(e));
}
 
template <typename Container, typename Element>
auto emplace_back(Container& c, Element e)
    -> std::enable_if_t<!HasEmplaceBack<Container>::value>
{
    c.emplace(std::move(e));
}
 
} // namespace detail
 
GUL_EXPORT
extern const std::string_view default_whitespace_characters;
 
GUL_EXPORT
extern const std::array<char, 16> hex_digits;
 
template <typename Integer,
          std::enable_if_t<std::is_integral<Integer>::value, bool> = true>
inline std::string hex_string(Integer v)
{
    auto u = static_cast<typename std::make_unsigned<Integer>::type>(v);
    std::string result;
 
    for (int idx = static_cast<int>(sizeof(Integer)) - 1; idx >= 0; --idx)
    {
        auto byte = u >> (8 * idx);
        unsigned int upper_nibble = (byte >> 4) & 0xf;
        unsigned int lower_nibble = byte & 0xf;
        result += hex_digits[upper_nibble];
        result += hex_digits[lower_nibble];
    }
 
    return result;
}
 
template <typename Iterator>
inline std::string
hex_string(Iterator begin, Iterator end, std::string_view separator = "")
{
    const auto range_length = std::distance(begin, end);
 
    std::string result;
 
    if (range_length > 0)
    {
        const auto n = static_cast<std::size_t>(range_length);
 
        result.reserve(2 * sizeof(*begin) * n + separator.size() * (n - 1));
 
        result += hex_string(*begin);
 
        for (auto it = std::next(begin); it != end; ++it)
        {
            result += separator;
            result += hex_string(*it);
        }
    }
 
    return result;
}
 
template <typename Integer, size_t num_elements,
          std::enable_if_t<std::is_integral<Integer>::value, bool> = true>
inline std::string
hex_string(const Integer (&array)[num_elements], std::string_view separator = "")
{
    return hex_string(std::begin(array), std::end(array), separator);
}
 
template <typename Container,
          std::enable_if_t<IsContainerLike<Container>::value, bool> = true>
inline std::string
hex_string(const Container& container, std::string_view separator = "")
{
    return hex_string(std::cbegin(container), std::cend(container), separator);
}
 
GUL_EXPORT
std::string null_safe_string(const char* char_ptr);
 
GUL_EXPORT
std::string_view null_safe_string_view(const char* char_ptr);
 
GUL_EXPORT
std::string_view null_safe_string_view(const char* char_ptr, std::size_t length);
 
GUL_EXPORT
std::string repeat(std::string_view str, std::size_t n);
 
GUL_EXPORT
std::string safe_string(const char* char_ptr, std::size_t length);
 
GUL_EXPORT
std::string_view safe_string_view(const char* char_ptr, std::size_t length);
 
 
} // namespace gul17
 
#endif
 
// vi:ts=4:sw=4:sts=4:et