string_helper.h

Go to the documentation of this file.

#ifndef OOKII_STRING_HELPER_H_
#define OOKII_STRING_HELPER_H_
 
#pragma once
 
#include <locale>
#include <sstream>
#include <optional>
#include <array>
#include <string>
#include <string_view>
#include <ranges>
#include <algorithm>
 
namespace ookii
{
 
    struct string_less
    {
    public:
        using is_transparent = int;
 
        string_less(bool case_sensitive = true, std::locale loc = {})
            : _case_sensitive{case_sensitive},
              _locale{loc}
        {
        }
 
        template<typename Range1, typename Range2>
        bool operator()(Range1 &&left, Range2 &&right) const
        {
            // Using enables ADL.
            using std::begin;
            using std::end;
            if (_case_sensitive)
            {
                return std::ranges::lexicographical_compare(left, right, std::less<>{});
            }
            else
            {
                return std::ranges::lexicographical_compare(left, right, [this](auto left, auto right) 
                    {
                        return std::toupper(left, _locale) < std::toupper(right, _locale); 
                    });
            }
        }
 
    private:
        bool _case_sensitive;
        std::locale _locale;
    };
 
    template<typename CharType, typename Traits>
    bool string_equal_case_insensitive(std::basic_string_view<CharType, Traits> string1, std::basic_string_view<CharType, Traits> string2, const std::locale &locale = {})
    {
        return std::ranges::equal(string1, string2, [&locale](auto left, auto right) 
            {
                return std::toupper(left, locale) == std::toupper(right, locale); 
            });
    }
 
    template<typename CharType, size_t Length>
    constexpr const std::array<CharType, Length> literal_cast(const char (&value)[Length])
    {
        std::array<CharType, Length> result{};
        std::ranges::copy(value, result.begin());
        return result;
    }
 
    template<typename CharType, typename Traits = std::char_traits<CharType>, typename Alloc = std::allocator<CharType>>
    struct string_convert
    {
        static std::basic_string<CharType, Traits, Alloc> from_bytes(std::string_view value, const std::locale &loc = {})
        {
            std::basic_string<CharType, Traits, Alloc> result;
            auto &facet = std::use_facet<std::ctype<CharType>>(loc);
            result.reserve(value.length());
            std::ranges::transform(value, std::back_inserter(result), [&facet](auto c)
                {
                    return facet.widen(c);
                });
 
            return result;
        }
    };
 
    template<typename Traits, typename Alloc>
    struct string_convert<char, Traits, Alloc>
    {
        static std::basic_string<char, Traits, Alloc> from_bytes(std::string_view value, const std::locale & = {})
        {
            return std::basic_string<char, Traits, Alloc>{value};
        }
    };
 
    template<typename T, typename CharType, typename Traits = std::char_traits<CharType>, typename Alloc = std::allocator<CharType>>
    struct lexical_convert
    {
        static std::optional<T> from_string(std::basic_string_view<CharType, Traits> value, const std::locale &loc = {})
        {
            std::basic_istringstream<CharType> stream{std::basic_string<CharType, Traits, Alloc>{value}};
            stream.imbue(loc);
            // Unsetting all base flags allows the stream to determine the base from the prefix
            // when converting a string to a number.
            stream.unsetf(std::ios::dec);
            stream.unsetf(std::ios::oct);
            stream.unsetf(std::ios::hex);
            T result;
            stream >> result;
            if (!stream || !stream.eof())
                return {};
 
            return result;
        }
    };
 
    template<typename CharType, typename Traits, typename Alloc>
    struct lexical_convert<std::basic_string<CharType, Traits, Alloc>, CharType, Traits, Alloc>
    {
        static std::optional<std::basic_string<CharType, Traits, Alloc>> from_string(std::basic_string_view<CharType, Traits> value, const std::locale &)
        {
            return {std::basic_string<CharType, Traits, Alloc>{value}};
        }
    };
 
    template<typename CharType, typename Traits = std::char_traits<CharType>>
    class tokenize
    {
        class iterator
        {
        public:
            using iterator_concept = std::forward_iterator_tag;
            using value_type = std::basic_string_view<CharType, Traits>;
            using difference_type = std::ptrdiff_t;
            using pointer = value_type*;
            using reference = value_type&;
 
            iterator() noexcept = default;
    
            iterator(value_type value, CharType separator) noexcept
                : _remaining{value},
                  _separator{separator}
            {
                next_value();
            }
 
            iterator &operator++() noexcept
            {
                next_value();
                return *this;
            }
 
            iterator operator++(int) noexcept
            {
                iterator temp = *this;
                next_value();
                return temp;
            }
 
            value_type operator*() const noexcept
            {
                return _value;
            }
 
            bool operator==(const iterator &other) const noexcept
            {
                return _value == other._value && _remaining == other._remaining;
            }
 
        private:
            void next_value() noexcept
            {
                if (_remaining.length() != 0)
                {
                    auto index = _remaining.find_first_of(_separator);
                    _value = _remaining.substr(0, index);
                    if (index == std::string_view::npos)
                    {
                        _remaining = {};
                    }
                    else
                    {
                        _remaining = _remaining.substr(index + 1);
                    }
                }
                else
                {
                    _value = {};
                }
            }
 
            value_type _value;
            value_type _remaining;
            CharType _separator;
        };
 
    public:
        tokenize(typename iterator::value_type value, CharType separator) noexcept
            : _value{value},
              _separator{separator}
        {
        }
 
        iterator begin() const noexcept
        {
            return iterator{_value, _separator};
        }
 
        iterator end() const noexcept
        {
            return iterator{};
        }
 
    private:
        typename iterator::value_type _value;
        CharType _separator;
    };
 
}
 
#endif