view release on metacpan or  search on metacpan

src/panda/basic_string_view.h  view on Meta::CPAN

    }

    template <size_t SIZE>
    size_t rfind (const CharT (&s)[SIZE], size_t pos = 0) const {
        return rfind(s, pos, SIZE-1);
    }


    size_t find_first_of (basic_string_view v, size_t pos = 0) const {
        return find_first_of(v._str, pos, v._length);
    }

    size_t find_first_of (CharT ch, size_t pos = 0) const {
        return find(ch, pos);
    }

    size_t find_first_of (const CharT* s, size_t pos, size_t count) const {
        if (count == 0) return npos;
        const CharT* end = _str + _length;
        for (const CharT* ptr = _str + pos; ptr < end; ++ptr) if (traits_type::find(s, count, *ptr)) return ptr - _str;
        return npos;
    }

    template<class _CharT, typename = typename std::enable_if<std::is_same<_CharT, CharT>::value>::type>
    size_t find_first_of (const _CharT* const& s, size_t pos = 0) const {
        return find_first_of(s, pos, traits_type::length(s));
    }

    template <size_t SIZE>
    size_t find_first_of (const CharT (&s)[SIZE], size_t pos = 0) const {
        return find_first_of(s, pos, SIZE-1);
    }


    size_t find_last_of (basic_string_view v, size_t pos = 0) const {
        return find_last_of(v._str, pos, v._length);
    }

    size_t find_last_of (CharT ch, size_t pos = 0) const {
        return rfind(ch, pos);
    }

    size_t find_last_of (const CharT* s, size_t pos, size_t count) const {
        if (count == 0) return npos;
        for (const CharT* ptr = _str + (pos >= _length ? (_length - 1) : pos); ptr >= _str; --ptr)
            if (traits_type::find(s, count, *ptr)) return ptr - _str;
        return npos;
    }

    template<class _CharT, typename = typename std::enable_if<std::is_same<_CharT, CharT>::value>::type>
    size_t find_last_of (const _CharT* const& s, size_t pos = 0) const {
        return find_last_of(s, pos, traits_type::length(s));
    }

    template <size_t SIZE>
    size_t find_last_of (const CharT (&s)[SIZE], size_t pos = 0) const {
        return find_last_of(s, pos, SIZE-1);
    }


    size_t find_first_not_of (basic_string_view v, size_t pos = 0) const {
        return find_first_not_of(v._str, pos, v._length);
    }

    size_t find_first_not_of (CharT ch, size_t pos = 0) const {
        const CharT* end = _str + _length;
        for (const CharT* ptr = _str + pos; ptr < end; ++ptr) if (!traits_type::eq(*ptr, ch)) return ptr - _str;
        return npos;
    }

    size_t find_first_not_of (const CharT* s, size_t pos, size_t count) const {
        if (count == 0) return pos >= _length ? npos : pos;
        const CharT* end = _str + _length;
        for (const CharT* ptr = _str + pos; ptr < end; ++ptr) if (!traits_type::find(s, count, *ptr)) return ptr - _str;
        return npos;
    }

    template<class _CharT, typename = typename std::enable_if<std::is_same<_CharT, CharT>::value>::type>
    size_t find_first_not_of (const _CharT* const& s, size_t pos = 0) const {
        return find_first_not_of(s, pos, traits_type::length(s));
    }

    template <size_t SIZE>
    size_t find_first_not_of (const CharT (&s)[SIZE], size_t pos = 0) const {
        return find_first_not_of(s, pos, SIZE-1);
    }


    size_t find_last_not_of (basic_string_view v, size_t pos = 0) const {
        return find_last_not_of(v._str, pos, v._length);
    }

    size_t find_last_not_of (CharT ch, size_t pos = 0) const {
        for (const CharT* ptr = _str + (pos >= _length ? (_length - 1) : pos); ptr >= _str; --ptr)
            if (!traits_type::eq(*ptr, ch)) return ptr - _str;
        return npos;
    }

    size_t find_last_not_of (const CharT* s, size_t pos, size_t count) const {
        if (count == 0) return pos >= _length ? (_length-1) : pos;
        for (const CharT* ptr = _str + (pos >= _length ? (_length - 1) : pos); ptr >= _str; --ptr)
            if (!traits_type::find(s, count, *ptr)) return ptr - _str;
        return npos;
    }

    template<class _CharT, typename = typename std::enable_if<std::is_same<_CharT, CharT>::value>::type>
    size_t find_last_not_of (const _CharT* const& s, size_t pos = 0) const {
        return find_last_not_of(s, pos, traits_type::length(s));
    }

    template <size_t SIZE>
    size_t find_last_not_of (const CharT (&s)[SIZE], size_t pos = 0) const {
        return find_last_not_of(s, pos, SIZE-1);
    }


private:

    static int _compare (const CharT* ptr1, size_t len1, const CharT* ptr2, size_t len2) {
        int r = traits_type::compare(ptr1, ptr2, std::min(len1, len2));
        if (!r) r = (len1 < len2) ? -1 : (len1 > len2 ? 1 : 0);
        return r;
    }

};

template <class C, class T> const C basic_string_view<C,T>::TERMINAL = C();

template <class C, class T> inline bool operator== (basic_string_view<C,T> lhs, basic_string_view<C,T> rhs) { return lhs.compare(rhs) == 0; }
template <class C, class T> inline bool operator== (const C* lhs, basic_string_view<C,T> rhs)               { return rhs.compare(lhs) == 0; }
template <class C, class T> inline bool operator== (basic_string_view<C,T> lhs, const C* rhs)               { return lhs.compare(rhs) == 0; }

template <class C, class T> inline bool operator!= (basic_string_view<C,T> lhs, basic_string_view<C,T> rhs) { return lhs.compare(rhs) != 0; }
template <class C, class T> inline bool operator!= (const C* lhs, basic_string_view<C,T> rhs)               { return rhs.compare(lhs) != 0; }
template <class C, class T> inline bool operator!= (basic_string_view<C,T> lhs, const C* rhs)               { return lhs.compare(rhs) != 0; }

template <class C, class T> inline bool operator<  (basic_string_view<C,T> lhs, basic_string_view<C,T> rhs) { return lhs.compare(rhs) < 0; }
template <class C, class T> inline bool operator<  (const C* lhs, basic_string_view<C,T> rhs)               { return rhs.compare(lhs) > 0; }
template <class C, class T> inline bool operator<  (basic_string_view<C,T> lhs, const C* rhs)               { return lhs.compare(rhs) < 0; }

template <class C, class T> inline bool operator<= (basic_string_view<C,T> lhs, basic_string_view<C,T> rhs) { return lhs.compare(rhs) <= 0; }
template <class C, class T> inline bool operator<= (const C* lhs, basic_string_view<C,T> rhs)               { return rhs.compare(lhs) >= 0; }
template <class C, class T> inline bool operator<= (basic_string_view<C,T> lhs, const C* rhs)               { return lhs.compare(rhs) <= 0; }

template <class C, class T> inline bool operator>  (basic_string_view<C,T> lhs, basic_string_view<C,T> rhs) { return lhs.compare(rhs) > 0; }
template <class C, class T> inline bool operator>  (const C* lhs, basic_string_view<C,T> rhs)               { return rhs.compare(lhs) < 0; }
template <class C, class T> inline bool operator>  (basic_string_view<C,T> lhs, const C* rhs)               { return lhs.compare(rhs) > 0; }

template <class C, class T> inline bool operator>= (basic_string_view<C,T> lhs, basic_string_view<C,T> rhs) { return lhs.compare(rhs) >= 0; }
template <class C, class T> inline bool operator>= (const C* lhs, basic_string_view<C,T> rhs)               { return rhs.compare(lhs) <= 0; }
template <class C, class T> inline bool operator>= (basic_string_view<C,T> lhs, const C* rhs)               { return lhs.compare(rhs) >= 0; }

template <class C, class T>
inline std::basic_ostream<C,T>& operator<< (std::basic_ostream<C,T>& os, basic_string_view<C,T> v) {
    return os.write(v.data(), v.length());
}

}