basic_string_view.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_STRING_BASIC_STRING_VIEW_HPP__
#define NEFORCE_CORE_STRING_BASIC_STRING_VIEW_HPP__

 
#include "NeForce/core/interface/iiterator.hpp"
#include "NeForce/core/string/char_traits.hpp"
#include "NeForce/core/string/char_types.hpp"
NEFORCE_BEGIN_NAMESPACE__


template <typename CharT, typename Traits = char_traits<CharT>>
class basic_string_view;
 

template <typename Traits>
struct basic_string_view_iterator : iiterator<basic_string_view_iterator<Traits>> {
public:
    using container_type = basic_string_view<typename Traits::char_type, Traits>; 
    using value_type = typename container_type::value_type;                       
    using size_type = typename container_type::size_type;                         
    using difference_type = typename container_type::difference_type;             
    using iterator_category = contiguous_iterator_tag;                            
    using reference = typename container_type::const_reference;                   
    using pointer = typename container_type::const_pointer;                       
 
private:
    pointer data_ = nullptr; 
    size_t size_ = 0;        
    size_t idx_ = 0;         
 
public:
    constexpr basic_string_view_iterator() noexcept = default;
    NEFORCE_CONSTEXPR20 ~basic_string_view_iterator() = default;
 
    constexpr basic_string_view_iterator(const basic_string_view_iterator&) noexcept = default;
    constexpr basic_string_view_iterator& operator=(const basic_string_view_iterator&) noexcept = default;
    constexpr basic_string_view_iterator(basic_string_view_iterator&&) noexcept = default;
    constexpr basic_string_view_iterator& operator=(basic_string_view_iterator&&) noexcept = default;

    constexpr basic_string_view_iterator(const pointer data, const size_t size, const size_t off) noexcept :
    data_(data),
    size_(size),
    idx_(off) {}

    NEFORCE_NODISCARD constexpr reference dereference() const noexcept {
        NEFORCE_DEBUG_VERIFY(data_, "Attempting to dereference on a null pointer");
        NEFORCE_DEBUG_VERIFY(idx_ < size_, "Attempting to dereference out of boundary");
        return data_[idx_];
    }

    constexpr void increment() noexcept {
        NEFORCE_DEBUG_VERIFY(data_, "Attempting to increment a null pointer");
        NEFORCE_DEBUG_VERIFY(idx_ < size_, "Attempting to increment out of boundary");
        ++idx_;
    }

    constexpr void decrement() noexcept {
        NEFORCE_DEBUG_VERIFY(data_, "Attempting to decrement a null pointer");
        NEFORCE_DEBUG_VERIFY(idx_ != 0, "Attempting to decrement out of boundary");
        --idx_;
    }

    constexpr void advance(difference_type off) noexcept {
        NEFORCE_DEBUG_VERIFY(data_ || off == 0, "Attempting to advance a null pointer");
        NEFORCE_DEBUG_VERIFY((off < 0 ? idx_ >= -off : size_ - idx_ >= off), "Attempting to advance out of boundary");
        idx_ += off;
    }

    NEFORCE_NODISCARD constexpr difference_type distance_to(const basic_string_view_iterator& other) const noexcept {
        NEFORCE_DEBUG_VERIFY(data_ == other.data_ && size_ == other.size_,
                             "Attempting to distance to a different container");
        return static_cast<difference_type>(idx_ - other.idx_);
    }

    NEFORCE_NODISCARD constexpr reference operator[](const difference_type n) const noexcept { return *(*this + n); }

    NEFORCE_NODISCARD constexpr bool equal_to(const basic_string_view_iterator& rhs) const noexcept {
        NEFORCE_DEBUG_VERIFY(data_ == rhs.data_ && size_ == rhs.size_, "Attempting to equal to a different container");
        return idx_ == rhs.idx_;
    }

    NEFORCE_NODISCARD constexpr bool less_than(const basic_string_view_iterator& rhs) const noexcept {
        NEFORCE_DEBUG_VERIFY(data_ == rhs.data_ && size_ == rhs.size_, "Attempting to less than a different container");
        return idx_ < rhs.idx_;
    }

    NEFORCE_NODISCARD constexpr pointer base() const noexcept { return data_ + idx_; }
};
 

template <typename CharT, typename Traits>
class basic_string_view : public icommon<basic_string_view<CharT, Traits>> {
    static_assert(is_same_v<CharT, typename Traits::char_type>,
                  "char type of basic string view should be same with char traits.");
    static_assert(!is_array_v<CharT> && is_trivial_v<CharT> && is_standard_layout_v<CharT>,
                  "basic string view only contains non-array trivial standard-layout types.");
 
public:
    using value_type = CharT;                                                 
    using pointer = const CharT*;                                             
    using reference = const CharT&;                                           
    using const_pointer = const CharT*;                                       
    using const_reference = const CharT&;                                     
    using size_type = size_t;                                                 
    using difference_type = ptrdiff_t;                                        
    using const_iterator = basic_string_view_iterator<Traits>;                
    using iterator = const_iterator;                                          
    using const_reverse_iterator = _NEFORCE reverse_iterator<const_iterator>; 
    using reverse_iterator = const_reverse_iterator;                          
    using traits_type = Traits;                                               

    static constexpr auto npos = static_cast<size_type>(-1);
 
private:
    const_pointer data_ = nullptr; 
    size_type size_ = 0;           

    NEFORCE_NODISCARD NEFORCE_ALWAYS_INLINE constexpr size_type clamp_size(const size_type position,
                                                                           const size_type size) const noexcept {
        return _NEFORCE min(size, size_ - position);
    }
 
public:
    constexpr basic_string_view() noexcept = default;
    constexpr basic_string_view(const basic_string_view&) noexcept = default;
    constexpr basic_string_view& operator=(const basic_string_view&) noexcept = default;

    constexpr basic_string_view(const_pointer str) noexcept :
    data_(str),
    size_(Traits::length(str)) {}

    constexpr basic_string_view(const_pointer str, const size_type n) noexcept :
    data_(str),
    size_(n) {}

    template <typename Iterator, enable_if_t<is_same_v<iter_value_t<Iterator>, value_type>, int> = 0>
    constexpr basic_string_view(Iterator start, Iterator finish) :
    data_(&*start),
    size_(_NEFORCE distance(start, finish)) {}

    NEFORCE_CONSTEXPR20 ~basic_string_view() noexcept = default;

    NEFORCE_NODISCARD constexpr const_iterator begin() const noexcept { return const_iterator(data_, size_, 0); }

    NEFORCE_NODISCARD constexpr const_iterator end() const noexcept { return const_iterator(data_, size_, size_); }

    NEFORCE_NODISCARD constexpr const_iterator cbegin() const noexcept { return begin(); }

    NEFORCE_NODISCARD constexpr const_iterator cend() const noexcept { return end(); }

    NEFORCE_NODISCARD constexpr const_reverse_iterator rbegin() const noexcept { return const_reverse_iterator(end()); }

    NEFORCE_NODISCARD constexpr const_reverse_iterator rend() const noexcept { return const_reverse_iterator(begin()); }

    NEFORCE_NODISCARD constexpr const_reverse_iterator crbegin() const noexcept { return rbegin(); }

    NEFORCE_NODISCARD constexpr const_reverse_iterator crend() const noexcept { return rend(); }

    NEFORCE_NODISCARD constexpr size_type size() const noexcept { return size_; }

    NEFORCE_NODISCARD constexpr size_type max_size() const noexcept {
        return (npos - sizeof(size_type) - sizeof(void*)) / sizeof(value_type) / 4;
    }

    NEFORCE_NODISCARD constexpr size_type length() const noexcept { return size_; }

    NEFORCE_NODISCARD constexpr bool empty() const noexcept { return size_ == 0; }

    NEFORCE_NODISCARD constexpr const_pointer data() const noexcept { return data_; }

    NEFORCE_NODISCARD constexpr const_reference front() const noexcept {
        NEFORCE_DEBUG_VERIFY(!empty(), "cannot call front on empty string_view");
        return data_[0];
    }

    NEFORCE_NODISCARD constexpr const_reference back() const noexcept {
        NEFORCE_DEBUG_VERIFY(!empty(), "cannot call back on empty string_view");
        return data_[size_ - 1];
    }

    NEFORCE_NODISCARD constexpr const_reference operator[](const size_type n) const noexcept {
        NEFORCE_DEBUG_VERIFY(n <= size_, "basic string view index out of ranges.");
        return data_[n];
    }

    NEFORCE_NODISCARD constexpr const_reference at(const size_type n) const {
        NEFORCE_DEBUG_VERIFY(n <= size_, "basic string view index out of ranges.");
        return data_[n];
    }

    constexpr void remove_prefix(const size_type n) noexcept {
        NEFORCE_DEBUG_VERIFY(size_ >= n, "cannot remove prefix longer than total size");
        data_ += n;
        size_ -= n;
    }

    constexpr void remove_suffix(const size_type n) noexcept {
        NEFORCE_DEBUG_VERIFY(size_ >= n, "cannot remove suffix longer than total size");
        size_ -= n;
    }

    constexpr size_type copy(CharT* const str, size_type count, const size_type off = 0) const {
        NEFORCE_DEBUG_VERIFY(off <= size_, "basic string view index out of ranges.");
        count = clamp_size(off, count);
        Traits::copy(str, data_ + off, count);
        return count;
    }

    NEFORCE_NODISCARD constexpr basic_string_view substr(const size_type off = 0, const size_type count = npos) const {
        NEFORCE_DEBUG_VERIFY(off <= size_, "basic string view index out of ranges.");
        const size_type clamp = clamp_size(off, count);
        return basic_string_view(data_ + off, clamp);
    }

    NEFORCE_NODISCARD constexpr basic_string_view head(const size_type count = npos) const { return substr(0, count); }

    NEFORCE_NODISCARD constexpr basic_string_view tail(const size_type off = 0) const { return substr(off); }

    NEFORCE_NODISCARD constexpr basic_string_view view(const size_type off, const size_type count = npos) const {
        return substr(off, count);
    }

    NEFORCE_NODISCARD constexpr int compare(const basic_string_view view) const noexcept {
        return (char_traits_compare<Traits>) (data_, size_, view.data_, view.size_);
    }

    NEFORCE_NODISCARD constexpr int compare(const size_type off, const size_type n,
                                            const basic_string_view view) const {
        return substr(off, n).compare(view);
    }

    NEFORCE_NODISCARD constexpr int compare(const size_type off, const size_type n, const basic_string_view view,
                                            const size_type roff, const size_type count) const {
        return substr(off, n).compare(view.substr(roff, count));
    }

    NEFORCE_NODISCARD constexpr int compare(const CharT* const str) const noexcept {
        return compare(basic_string_view(str));
    }

    NEFORCE_NODISCARD constexpr int compare(const size_type off, const size_type n, const CharT* const str) const {
        return substr(off, n).compare(basic_string_view(str));
    }

    NEFORCE_NODISCARD constexpr int compare(const size_type off, const size_type n, const CharT* const str,
                                            const size_type count) const {
        return substr(off, n).compare(basic_string_view(str, count));
    }

    NEFORCE_NODISCARD NEFORCE_CONSTEXPR20 int compare_ignore_case(const basic_string_view view) const noexcept {
        const size_type min_len = _NEFORCE min(size_, view.size_);
        for (size_type i = 0; i < min_len; ++i) {
            const auto lc = _NEFORCE to_lowercase(data_[i]);
            const auto rc = _NEFORCE to_lowercase(view.data_[i]);
            if (lc != rc) {
                return (lc < rc) ? -1 : 1;
            }
        }
        if (size_ < view.size_) {
            return -1;
        }
        if (size_ > view.size_) {
            return 1;
        }
        return 0;
    }

    NEFORCE_NODISCARD NEFORCE_CONSTEXPR20 int compare_ignore_case(const_pointer str) const noexcept {
        return this->compare_ignore_case(basic_string_view(str));
    }

    NEFORCE_NODISCARD constexpr size_type find(const basic_string_view view, const size_type n = 0) const noexcept {
        return (char_traits_find<Traits>) (data_, size_, n, view.data_, view.size_);
    }

    NEFORCE_NODISCARD constexpr size_type find(const CharT chr, const size_type n = 0) const noexcept {
        return (char_traits_find_char<Traits>) (data_, size_, n, chr);
    }

    NEFORCE_NODISCARD constexpr size_type find(const CharT* const str, const size_type off,
                                               const size_type count) const noexcept {
        return (char_traits_find<Traits>) (data_, size_, off, str, count);
    }

    NEFORCE_NODISCARD constexpr size_type find(const CharT* const str, const size_type off = 0) const noexcept {
        return (char_traits_find<Traits>) (data_, size_, off, str, Traits::length(str));
    }

    NEFORCE_NODISCARD constexpr size_type rfind(const basic_string_view view,
                                                const size_type off = npos) const noexcept {
        return (char_traits_rfind<Traits>) (data_, size_, off, view.data_, view.size_);
    }

    NEFORCE_NODISCARD constexpr size_type rfind(const CharT chr, const size_type n = npos) const noexcept {
        return (char_traits_rfind_char<Traits>) (data_, size_, n, chr);
    }

    NEFORCE_NODISCARD constexpr size_type rfind(const CharT* const str, const size_type off,
                                                const size_type n) const noexcept {
        return (char_traits_rfind<Traits>) (data_, size_, off, str, n);
    }

    NEFORCE_NODISCARD constexpr size_type rfind(const CharT* const str, const size_type off = npos) const noexcept {
        return (char_traits_rfind<Traits>) (data_, size_, off, str, Traits::length(str));
    }

    NEFORCE_NODISCARD constexpr size_type find_first_of(const basic_string_view view,
                                                        const size_type off = 0) const noexcept {
        return (char_traits_find_first_of<Traits>) (data_, size_, off, view.data_, view.size_);
    }

    NEFORCE_NODISCARD constexpr size_type find_first_of(const CharT chr, const size_type off = 0) const noexcept {
        return (char_traits_find_char<Traits>) (data_, size_, off, chr);
    }

    NEFORCE_NODISCARD constexpr size_type find_first_of(const CharT* const str, const size_type off,
                                                        const size_type n) const noexcept {
        return (char_traits_find_first_of<Traits>) (data_, size_, off, str, n);
    }

    NEFORCE_NODISCARD constexpr size_type find_first_of(const CharT* const str,
                                                        const size_type off = 0) const noexcept {
        return (char_traits_find_first_of<Traits>) (data_, size_, off, str, Traits::length(str));
    }

    NEFORCE_NODISCARD constexpr size_type find_last_of(const basic_string_view view,
                                                       const size_type off = npos) const noexcept {
        return (char_traits_find_last_of<Traits>) (data_, size_, off, view.data_, view.size_);
    }

    NEFORCE_NODISCARD constexpr size_type find_last_of(const CharT chr, const size_type off = npos) const noexcept {
        return (char_traits_rfind_char<Traits>) (data_, size_, off, chr);
    }

    NEFORCE_NODISCARD constexpr size_type find_last_of(const CharT* const str, const size_type off,
                                                       const size_type n) const noexcept {
        return (char_traits_find_last_of<Traits>) (data_, size_, off, str, n);
    }

    NEFORCE_NODISCARD constexpr size_type find_last_of(const CharT* const str,
                                                       const size_type off = npos) const noexcept {
        return (char_traits_find_last_of<Traits>) (data_, size_, off, str, Traits::length(str));
    }

    NEFORCE_NODISCARD constexpr size_type find_first_not_of(const basic_string_view view,
                                                            const size_type off = 0) const noexcept {
        return (char_traits_find_first_not_of<Traits>) (data_, size_, off, view.data_, view.size_);
    }

    NEFORCE_NODISCARD constexpr size_type find_first_not_of(const CharT chr, const size_type off = 0) const noexcept {
        return (char_traits_find_not_char<Traits>) (data_, size_, off, chr);
    }

    NEFORCE_NODISCARD constexpr size_type find_first_not_of(const CharT* const str, const size_type off,
                                                            const size_type n) const noexcept {
        return (char_traits_find_first_not_of<Traits>) (data_, size_, off, str, n);
    }

    NEFORCE_NODISCARD constexpr size_type find_first_not_of(const CharT* const str,
                                                            const size_type off = 0) const noexcept {
        return (char_traits_find_first_not_of<Traits>) (data_, size_, off, str, Traits::length(str));
    }

    NEFORCE_NODISCARD constexpr size_type find_last_not_of(const basic_string_view view,
                                                           const size_type off = npos) const noexcept {
        return (char_traits_find_last_not_of<Traits>) (data_, size_, off, view.data_, view.size_);
    }

    NEFORCE_NODISCARD constexpr size_type find_last_not_of(const CharT chr, const size_type off = npos) const noexcept {
        return (char_traits_rfind_not_char<Traits>) (data_, size_, off, chr);
    }

    NEFORCE_NODISCARD constexpr size_type find_last_not_of(const CharT* const str, const size_type off,
                                                           const size_type n) const noexcept {
        return (char_traits_find_last_not_of<Traits>) (data_, size_, off, str, n);
    }

    NEFORCE_NODISCARD constexpr size_type find_last_not_of(const CharT* const str,
                                                           const size_type off = npos) const noexcept {
        return (char_traits_find_last_not_of<Traits>) (data_, size_, off, str, Traits::length(str));
    }

    NEFORCE_NODISCARD NEFORCE_CONSTEXPR20 size_type count(value_type chr, const size_type position = 0) const noexcept {
        size_type n = 0;
        for (size_type idx = position; idx < size_; ++idx) {
            if (*(data() + idx) == chr) {
                ++n;
            }
        }
        return n;
    }

    NEFORCE_NODISCARD NEFORCE_CONSTEXPR20 bool starts_with(const basic_string_view view) const noexcept {
        return view.size() <= size_ && traits_type::compare(data(), view.data(), view.size()) == 0;
    }

    NEFORCE_NODISCARD NEFORCE_CONSTEXPR20 bool starts_with(value_type chr) const noexcept {
        return !empty() && traits_type::eq(front(), chr);
    }

    NEFORCE_NODISCARD NEFORCE_CONSTEXPR20 bool starts_with(const_pointer str) const noexcept {
        return this->starts_with(basic_string_view(str));
    }

    NEFORCE_NODISCARD NEFORCE_CONSTEXPR20 bool ends_with(const basic_string_view view) const noexcept {
        const size_type view_size = view.size();
        return view_size <= size_ && traits_type::compare(data_ + size_ - view_size, view.data(), view_size) == 0;
    }

    NEFORCE_NODISCARD NEFORCE_CONSTEXPR20 bool ends_with(value_type chr) const noexcept {
        return !empty() && traits_type::eq(back(), chr);
    }

    NEFORCE_NODISCARD NEFORCE_CONSTEXPR20 bool ends_with(const_pointer str) const noexcept {
        return this->ends_with(basic_string_view(str));
    }

    NEFORCE_NODISCARD NEFORCE_CONSTEXPR20 bool contains(const basic_string_view view) const noexcept {
        return this->find(view) != npos;
    }

    NEFORCE_NODISCARD NEFORCE_CONSTEXPR20 bool contains(value_type chr) const noexcept {
        return this->find(chr) != npos;
    }

    NEFORCE_NODISCARD NEFORCE_CONSTEXPR20 bool contains(const_pointer str) const noexcept {
        return this->find(str) != npos;
    }

    NEFORCE_NODISCARD NEFORCE_CONSTEXPR20 basic_string_view trim_left() const noexcept {
        return this->trim_left_if([](value_type ch) { return _NEFORCE is_space(ch); });
    }

    NEFORCE_NODISCARD NEFORCE_CONSTEXPR20 basic_string_view trim_right() const noexcept {
        return this->trim_right_if([](value_type ch) { return _NEFORCE is_space(ch); });
    }

    NEFORCE_NODISCARD NEFORCE_CONSTEXPR20 basic_string_view trim() const noexcept {
        return this->trim_left().trim_right();
    }

    template <typename Predicate>
    NEFORCE_NODISCARD NEFORCE_CONSTEXPR20 basic_string_view trim_left_if(Predicate pred) const
            noexcept(noexcept(pred(*cbegin()))) {
        if (empty()) {
            return *this;
        }
 
        const_iterator it = cbegin();
        while (it != cend() && pred(*it)) {
            ++it;
        }
 
        if (it != cbegin()) {
            return basic_string_view(data_ + (it - cbegin()), size_ - (it - cbegin()));
        }
 
        return *this;
    }

    template <typename Predicate>
    NEFORCE_NODISCARD NEFORCE_CONSTEXPR20 basic_string_view trim_right_if(Predicate pred) const
            noexcept(noexcept(pred(*crbegin()))) {
        if (empty()) {
            return *this;
        }
 
        const_reverse_iterator rit = crbegin();
        while (rit != crend() && pred(*rit)) {
            ++rit;
        }
 
        if (rit != crbegin()) {
            return basic_string_view(data_, size_ - (rit - crbegin()));
        }
 
        return *this;
    }

    template <typename Predicate>
    NEFORCE_NODISCARD NEFORCE_CONSTEXPR20 basic_string_view trim_if(Predicate pred) const
            noexcept(noexcept(this->trim_right_if(pred)) && noexcept(this->trim_left_if(pred))) {
        return this->trim_left_if(pred).trim_right_if(pred);
    }

    NEFORCE_NODISCARD NEFORCE_CONSTEXPR20 bool equal_to(const basic_string_view str) const noexcept {
        return (char_traits_equal<Traits>) (data_, size_, str.data_, str.size_);
    }

    NEFORCE_NODISCARD NEFORCE_CONSTEXPR20 bool equal_to(const CharT* str) const noexcept {
        return equal_to(basic_string_view(str));
    }

    constexpr void swap(basic_string_view& view) noexcept {
        const basic_string_view tmp(view);
        view = *this;
        *this = tmp;
    }

    NEFORCE_NODISCARD constexpr bool less_than(const basic_string_view& rhs) const noexcept {
        return this->compare(rhs) < 0;
    }

    NEFORCE_NODISCARD constexpr size_t to_hash() const noexcept {
        return _NEFORCE FNV_hash_string(this->data(), this->length());
    }
};
 
#ifndef NEFORCE_STANDARD_17
template <typename CharT, typename Traits>
constexpr size_t basic_string_view<CharT, Traits>::npos;
#endif
 
#ifndef NEFORCE_COMPILER_CLANG_CL
extern template class basic_string_view<char>;
extern template class basic_string_view<wchar_t>;
#    ifdef NEFORCE_STANDARD_20
extern template class basic_string_view<char8_t>;
#    endif
extern template class basic_string_view<char16_t>;
extern template class basic_string_view<char32_t>;
#endif
 // StringView
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_STRING_BASIC_STRING_VIEW_HPP__