join_split.h

Go to the documentation of this file.

 
#ifndef GUL17_JOIN_SPLIT_H_
#define GUL17_JOIN_SPLIT_H_
 
#include <iterator>
#include <regex>
#include <string_view>
#include <string>
#include <type_traits>
#include <vector>
 
#include "gul17/internal.h"
#include "gul17/string_util.h"
 
namespace gul17 {
 
template <typename StringContainer = std::vector<std::string>,
          typename ContainerInsertFct = void (*)(StringContainer&, std::string_view)>
inline StringContainer
split(std::string_view text, std::string_view delimiter,
      ContainerInsertFct insert_fct = detail::emplace_back<StringContainer>)
{
    using StringType = typename StringContainer::value_type;
    using SizeType = typename StringType::size_type;
 
    auto result = StringContainer{ };
    auto search_start = SizeType{ 0 };
    auto push_start = search_start;
 
    for (;;) {
        const auto hit = text.find(delimiter.data(), search_start, delimiter.size());
        if (hit == StringType::npos)
            break;
        const auto hit_len = hit - push_start;
        insert_fct(result, text.substr(push_start, hit_len));
        search_start += std::max(delimiter.size() + hit_len, SizeType{ 1 });
        push_start += delimiter.size() + hit_len;
    }
    insert_fct(result, text.substr(push_start));
    return result;
}
 
template <typename StringContainer = std::vector<std::string>,
          typename ContainerInsertFct = void (*)(StringContainer&, std::string_view)>
inline StringContainer
split(std::string_view text, const std::regex& delimiter,
      ContainerInsertFct insert_fct = detail::emplace_back<StringContainer>)
{
    auto const end = std::cregex_iterator{ };
    auto result = StringContainer{ };
 
    auto parts = std::cregex_iterator(text.data(), text.data() + text.size(), delimiter);
    if (parts == end)
    {
        insert_fct(result, text);
    }
    else
    {
        auto previous = std::cregex_iterator{ };
        for (; parts != end; ++parts) {
            if (parts == previous and not parts->length())
                break;
            auto const& match = parts->prefix();
            insert_fct(result, std::string_view(match.first, static_cast<std::size_t>(match.length())));
            previous = parts;
        }
 
        auto const& match = previous->suffix();
        insert_fct(result, std::string_view(match.first, static_cast<std::size_t>(match.length())));
    }
 
    return result;
}
 
template <typename StringContainer = std::vector<std::string_view>,
          typename ContainerInsertFct = void (*)(StringContainer&, std::string_view)>
inline StringContainer
split_sv(std::string_view text, std::string_view delimiter,
      ContainerInsertFct insert_fct = detail::emplace_back<StringContainer>)
{
    return split<StringContainer>(text, delimiter, insert_fct);
}
 
namespace detail {
 
// Type trait to check if a type has a member function size()
template <typename, typename = void>
struct HasSize : std::false_type
{};
 
template <typename T>
struct HasSize<T, std::void_t<decltype(std::declval<const T&>().size())>> : std::true_type
{};
 
} // namespace detail
 
template <typename Iterator>
inline std::string
join(Iterator begin, Iterator end, std::string_view glue)
{
    using ElementType = decltype(*begin);
    std::string result;
 
    if (begin == end)
        return result; // Return an empty string
 
    if constexpr (detail::HasSize<ElementType>::value)
    {
        std::size_t num_strings = 0;
        std::size_t len = 0;
 
        for (auto it = begin; it != end; ++it)
        {
            ++num_strings;
            len += it->size();
        }
        len += (num_strings - 1) * glue.size();
 
        result.reserve(len);
    }
 
    result += *begin;
 
    // Iterate over all but the first string
    for (auto it = std::next(begin); it != end; ++it)
    {
        result.append(glue.data(), glue.size());
        result += *it;
    }
 
    return result;
}
 
template <typename StringContainer>
inline std::string
join(const StringContainer& parts, std::string_view glue)
{
    return join(parts.begin(), parts.end(), glue);
}
 
template <typename Iterator, typename ConversionFct>
inline std::string
join(Iterator begin, Iterator end, std::string_view glue, ConversionFct to_string,
     std::size_t prealloc = 0)
{
    static_assert(std::is_invocable_v<ConversionFct, decltype(*begin)>,
                  "ConversionFct does not accept the element type of the range");
 
    std::string result;
 
    if (begin == end)
        return result; // Return an empty string
 
    result.reserve(prealloc);
    result += to_string(*begin);
 
    // Iterate over all but the first element of the range
    for (auto it = std::next(begin); it != end; ++it)
    {
        result += glue;
        result += to_string(*it);
    }
 
    return result;
}
 
template <typename Container, typename ConversionFct>
inline std::string
join(const Container& container, std::string_view glue, ConversionFct to_string,
     std::size_t prealloc = 0)
{
    return join(container.cbegin(), container.cend(), glue, to_string, prealloc);
}
 
 
} // namespace gul17
 
#endif
 
/* vim:set noexpandtab softtabstop=4 tabstop=4 shiftwidth=4 textwidth=90 cindent: */