string_util.h

Go to the documentation of this file.

 
#ifndef GUL14_STRING_UTIL_H_
#define GUL14_STRING_UTIL_H_
 
#include <array>
#include <iterator>
#include <string>
 
#include "gul14/internal.h"
#include "gul14/string_view.h"
#include "gul14/traits.h"
 
namespace gul14 {
 
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 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, string_view separator = "")
{
    const std::size_t n = std::distance(begin, end);
 
    std::string result;
 
    if (n > 0)
    {
        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], 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, string_view separator = "")
{
    return hex_string(std::cbegin(container), std::cend(container), separator);
}
 
GUL_EXPORT
std::string repeat(gul14::string_view str, std::size_t n);
 
GUL_EXPORT
std::string safe_string(const char* char_ptr, std::size_t length);
 
 
} // namespace gul14
 
#endif
 
// vi:ts=4:sw=4:sts=4:et