basic_string_view.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: BSL-1.0
#ifndef TETL_BASIC_STRING_VIEW_STRING_VIEW_HPP
#define TETL_BASIC_STRING_VIEW_STRING_VIEW_HPP
 
#include <etl/_algorithm/clamp.hpp>
#include <etl/_algorithm/find_end.hpp>
#include <etl/_algorithm/lexicographical_compare.hpp>
#include <etl/_algorithm/min.hpp>
#include <etl/_algorithm/none_of.hpp>
#include <etl/_concepts/emulation.hpp>
#include <etl/_contracts/check.hpp>
#include <etl/_iterator/begin.hpp>
#include <etl/_iterator/data.hpp>
#include <etl/_iterator/end.hpp>
#include <etl/_iterator/next.hpp>
#include <etl/_iterator/rbegin.hpp>
#include <etl/_iterator/rend.hpp>
#include <etl/_iterator/reverse_iterator.hpp>
#include <etl/_iterator/size.hpp>
#include <etl/_ranges/enable_borrowed_range.hpp>
#include <etl/_string/char_traits.hpp>
#include <etl/_type_traits/type_identity.hpp>
#include <etl/_utility/swap.hpp>
 
namespace etl {

template <typename Char, typename Traits = etl::char_traits<Char>>
struct basic_string_view {
    using traits_type            = Traits;
    using value_type             = Char;
    using pointer                = Char*;
    using const_pointer          = Char const*;
    using reference              = Char&;
    using const_reference        = Char const&;
    using const_iterator         = Char const*;
    using iterator               = const_iterator;
    using size_type              = etl::size_t;
    using difference_type        = etl::ptrdiff_t;
    using const_reverse_iterator = etl::reverse_iterator<const_iterator>;
    using reverse_iterator       = const_reverse_iterator;

    constexpr basic_string_view() noexcept = default;

    constexpr basic_string_view(basic_string_view const& other) noexcept = default;

    constexpr basic_string_view(Char const* str, size_type size)
        : _begin{str}
        , _size{size}
    {
    }

    constexpr basic_string_view(Char const* str)
        : _begin{str}
        , _size{traits_type::length(str)}
    {
    }
 
    constexpr basic_string_view(nullptr_t /*null*/) = delete;

    template <typename Iter>
        requires(detail::RandomAccessIterator<Iter>)
    constexpr basic_string_view(Iter first, Iter last)
        : basic_string_view{first, static_cast<size_type>(last - first)}
    {
    }
 
    ~basic_string_view() noexcept = default;

    constexpr auto operator=(basic_string_view const& view) noexcept -> basic_string_view& = default;

    [[nodiscard]] constexpr auto begin() const noexcept -> const_iterator { return cbegin(); }

    [[nodiscard]] constexpr auto cbegin() const noexcept -> const_iterator { return _begin; }

    [[nodiscard]] constexpr auto end() const noexcept -> const_iterator { return cend(); }

    [[nodiscard]] constexpr auto cend() const noexcept -> const_iterator { return _begin + _size; }

    [[nodiscard]] constexpr auto rbegin() const noexcept -> const_reverse_iterator { return crbegin(); }

    [[nodiscard]] constexpr auto crbegin() const noexcept -> const_reverse_iterator
    {
        return const_reverse_iterator(end());
    }

    [[nodiscard]] constexpr auto rend() const noexcept -> const_reverse_iterator { return crend(); }

    [[nodiscard]] constexpr auto crend() const noexcept -> const_reverse_iterator
    {
        return const_reverse_iterator(begin());
    }

    [[nodiscard]] constexpr auto operator[](size_type pos) const -> const_reference
    {
        TETL_PRECONDITION(pos < size());
        return unsafe_at(pos);
    }

    [[nodiscard]] constexpr auto front() const -> const_reference
    {
        TETL_PRECONDITION(not empty());
        return unsafe_at(0);
    }

    [[nodiscard]] constexpr auto back() const -> const_reference
    {
        TETL_PRECONDITION(not empty());
        return unsafe_at(_size - 1);
    }

    [[nodiscard]] constexpr auto data() const noexcept -> const_pointer { return _begin; }

    [[nodiscard]] constexpr auto size() const noexcept -> size_type { return length(); }

    [[nodiscard]] constexpr auto length() const noexcept -> size_type { return _size; }

    [[nodiscard]] constexpr auto max_size() const noexcept -> size_type { return size_type(-1); }

    [[nodiscard]] constexpr auto empty() const noexcept -> bool { return _size == 0; }

    constexpr auto remove_prefix(size_type n) -> void
    {
        TETL_PRECONDITION(n <= size());
        _begin += n;
        _size -= n;
    }

    constexpr auto remove_suffix(size_type n) -> void
    {
        TETL_PRECONDITION(n <= size());
        _size = _size - n;
    }

    constexpr auto swap(basic_string_view& v) noexcept -> void
    {
        etl::swap(_begin, v._begin);
        etl::swap(_size, v._size);
    }

    [[nodiscard]] constexpr auto copy(Char* dest, size_type count, size_type pos = 0) const -> size_type
    {
        TETL_PRECONDITION(pos <= size());
        auto const rcount = etl::min(count, size() - pos);
        traits_type::copy(dest, data() + pos, rcount);
        return rcount;
    }

    [[nodiscard]] constexpr auto substr(size_type pos = 0, size_type count = npos) const -> basic_string_view
    {
        TETL_PRECONDITION(pos <= size());
        auto const rcount = etl::min(count, size() - pos);
        return basic_string_view{_begin + pos, rcount};
    }

    [[nodiscard]] constexpr auto compare(basic_string_view v) const noexcept -> int
    {
        auto const rlen = etl::min(size(), v.size());
        auto const res  = traits_type::compare(data(), v.data(), rlen);
 
        if (res < 0) {
            return -1;
        }
        if (res > 0) {
            return 1;
        }
 
        if (size() < v.size()) {
            return -1;
        }
        if (size() > v.size()) {
            return 1;
        }
 
        return 0;
    }

    [[nodiscard]] constexpr auto compare(size_type pos1, size_type count1, basic_string_view v) const -> int
    {
        return substr(pos1, count1).compare(v);
    }

    [[nodiscard]] constexpr auto
    compare(size_type pos1, size_type count1, basic_string_view v, size_type pos2, size_type count2) const -> int
    {
        return substr(pos1, count1).compare(v.substr(pos2, count2));
    }

    [[nodiscard]] constexpr auto compare(Char const* s) const -> int { return compare(basic_string_view(s)); }

    [[nodiscard]] constexpr auto compare(size_type pos1, size_type count1, Char const* s) const -> int
    {
        return substr(pos1, count1).compare(basic_string_view(s));
    }

    [[nodiscard]] constexpr auto compare(size_type pos1, size_type count1, Char const* s, size_type count2) const -> int
    {
        return substr(pos1, count1).compare(basic_string_view(s, count2));
    }

    [[nodiscard]] constexpr auto starts_with(basic_string_view sv) const noexcept -> bool
    {
        return substr(0, sv.size()) == sv;
    }

    [[nodiscard]] constexpr auto starts_with(Char c) const noexcept -> bool
    {
        return !empty() && traits_type::eq(front(), c);
    }

    [[nodiscard]] constexpr auto starts_with(Char const* str) const -> bool
    {
        return starts_with(basic_string_view(str));
    }

    [[nodiscard]] constexpr auto ends_with(basic_string_view sv) const noexcept -> bool
    {
        return size() >= sv.size() && compare(size() - sv.size(), npos, sv) == 0;
    }

    [[nodiscard]] constexpr auto ends_with(Char c) const noexcept -> bool { return !empty() && Traits::eq(back(), c); }

    constexpr auto ends_with(Char const* str) const -> bool { return ends_with(basic_string_view(str)); }

    [[nodiscard]] constexpr auto find(basic_string_view v, size_type pos = 0) const noexcept -> size_type
    {
        if (v.size() > size() - pos) {
            return npos;
        }
 
        for (size_type outerIdx = pos; outerIdx < size(); ++outerIdx) {
            if (unsafe_at(outerIdx) == v.front()) {
                auto found = [&] {
                    for (size_type innerIdx = 0; innerIdx < v.size(); ++innerIdx) {
                        auto offset = outerIdx + innerIdx;
                        if (unsafe_at(offset) != v[innerIdx]) {
                            return false;
                        }
                    }
 
                    return true;
                }();
 
                if (found) {
                    return outerIdx;
                }
            }
        }
 
        return npos;
    }

    [[nodiscard]] constexpr auto find(Char ch, size_type pos = 0) const noexcept -> size_type
    {
        return find(basic_string_view(&ch, 1), pos);
    }

    constexpr auto find(Char const* s, size_type pos, size_type count) const -> size_type
    {
        return find(basic_string_view(s, count), pos);
    }

    constexpr auto find(Char const* s, size_type pos = 0) const -> size_type { return find(basic_string_view(s), pos); }

    [[nodiscard]] constexpr auto rfind(basic_string_view sv, size_type pos = npos) const noexcept -> size_type
    {
        pos = etl::min(pos, size());
        if (sv.size() < size() - pos) {
            pos += sv.size();
        } else {
            pos = size();
        }
 
        auto const* r = etl::find_end(data(), data() + pos, sv.begin(), sv.end(), Traits::eq);
        if (sv.size() > 0 && r == data() + pos) {
            return npos;
        }
        return static_cast<size_type>(r - data());
    }

    [[nodiscard]] constexpr auto rfind(Char c, size_type pos = npos) const noexcept -> size_type
    {
        if (size() < 1) {
            return npos;
        }
 
        if (pos < size()) {
            ++pos;
        } else {
            pos = size();
        }
        for (auto const* s = data() + pos; s != data();) {
            if (Traits::eq(*--s, c)) {
                return static_cast<size_type>(s - data());
            }
        }
        return npos;
    }

    constexpr auto rfind(Char const* s, size_type pos, size_type count) const noexcept -> size_type
    {
        return rfind({s, count}, pos);
    }

    constexpr auto rfind(Char const* s, size_type pos = npos) const noexcept -> size_type
    {
        return rfind({s, traits_type::length(s)}, pos);
    }

    [[nodiscard]] constexpr auto find_first_of(basic_string_view v, size_type pos = 0) const noexcept -> size_type
    {
        for (size_type idx = pos; idx < size(); ++idx) {
            for (auto const c : v) {
                if (c == unsafe_at(idx)) {
                    return idx;
                }
            }
        }
 
        return npos;
    }

    [[nodiscard]] constexpr auto find_first_of(Char c, size_type pos = 0) const noexcept -> size_type
    {
        return find_first_of(basic_string_view(&c, 1), pos);
    }

    constexpr auto find_first_of(Char const* s, size_type pos, size_type count) const -> size_type
    {
        return find_first_of(basic_string_view(s, count), pos);
    }

    constexpr auto find_first_of(Char const* s, size_type pos = 0) const -> size_type
    {
        return find_first_of(basic_string_view(s), pos);
    }

    [[nodiscard]] constexpr auto find_first_not_of(basic_string_view sv, size_type pos = 0) const noexcept -> size_type
    {
        auto const* str = data();
        if (pos < size()) {
            auto const* last = str + size();
            for (auto const* s = str + pos; s != last; ++s) {
                if (Traits::find(sv.data(), sv.size(), *s) == nullptr) {
                    return static_cast<size_type>(s - str);
                }
            }
        }
        return npos;
    }

    [[nodiscard]] constexpr auto find_first_not_of(Char c, size_type pos = 0) const noexcept -> size_type
    {
        if (pos < size()) {
            auto const* last = data() + size();
            for (auto const* s = data() + pos; s != last; ++s) {
                if (!Traits::eq(*s, c)) {
                    return static_cast<size_type>(s - data());
                }
            }
        }
        return npos;
    }

    [[nodiscard]] constexpr auto find_first_not_of(Char const* s, size_type pos, size_type count) const -> size_type
    {
        return find_first_not_of({s, count}, pos);
    }

    [[nodiscard]] constexpr auto find_first_not_of(Char const* s, size_type pos = 0) const -> size_type
    {
        return find_first_not_of({s, traits_type::length(s)}, pos);
    }

    [[nodiscard]] constexpr auto find_last_of(basic_string_view v, size_type pos = npos) const noexcept -> size_type
    {
        auto offset = etl::clamp<size_type>(pos, 0, size() - 1);
        do { // NOLINT(cppcoreguidelines-avoid-do-while)
            auto const current = unsafe_at(offset);
            for (auto const ch : v) {
                if (ch == current) {
                    return offset;
                }
            }
        } while (offset-- != 0);
 
        return npos;
    }

    [[nodiscard]] constexpr auto find_last_of(Char c, size_type pos = npos) const noexcept -> size_type
    {
        return find_last_of(basic_string_view(&c, 1), pos);
    }

    constexpr auto find_last_of(Char const* s, size_type pos, size_type count) const -> size_type
    {
        return find_last_of(basic_string_view(s, count), pos);
    }

    constexpr auto find_last_of(Char const* s, size_type pos = npos) const -> size_type
    {
        return find_last_of(basic_string_view(s), pos);
    }

    [[nodiscard]] constexpr auto find_last_not_of(basic_string_view v, size_type pos = npos) const noexcept -> size_type
    {
        auto offset = etl::clamp<size_type>(pos, 0, size() - 1);
        do { // NOLINT(cppcoreguidelines-avoid-do-while)
            auto equals = [&](auto ch) { return ch == unsafe_at(offset); };
            if (etl::none_of(v.begin(), v.end(), equals)) {
                return offset;
            }
        } while (offset-- != 0);
 
        return npos;
    }

    [[nodiscard]] constexpr auto find_last_not_of(Char c, size_type pos = npos) const noexcept -> size_type
    {
        return find_last_not_of(basic_string_view(&c, 1), pos);
    }

    [[nodiscard]] constexpr auto find_last_not_of(const_pointer s, size_type pos, size_type count) const -> size_type
    {
        return find_last_not_of(basic_string_view(s, count), pos);
    }

    [[nodiscard]] constexpr auto find_last_not_of(const_pointer s, size_type pos = npos) const -> size_type
    {
        return find_last_not_of(basic_string_view(s), pos);
    }

    [[nodiscard]] constexpr auto contains(basic_string_view sv) const noexcept -> bool { return find(sv) != npos; }

    [[nodiscard]] constexpr auto contains(Char c) const noexcept -> bool { return find(c) != npos; }

    [[nodiscard]] constexpr auto contains(Char const* s) const -> bool { return find(s) != npos; }

    static constexpr size_type npos = size_type(-1);
 
private:
    [[nodiscard]] constexpr auto unsafe_at(size_type pos) const -> const_reference { return _begin[pos]; }
 
    const_pointer _begin = nullptr;
    size_type _size      = 0;
};

using string_view = basic_string_view<char, etl::char_traits<char>>;

using wstring_view = basic_string_view<wchar_t, etl::char_traits<wchar_t>>;

using u8string_view = basic_string_view<char8_t, etl::char_traits<char8_t>>;

using u16string_view = basic_string_view<char16_t, etl::char_traits<char16_t>>;

using u32string_view = basic_string_view<char32_t, etl::char_traits<char32_t>>;
 
inline namespace literals {
inline namespace string_view_literals {

[[nodiscard]] constexpr auto operator""_sv(char const* str, etl::size_t len) noexcept -> etl::string_view
{
    return {str, len};
}

[[nodiscard]] constexpr auto operator""_sv(wchar_t const* str, etl::size_t len) noexcept -> etl::wstring_view
{
    return {str, len};
}

[[nodiscard]] constexpr auto operator""_sv(char8_t const* str, etl::size_t len) noexcept -> etl::u8string_view
{
    return {str, len};
}

[[nodiscard]] constexpr auto operator""_sv(char16_t const* str, etl::size_t len) noexcept -> etl::u16string_view
{
    return {str, len};
}

[[nodiscard]] constexpr auto operator""_sv(char32_t const* str, etl::size_t len) noexcept -> etl::u32string_view
{
    return {str, len};
}
 
} // namespace string_view_literals
} // namespace literals
 
namespace ranges {
 
template <typename Char, typename Traits>
inline constexpr bool enable_borrowed_range<etl::basic_string_view<Char, Traits>> = true;
 
} // namespace ranges

template <typename Char, typename Traits>
[[nodiscard]] constexpr auto
operator==(basic_string_view<Char, Traits> lhs, type_identity_t<basic_string_view<Char, Traits>> rhs) noexcept -> bool
{
    if (lhs.size() != rhs.size()) {
        return false;
    }
    return lhs.compare(rhs) == 0;
}

template <typename Char, typename Traits>
[[nodiscard]] constexpr auto
operator<(basic_string_view<Char, Traits> lhs, basic_string_view<Char, Traits> rhs) noexcept -> bool
{
    return lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
}
 
template <typename Char, typename Traits, int = 1>
[[nodiscard]] constexpr auto
operator<(type_identity_t<basic_string_view<Char, Traits>> lhs, basic_string_view<Char, Traits> rhs) noexcept -> bool
{
    return lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
}
 
template <typename Char, typename Traits, int = 2>
[[nodiscard]] constexpr auto
operator<(basic_string_view<Char, Traits> lhs, type_identity_t<basic_string_view<Char, Traits>> rhs) noexcept -> bool
{
    return lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
}

template <typename Char, typename Traits>
[[nodiscard]] constexpr auto
operator<=(basic_string_view<Char, Traits> lhs, basic_string_view<Char, Traits> rhs) noexcept -> bool
{
    return (lhs < rhs) or (lhs == rhs);
}
 
template <typename Char, typename Traits, int = 1>
[[nodiscard]] constexpr auto
operator<=(type_identity_t<basic_string_view<Char, Traits>> lhs, basic_string_view<Char, Traits> rhs) noexcept -> bool
{
    return (lhs < rhs) or (lhs == rhs);
}
 
template <typename Char, typename Traits, int = 2>
[[nodiscard]] constexpr auto
operator<=(basic_string_view<Char, Traits> lhs, type_identity_t<basic_string_view<Char, Traits>> rhs) noexcept -> bool
{
    return (lhs < rhs) or (lhs == rhs);
}

template <typename Char, typename Traits>
[[nodiscard]] constexpr auto
operator>(basic_string_view<Char, Traits> lhs, basic_string_view<Char, Traits> rhs) noexcept -> bool
{
    return !(lhs < rhs) and !(lhs == rhs);
}
 
template <typename Char, typename Traits, int = 1>
[[nodiscard]] constexpr auto
operator>(type_identity_t<basic_string_view<Char, Traits>> lhs, basic_string_view<Char, Traits> rhs) noexcept -> bool
{
    return !(lhs < rhs) and !(lhs == rhs);
}
 
template <typename Char, typename Traits, int = 2>
[[nodiscard]] constexpr auto
operator>(basic_string_view<Char, Traits> lhs, type_identity_t<basic_string_view<Char, Traits>> rhs) noexcept -> bool
{
    return !(lhs < rhs) and !(lhs == rhs);
}

template <typename Char, typename Traits>
[[nodiscard]] constexpr auto
operator>=(basic_string_view<Char, Traits> lhs, basic_string_view<Char, Traits> rhs) noexcept -> bool
{
    return lhs > rhs or lhs == rhs;
}
 
template <typename Char, typename Traits, int = 1>
[[nodiscard]] constexpr auto
operator>=(type_identity_t<basic_string_view<Char, Traits>> lhs, basic_string_view<Char, Traits> rhs) noexcept -> bool
{
    return lhs > rhs or lhs == rhs;
}
 
template <typename Char, typename Traits, int = 2>
[[nodiscard]] constexpr auto
operator>=(basic_string_view<Char, Traits> lhs, type_identity_t<basic_string_view<Char, Traits>> rhs) noexcept -> bool
{
    return lhs > rhs or lhs == rhs;
}
 
} // namespace etl
 
#endif // TETL_BASIC_STRING_VIEW_STRING_VIEW_HPP