StringView.h

Go to the documentation of this file.

#ifndef ZSERIO_STRING_VIEW_H_INC
#define ZSERIO_STRING_VIEW_H_INC
 
#include <algorithm>
#include <cstddef>
#include <limits>
#include <memory>
#include <utility>
 
#include "zserio/CppRuntimeException.h"
#include "zserio/RebindAlloc.h"
#include "zserio/String.h"
#include "zserio/StringConvertUtil.h"
 
namespace zserio
{
 
template <typename CharT, typename Traits = std::char_traits<CharT>>
class BasicStringView
{
public:
    using traits_type = Traits;
    using value_type = CharT;
    using pointer = CharT*;
    using const_pointer = const CharT*;
    using reference = CharT&;
    using const_reference = const CharT&;
    using const_iterator = const_pointer;
    using iterator = const_iterator;
    using const_reverse_iterator = std::reverse_iterator<const_iterator>;
    using reverse_iterator = const_reverse_iterator;
    using size_type = size_t;
    using difference_type = ptrdiff_t;
 
    static constexpr const size_type npos = static_cast<size_type>(-1);
 
    constexpr BasicStringView() noexcept = default;
 
    BasicStringView(const const_pointer str) noexcept :
            m_data(str),
            m_size(Traits::length(str))
    {}
 
    constexpr BasicStringView(const const_pointer str, const size_type count) noexcept :
            m_data(str),
            m_size(count)
    {}
 
    template <typename ALLOC>
    constexpr BasicStringView(const std::basic_string<CharT, Traits, ALLOC>& str) noexcept :
            m_data(str.data()),
            m_size(str.size())
    {}
 
    ~BasicStringView() = default;
 
    BasicStringView(const BasicStringView&) noexcept = default;
    BasicStringView& operator=(const BasicStringView&) noexcept = default;
 
    BasicStringView(BasicStringView&&) noexcept = default;
    BasicStringView& operator=(BasicStringView&&) noexcept = default;
    constexpr const_iterator begin() const noexcept
    {
        return m_data;
    }
 
    constexpr const_iterator cbegin() const noexcept
    {
        return begin();
    }
 
    constexpr const_iterator end() const noexcept
    {
        return m_data + m_size;
    }
 
    constexpr const_iterator cend() const noexcept
    {
        return end();
    }
 
    constexpr const_reverse_iterator rbegin() const noexcept
    {
        return const_reverse_iterator(end());
    }
 
    constexpr const_reverse_iterator crbegin() const noexcept
    {
        return rbegin();
    }
 
    constexpr const_reverse_iterator rend() const noexcept
    {
        return const_reverse_iterator(begin());
    }
 
    constexpr const_reverse_iterator crend() const noexcept
    {
        return rend();
    }
 
    constexpr const_reference operator[](const size_type pos) const noexcept
    {
        return m_data[pos];
    }
 
    const_reference at(const size_type pos) const
    {
        if (pos >= size())
        {
            throw CppRuntimeException("StringView: Position ")
                    << pos << " out of range for view size " << size() << "!";
        }
        return m_data[pos];
    }
 
    constexpr const_reference front() const noexcept
    {
        return m_data[0];
    }
 
    constexpr const_reference back() const noexcept
    {
        return m_data[m_size - 1];
    }
 
    constexpr const_pointer data() const noexcept
    {
        return m_data;
    }
 
    constexpr size_type size() const noexcept
    {
        return m_size;
    }
 
    constexpr size_type length() const noexcept
    {
        return size();
    }
 
    constexpr size_type max_size() const noexcept
    {
        return std::numeric_limits<size_type>::max();
    }
 
    constexpr bool empty() const noexcept
    {
        return size() == 0;
    }
 
    void remove_prefix(size_type n)
    {
        m_data += n;
        m_size -= n;
    }
 
    void remove_suffix(size_type n)
    {
        m_size -= n;
    }
 
    void swap(BasicStringView& other) noexcept
    {
        std::swap(m_data, other.m_data);
        std::swap(m_size, other.m_size);
    }
 
    size_type copy(CharT* dest, size_type count, size_type pos = 0) const
    {
        if (pos > size())
        {
            throw CppRuntimeException("StringView: Position ")
                    << pos << " out of range for view size " << size() << "!";
        }
        const size_t rcount = std::min(count, size() - pos);
        Traits::copy(dest, data() + pos, rcount);
        return rcount;
    }
 
    BasicStringView substr(size_type pos = 0, size_type count = npos) const
    {
        if (pos > size())
        {
            throw CppRuntimeException("StringView: Position ")
                    << pos << " out of range for view size " << size() << "!";
        }
        const size_t rcount = std::min(count, size() - pos);
        return BasicStringView(m_data + pos, rcount);
    }
 
    int compare(BasicStringView other) const noexcept
    {
        const size_type rlen = std::min(size(), other.size());
        const int cmp = Traits::compare(data(), other.data(), rlen);
 
        if (cmp != 0)
        {
            return cmp;
        }
 
        if (size() < other.size())
        {
            return -1;
        }
        else if (size() > other.size())
        {
            return 1;
        }
        else
        {
            return 0;
        }
    }
 
    int compare(size_type pos1, size_type count1, BasicStringView other) const
    {
        return substr(pos1, count1).compare(other);
    }
 
    int compare(size_type pos1, size_type count1, BasicStringView other, size_type pos2, size_type count2) const
    {
        return substr(pos1, count1).compare(other.substr(pos2, count2));
    }
 
    int compare(const CharT* str) const
    {
        return compare(BasicStringView(str));
    }
 
    int compare(size_type pos1, size_type count1, const CharT* str) const
    {
        return substr(pos1, count1).compare(BasicStringView(str));
    }
 
    int compare(size_type pos1, size_type count1, const CharT* str, size_type count2) const
    {
        return substr(pos1, count1).compare(BasicStringView(str, count2));
    }
 
    size_type find(BasicStringView str, size_type pos = 0) const noexcept
    {
        if (pos >= size() || str.size() > size() - pos)
        {
            return npos; // the string cannot be there
        }
 
        if (str.size() == 0)
        {
            return pos; // zero-sized search, this defaults to the match at the beginning
        }
 
        const const_pointer startPtr = data() + pos; // where the searching will start
        const const_pointer endPtr = data() + (size() - str.size()) + 1; // where the searching will end
 
        // initial position
        const_pointer ptr = Traits::find(startPtr, static_cast<size_t>(endPtr - startPtr), str[0]);
        while (ptr)
        {
            // check if the searched string is present
            if (Traits::compare(ptr, str.data(), str.size()) == 0)
            {
                return static_cast<size_t>(ptr - data());
            }
 
            // go to next position
            ptr = Traits::find(ptr + 1, static_cast<size_t>(endPtr - ptr - 1), str[0]);
        }
 
        return npos;
    }
 
    size_type find(CharT character, size_type pos = 0) const noexcept
    {
        return find(BasicStringView(std::addressof(character), 1), pos);
    }
 
    size_type find(const CharT* str, size_type pos, size_type count) const
    {
        return find(BasicStringView(str, count), pos);
    }
 
    size_type find(const CharT* str, size_type pos = 0) const
    {
        return find(BasicStringView(str), pos);
    }
 
    size_type rfind(BasicStringView str, size_type pos = npos) const noexcept
    {
        if (str.size() > size())
        {
            return npos;
        }
 
        for (size_t p = std::min(static_cast<size_type>(size() - str.size()), pos) + 1; p > 0; --p)
        {
            if (Traits::compare(data() + p - 1, str.data(), str.size()) == 0)
            {
                return p - 1;
            }
        }
 
        return npos;
    }
 
    size_type rfind(CharT character, size_type pos = npos) const noexcept
    {
        return rfind(BasicStringView(std::addressof(character), 1), pos);
    }
 
    size_type rfind(const CharT* str, size_type pos, size_type count) const
    {
        return rfind(BasicStringView(str, count), pos);
    }
 
    size_type rfind(const CharT* str, size_type pos = npos) const
    {
        return rfind(BasicStringView(str), pos);
    }
 
    size_type find_first_of(BasicStringView str, size_type pos = 0) const noexcept
    {
        if (str.size() == 0 || pos >= size())
        {
            return npos;
        }
 
        for (size_type idx = pos; idx < size(); ++idx)
        {
            if (Traits::find(str.data(), str.size(), data()[idx]) != nullptr)
            {
                return idx;
            }
        }
 
        return npos;
    }
 
    size_type find_first_of(CharT character, size_type pos = 0) const noexcept
    {
        return find_first_of(BasicStringView(std::addressof(character), 1), pos);
    }
 
    size_type find_first_of(const CharT* str, size_type pos, size_type count) const
    {
        return find_first_of(BasicStringView(str, count), pos);
    }
 
    size_type find_first_of(const CharT* str, size_type pos = 0) const
    {
        return find_first_of(BasicStringView(str), pos);
    }
 
    size_type find_last_of(BasicStringView str, size_type pos = npos) const noexcept
    {
        if (str.empty() || empty())
        {
            return npos;
        }
 
        for (size_type idx = std::min(pos + 1, size()); idx > 0; --idx)
        {
            if (Traits::find(str.data(), str.size(), data()[idx - 1]) != nullptr)
            {
                return idx - 1;
            }
        }
 
        return npos;
    }
 
    size_type find_last_of(CharT character, size_type pos = npos) const noexcept
    {
        return find_last_of(BasicStringView(std::addressof(character), 1), pos);
    }
 
    size_type find_last_of(const CharT* str, size_type pos, size_type count) const
    {
        return find_last_of(BasicStringView(str, count), pos);
    }
 
    size_type find_last_of(const CharT* str, size_type pos = npos) const
    {
        return find_last_of(BasicStringView(str), pos);
    }
 
    size_type find_first_not_of(BasicStringView str, size_type pos = 0) const noexcept
    {
        if (str.size() == 0 || pos >= size())
        {
            return npos;
        }
 
        for (size_type idx = pos; idx < size(); ++idx)
        {
            if (Traits::find(str.data(), str.size(), data()[idx]) == nullptr)
            {
                return idx;
            }
        }
 
        return npos;
    }
 
    size_type find_first_not_of(CharT character, size_type pos = 0) const noexcept
    {
        return find_first_not_of(BasicStringView(std::addressof(character), 1), pos);
    }
 
    size_type find_first_not_of(const CharT* str, size_type pos, size_type count) const
    {
        return find_first_not_of(BasicStringView(str, count), pos);
    }
 
    size_type find_first_not_of(const CharT* str, size_type pos = 0) const
    {
        return find_first_not_of(BasicStringView(str), pos);
    }
 
    size_type find_last_not_of(BasicStringView str, size_type pos = npos) const noexcept
    {
        if (str.empty() || empty())
        {
            return npos;
        }
 
        for (size_type idx = std::min(pos + 1, size()); idx > 0; --idx)
        {
            if (Traits::find(str.data(), str.size(), data()[idx - 1]) == nullptr)
            {
                return idx - 1;
            }
        }
 
        return npos;
    }
 
    size_type find_last_not_of(CharT character, size_type pos = npos) const noexcept
    {
        return find_last_not_of(BasicStringView(std::addressof(character), 1), pos);
    }
 
    size_type find_last_not_of(const CharT* str, size_type pos, size_type count) const
    {
        return find_last_not_of(BasicStringView(str, count), pos);
    }
 
    size_type find_last_not_of(const CharT* str, size_type pos = npos) const
    {
        return find_last_not_of(BasicStringView(str), pos);
    }
 
private:
    const_pointer m_data = nullptr;
    size_type m_size = 0;
};
 
template <typename CharT, class Traits>
constexpr std::size_t const BasicStringView<CharT, Traits>::npos;
 
template <typename CharT, class Traits>
constexpr bool operator==(BasicStringView<CharT, Traits> lhs, BasicStringView<CharT, Traits> rhs) noexcept
{
    return lhs.compare(rhs) == 0;
}
 
template <typename CharT, class Traits>
constexpr bool operator!=(BasicStringView<CharT, Traits> lhs, BasicStringView<CharT, Traits> rhs) noexcept
{
    return lhs.compare(rhs) != 0;
}
 
template <typename CharT, class Traits>
constexpr bool operator<(BasicStringView<CharT, Traits> lhs, BasicStringView<CharT, Traits> rhs) noexcept
{
    return lhs.compare(rhs) < 0;
}
 
template <typename CharT, class Traits>
constexpr bool operator<=(BasicStringView<CharT, Traits> lhs, BasicStringView<CharT, Traits> rhs) noexcept
{
    return lhs.compare(rhs) <= 0;
}
 
template <typename CharT, class Traits>
constexpr bool operator>(BasicStringView<CharT, Traits> lhs, BasicStringView<CharT, Traits> rhs) noexcept
{
    return lhs.compare(rhs) > 0;
}
 
template <typename CharT, class Traits>
constexpr bool operator>=(BasicStringView<CharT, Traits> lhs, BasicStringView<CharT, Traits> rhs) noexcept
{
    return lhs.compare(rhs) >= 0;
}
 
template <typename CharT, size_t N>
constexpr BasicStringView<CharT> makeStringView(const CharT (&str)[N])
{
    static_assert(N != 0, "Zero length arrays C++ extension is not supported!");
    return BasicStringView<CharT>(str, str[N - 1] == CharT() ? (N - 1) : N);
}
 
template <typename CharT, typename Traits, typename ALLOC = std::allocator<char>>
std::basic_string<CharT, Traits, RebindAlloc<ALLOC, CharT>> stringViewToString(
        BasicStringView<CharT, Traits> stringView, const ALLOC& allocator = ALLOC())
{
    return std::basic_string<CharT, Traits, RebindAlloc<ALLOC, CharT>>(
            stringView.data(), stringView.size(), allocator);
}
 
template <typename CharT, typename Traits, typename ALLOC = std::allocator<char>>
std::basic_string<CharT, Traits, ALLOC>& operator+=(
        std::basic_string<CharT, Traits, ALLOC>& first, BasicStringView<CharT, Traits> second)
{
    return first.append(second.data(), second.size());
}
 
using StringView = BasicStringView<char, std::char_traits<char>>;
 
template <typename ALLOC>
string<ALLOC> toString(StringView value, const ALLOC& allocator = ALLOC())
{
    return stringViewToString(value, allocator);
}
 
inline CppRuntimeException& operator<<(CppRuntimeException& exception, StringView view)
{
    exception.append(view.data(), view.size());
    return exception;
}
 
inline namespace literals
{
 
constexpr ::zserio::StringView operator"" _sv(const char* str, std::size_t len) noexcept
{
    return ::zserio::StringView(str, len);
}
 
} // namespace literals
 
} // namespace zserio
 
#endif // ZSERIO_STRING_VIEW_H_INC