basic_string_view.hpp

Go to the documentation of this file.

#ifndef BSL_BASIC_STRING_VIEW_HPP
#define BSL_BASIC_STRING_VIEW_HPP

#include "char_traits.hpp"
#include "contiguous_iterator.hpp"
#include "cstdint.hpp"
#include "debug.hpp"
#include "min_of.hpp"
#include "npos.hpp"
#include "numeric_limits.hpp"
#include "reverse_iterator.hpp"

// TODO:
// - Need to implement the find functions. These need the safe_int class as
//   there is a lot of math that could result in overflow that needs to be
//   accounted for.
//

namespace bsl
{
    template<typename CharT, typename Traits = char_traits<CharT>>
    class basic_string_view final    // NOLINT
    {
    public:
        using value_type = CharT const;
        using size_type = bsl::uintmax;
        using difference_type = bsl::uintmax;
        using reference_type = CharT const &;
        using const_reference_type = CharT const &;
        using pointer_type = CharT const *;
        using const_pointer_type = CharT const *;
        using iterator_type = contiguous_iterator<CharT const>;
        using const_iterator_type = contiguous_iterator<CharT const>;
        using reverse_iterator_type = reverse_iterator<iterator_type>;
        using const_reverse_iterator_type = reverse_iterator<const_iterator_type>;

        constexpr basic_string_view() noexcept = default;

        constexpr basic_string_view(pointer_type const s) noexcept    // PRQA S 2180 // NOLINT
            : m_ptr{s}, m_count{Traits::length(s)}
        {
            if ((nullptr == m_ptr) || (0U == m_count)) {
                *this = basic_string_view{};
            }
        }

        constexpr basic_string_view &
        operator=(pointer_type const s) &noexcept
        {
            *this = basic_string_view{s};
            return *this;
        }

        [[nodiscard]] constexpr pointer_type
        at_if(size_type const index) noexcept
        {
            if ((nullptr == m_ptr) || (index >= m_count)) {
                return nullptr;
            }

            return &m_ptr[index];    // PRQA S 4024 // NOLINT
        }

        [[nodiscard]] constexpr const_pointer_type
        at_if(size_type const index) const noexcept
        {
            if ((nullptr == m_ptr) || (index >= m_count)) {
                return nullptr;
            }

            return &m_ptr[index];    // NOLINT
        }

        [[nodiscard]] constexpr pointer_type
        front_if() noexcept
        {
            return this->at_if(0U);
        }

        [[nodiscard]] constexpr const_pointer_type
        front_if() const noexcept
        {
            return this->at_if(0U);
        }

        [[nodiscard]] constexpr pointer_type
        back_if() noexcept
        {
            return this->at_if((m_count > 0U) ? (m_count - 1U) : 0U);
        }

        [[nodiscard]] constexpr const_pointer_type
        back_if() const noexcept
        {
            return this->at_if((m_count > 0U) ? (m_count - 1U) : 0U);
        }

        [[nodiscard]] constexpr pointer_type
        data() noexcept
        {
            return m_ptr;
        }

        [[nodiscard]] constexpr const_pointer_type
        data() const noexcept
        {
            return m_ptr;
        }

        [[nodiscard]] constexpr iterator_type
        begin() noexcept
        {
            return iterator_type{m_ptr, m_count, 0U};
        }

        [[nodiscard]] constexpr const_iterator_type
        begin() const noexcept
        {
            return const_iterator_type{m_ptr, m_count, 0U};
        }

        [[nodiscard]] constexpr const_iterator_type
        cbegin() const noexcept
        {
            return const_iterator_type{m_ptr, m_count, 0U};
        }

        [[nodiscard]] constexpr iterator_type
        iter(size_type const i) noexcept
        {
            return iterator_type{m_ptr, m_count, i};
        }

        [[nodiscard]] constexpr const_iterator_type
        iter(size_type const i) const noexcept
        {
            return const_iterator_type{m_ptr, m_count, i};
        }

        [[nodiscard]] constexpr const_iterator_type
        citer(size_type const i) const noexcept
        {
            return const_iterator_type{m_ptr, m_count, i};
        }

        [[nodiscard]] constexpr iterator_type
        end() noexcept
        {
            return iterator_type{m_ptr, m_count, m_count};
        }

        [[nodiscard]] constexpr const_iterator_type
        end() const noexcept
        {
            return const_iterator_type{m_ptr, m_count, m_count};
        }

        [[nodiscard]] constexpr const_iterator_type
        cend() const noexcept
        {
            return const_iterator_type{m_ptr, m_count, m_count};
        }

        [[nodiscard]] constexpr reverse_iterator_type
        rbegin() noexcept
        {
            return reverse_iterator_type{this->end()};
        }

        [[nodiscard]] constexpr const_reverse_iterator_type
        rbegin() const noexcept
        {
            return const_reverse_iterator_type{this->end()};
        }

        [[nodiscard]] constexpr const_reverse_iterator_type
        crbegin() const noexcept
        {
            return const_reverse_iterator_type{this->cend()};
        }

        [[nodiscard]] constexpr reverse_iterator_type
        riter(size_type const i) noexcept
        {
            size_type const ai{(i >= m_count) ? m_count : (i + 1U)};
            return reverse_iterator_type{this->iter(ai)};
        }

        [[nodiscard]] constexpr const_reverse_iterator_type
        riter(size_type const i) const noexcept
        {
            size_type const ai{(i >= m_count) ? m_count : (i + 1U)};
            return const_reverse_iterator_type{this->iter(ai)};
        }

        [[nodiscard]] constexpr const_reverse_iterator_type
        criter(size_type const i) const noexcept
        {
            size_type const ai{(i >= m_count) ? m_count : (i + 1U)};
            return const_reverse_iterator_type{this->citer(ai)};
        }

        [[nodiscard]] constexpr reverse_iterator_type
        rend() noexcept
        {
            return reverse_iterator_type{this->begin()};
        }

        [[nodiscard]] constexpr const_reverse_iterator_type
        rend() const noexcept
        {
            return const_reverse_iterator_type{this->begin()};
        }

        [[nodiscard]] constexpr const_reverse_iterator_type
        crend() const noexcept
        {
            return const_reverse_iterator_type{this->cbegin()};
        }

        [[nodiscard]] constexpr bool
        empty() const noexcept
        {
            return 0U == m_count;
        }

        [[nodiscard]] constexpr size_type
        size() const noexcept
        {
            return m_count;
        }

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

        [[nodiscard]] static constexpr size_type
        max_size() noexcept
        {
            return numeric_limits<size_type>::max() / sizeof(CharT);
        }

        [[nodiscard]] constexpr size_type
        size_bytes() const noexcept
        {
            return m_count * sizeof(CharT);
        }

        [[maybe_unused]] constexpr basic_string_view &
        remove_prefix(size_type const n) noexcept
        {
            if (n >= this->size()) {
                *this = basic_string_view{};
            }

            *this = basic_string_view{this->at_if(n), this->size() - n};
            return *this;
        }

        [[maybe_unused]] constexpr basic_string_view &
        remove_suffix(size_type const n) noexcept
        {
            if (n >= this->size()) {
                *this = basic_string_view{};
            }

            *this = basic_string_view{this->at_if(0U), this->size() - n};
            return *this;
        }

        [[nodiscard]] constexpr basic_string_view
        substr(size_type const pos = 0U, size_type const count = npos) const noexcept
        {
            if (pos >= this->size()) {
                return basic_string_view{};
            }

            return basic_string_view{this->at_if(pos), min_of(count, this->size() - pos)};
        }

        [[nodiscard]] constexpr bsl::int32
        compare(basic_string_view const &str) const noexcept
        {
            return Traits::compare(this->data(), str.data(), min_of(this->size(), str.size()));
        }

        [[nodiscard]] constexpr bsl::int32
        compare(                      // --
            size_type const pos,      // --
            size_type const count,    // --
            basic_string_view const &str) const noexcept
        {
            return this->substr(pos, count).compare(str);
        }

        [[nodiscard]] constexpr bsl::int32
        compare(                             // --
            size_type pos1,                  // --
            size_type count1,                // --
            basic_string_view const &str,    // --
            size_type pos2,                  // --
            size_type count2) const noexcept
        {
            return this->substr(pos1, count1).compare(str.substr(pos2, count2));
        }

        [[nodiscard]] constexpr bsl::int32
        compare(pointer_type const str) const noexcept
        {
            return this->compare(basic_string_view{str});
        }

        [[nodiscard]] constexpr bsl::int32
        compare(size_type pos, size_type count, pointer_type const str) const noexcept
        {
            return this->substr(pos, count).compare(basic_string_view{str});
        }

        [[nodiscard]] constexpr bsl::int32
        compare(                       // --
            size_type pos,             // --
            size_type count1,          // --
            pointer_type const str,    // --
            size_type count2) const noexcept
        {
            return this->compare(pos, count1, basic_string_view{str}, 0, count2);
        }

        [[nodiscard]] constexpr bool
        starts_with(basic_string_view const &str) const noexcept
        {
            if (this->size() < str.size()) {
                return false;
            }

            return this->substr(0U, str.size()) == str;
        }

        [[nodiscard]] constexpr bool
        starts_with(value_type const c) const noexcept
        {
            if (auto *const ptr = this->front_if()) {
                return Traits::eq(*ptr, c);
            }

            return false;
        }

        [[nodiscard]] constexpr bool
        starts_with(pointer_type const str) const noexcept
        {
            return this->starts_with(basic_string_view{str});
        }

        [[nodiscard]] constexpr bool
        ends_with(basic_string_view const &str) const noexcept
        {
            if (this->size() < str.size()) {
                return false;
            }

            return this->compare(this->size() - str.size(), npos, str) == 0;
        }

        [[nodiscard]] constexpr bool
        ends_with(value_type const c) const noexcept
        {
            if (auto *const ptr = this->back_if()) {
                return Traits::eq(*ptr, c);
            }

            return false;
        }

        [[nodiscard]] constexpr bool
        ends_with(pointer_type const str) const noexcept
        {
            return this->ends_with(basic_string_view{str});
        }

    private:
        constexpr basic_string_view(pointer_type const s, size_type const count) noexcept
            : m_ptr{s}, m_count{count}
        {
            if ((nullptr == m_ptr) || (0U == m_count)) {
                *this = basic_string_view{};
            }
        }

        pointer_type m_ptr;
        size_type m_count;
    };

    template<typename CharT, typename Traits>
    constexpr bool
    operator==(
        bsl::basic_string_view<CharT, Traits> const &lhs,
        bsl::basic_string_view<CharT, Traits> const &rhs) noexcept
    {
        if (lhs.size() != rhs.size()) {
            return false;
        }

        return lhs.compare(rhs) == 0;
    }

    template<typename CharT, typename Traits>
    constexpr bool
    operator==(bsl::basic_string_view<CharT, Traits> const &lhs, CharT const *const rhs) noexcept
    {
        return lhs == bsl::basic_string_view<CharT, Traits>{rhs};
    }

    template<typename CharT, typename Traits>
    constexpr bool
    operator==(CharT const *const lhs, bsl::basic_string_view<CharT, Traits> const &rhs) noexcept
    {
        return bsl::basic_string_view<CharT, Traits>{lhs} == rhs;
    }

    template<typename CharT, typename Traits>
    constexpr bool
    operator!=(
        bsl::basic_string_view<CharT, Traits> const &lhs,
        bsl::basic_string_view<CharT, Traits> const &rhs) noexcept
    {
        return !(lhs == rhs);
    }

    template<typename CharT, typename Traits>
    constexpr bool
    operator!=(bsl::basic_string_view<CharT, Traits> const &lhs, CharT const *const rhs) noexcept
    {
        return !(lhs == rhs);
    }

    template<typename CharT, typename Traits>
    constexpr bool
    operator!=(CharT const *const lhs, bsl::basic_string_view<CharT, Traits> const &rhs) noexcept
    {
        return !(lhs == rhs);
    }

    template<typename OUT, typename CharT>
    constexpr void
    fmt_impl(OUT &&o, fmt_options const &ops, basic_string_view<CharT> const &str) noexcept
    {
        details::fmt_impl_align_pre(o, ops, str.length(), true);
        o.write(str.data());
        details::fmt_impl_align_suf(o, ops, str.length(), true);
    }

    template<typename T, typename CharT>
    [[maybe_unused]] constexpr out<T>
    operator<<(out<T> const o, basic_string_view<CharT> const &str) noexcept
    {
        if constexpr (o.empty()) {
            return o;
        }

        o.write(str.data());
        return o;
    }
}

#endif