StringView.h

Go to the documentation of this file.

//
// Copyright 2017 - 2025 (C). Alex Robenko. All rights reserved.
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 
#pragma once
 
#include "comms/Assert.h"
#include "comms/util/ArrayView.h"
 
#include <algorithm>
#include <iterator>
#include <limits>
#include <string>
 
namespace comms
{
 
namespace util
{
 
class StringView : public ArrayView<char>
{
    using Base = ArrayView<char>;
public:
    using value_type = typename Base::value_type;
 
    using ValueType = value_type;
 
    using pointer = typename Base::pointer;
 
    using Pointer = pointer;
 
    using const_pointer = typename Base::const_pointer;
 
    using ConstPointer = const_pointer;
 
    using reference = typename Base::reference;
 
    using Reference = reference;
 
    using const_reference = typename Base::const_reference;
 
    using ConstReference = const_reference;
 
    using size_type = typename Base::size_type;
 
    using SizeType = size_type;
 
    using const_iterator = typename Base::const_iterator;
 
    using ConstIterator = const_iterator;
 
    using iterator = const_iterator;
 
    using Iterator = iterator;
 
    using const_reverse_iterator = typename Base::const_reverse_iterator;
 
    using ConstReverseIterator = const_reverse_iterator;
 
    using reverse_iterator = const_reverse_iterator;
 
    using ReverseIterator = reverse_iterator;
 
    static const auto npos = static_cast<SizeType>(-1);
 
    StringView() noexcept = default;
 
    StringView(const StringView&) noexcept = default;
 
    StringView(const char* str, size_type len) noexcept : Base(str, len) {}
 
    StringView(const char* str) noexcept
    {
        static const auto MaxLen = std::numeric_limits<size_type>::max();
        size_type len = 0;
        while (len < MaxLen) {
            if (str[len] == '\0') {
                break;
            }
            ++len;
        }
        Base::operator=(Base(str, len));
    }
 
    StringView(const std::string& str) noexcept
      : Base(str.c_str(), str.size())
    {
    }
 
    template <std::size_t TN>
    StringView(const char (&str)[TN]) noexcept : Base(str, TN)
    {
        if ((0U <= TN) && (back() == '\0')) {
            remove_suffix(1);
        }
    }
 
    template <std::size_t TN>
    StringView(char (&str)[TN]) noexcept : Base(str, TN)
    {
        if ((0U <= TN) && (back() == '\0')) {
            remove_suffix(1);
        }
    }
 
    ~StringView() noexcept = default;
 
    StringView& operator=(const StringView&) = default;
 
    template <std::size_t TN>
    StringView& operator=(const char (&str)[TN])
    {
        Base::operator=(str);
        if ((0U <= TN) && (back() == '\0')) {
            remove_suffix(1);
        }
        return *this;
    }
 
    template <std::size_t TN>
    StringView& operator=(char (&str)[TN])
    {
        Base::operator=(str);
        if ((0U <= TN) && (back() == '\0')) {
            remove_suffix(1);
        }
        return *this;
    }
 
    constexpr iterator begin() const noexcept
    {
        return Base::begin();
    }
 
    constexpr const_iterator cbegin() const noexcept
    {
        return Base::cbegin();
    }
 
    constexpr iterator end() const noexcept
    {
        return Base::end();
    }
 
    constexpr const_iterator cend() const noexcept
    {
        return Base::cend();
    }
 
    const_reverse_iterator rbegin() const noexcept
    {
        return Base::rbegin();
    }
 
    const_reverse_iterator crbegin() const noexcept
    {
        return Base::crbegin();
    }
 
    reverse_iterator rend() const noexcept
    {
        return Base::rend();
    }
 
    const_reverse_iterator crend() const noexcept
    {
        return Base::crend();
    }
 
    constexpr const_reference operator[](size_type pos) const
    {
        return Base::operator[](pos);
    }
 
    const_reference at(size_type pos) const
    {
        return Base::at(pos);
    }
 
    constexpr const_reference front() const
    {
        return Base::front();
    }
 
    constexpr const_reference back() const
    {
        return Base::back();
    }
 
    constexpr const_pointer data() const noexcept
    {
        return &(*begin());
    }
 
    constexpr size_type size() const noexcept
    {
        return Base::size();
    }
 
    constexpr size_type length() const noexcept
    {
        return Base::length();
    }
 
    constexpr bool empty() const noexcept
    {
        return Base::empty();
    }
 
    std::string substr(size_type pos = 0, size_type count = npos) const
    {
        COMMS_ASSERT(pos <= size());
        return std::string(begin() + pos, begin() + pos + std::min(size() - pos, count));
    }
 
    void remove_prefix(size_type n)
    {
        Base::remove_prefix(n);
    }
 
    void remove_suffix(size_type n)
    {
        Base::remove_suffix(n);
    }
 
    void swap(StringView& other) noexcept
    {
        Base::swap(other);
    }
 
    size_type copy(char* dest, size_type count, size_type pos = 0) const
    {
        if (size() <= pos) {
            return 0U;
        }
 
        auto toCopy = std::min(count, size() - pos);
        std::copy_n(cbegin() + pos, toCopy, dest);
        return toCopy;
    }
 
    int compare(const StringView& other) const
    {
        return compare(0, size(), other);
    }
 
    int compare(size_type pos, size_type count, const StringView& other) const
    {
        return compare(pos, count, other, 0, other.size());
    }
 
    int compare(
        size_type pos1,
        size_type count1,
        const StringView& other,
        size_type pos2,
        size_type count2) const
    {
        COMMS_ASSERT(pos1 <= size());
        COMMS_ASSERT(pos2 <= other.size());
        count1 = std::min(count1, size() - pos1);
        count2 = std::min(count2, other.size() - pos2);
        auto minCount = std::min(count1, count2);
        for (auto idx = 0U; idx < minCount; ++idx) {
            auto thisCh = (*this)[pos1 + idx];
            auto otherCh = other[pos2 + idx];
            auto diff = static_cast<int>(thisCh) - static_cast<int>(otherCh);
            if (diff != 0) {
                return diff;
            }
        }
 
        return static_cast<int>(count1) - static_cast<int>(count2);
    }
 
    int compare(const char* s) const
    {
        return compare(0U, size(), s);
    }
 
    int compare(size_type pos, size_type count, const char* s) const
    {
        return compare(pos, count, StringView(s));
    }
 
    int compare(size_type pos1, size_type count1, const char* s, size_type count2) const
    {
        return compare(pos1, count1, StringView(s, count2));
    }
 
    size_type find(const StringView& str, size_type pos = 0) const
    {
        if (size() <= pos) {
            return npos;
        }
 
        COMMS_ASSERT(pos <= size());
        auto remCount = size() - pos;
        if (remCount < str.size()) {
            return npos;
        }
 
        auto maxPos = size() - str.size();
        for (auto idx = pos; idx <= maxPos; ++idx) {
            auto thisStrBeg = cbegin() + idx;
            auto thisStrEnd = thisStrBeg + str.size();
            if (std::equal(thisStrBeg, thisStrEnd, str.begin())) {
                return idx;
            }
        }
        return npos;
    }
 
    size_type find(char c, size_type pos = 0) const
    {
        return find(StringView(&c, 1), pos);
    }
 
    size_type find(const char* str, size_type pos, size_type count) const
    {
        return find(StringView(str, count), pos);
    }
 
    size_type find(const char* str, size_type pos = 0) const
    {
        return find(StringView(str), pos);
    }
    size_type find_first_of(const StringView& other, size_type pos = 0)
    {
        if (empty() || (size() <= pos)) {
            return npos;
        }
 
        pos = std::min(pos, size() - 1);
        for (auto iter = cbegin() + pos; iter != cend(); ++iter) {
            auto foundIter = std::find(other.cbegin(), other.cend(), *iter);
            if (foundIter != other.cend()) {
                return static_cast<SizeType>(std::distance(cbegin(), iter));
            }
        }
 
        return npos;
    }
 
    size_type find_first_of(char c, size_type pos = 0)
    {
        return find_first_of(StringView(&c, 1), pos);
    }
 
    size_type find_first_of(const char* str, size_type pos, size_type count)
    {
        return find_first_of(StringView(str, count), pos);
    }
 
    size_type find_first_of(const char* str, size_type pos = 0)
    {
        return find_first_of(StringView(str), pos);
    }
 
    size_type find_last_of(const StringView& other, size_type pos = npos)
    {
        if (empty()) {
            return npos;
        }
 
        pos = std::min(pos, size() - 1);
        auto begIter = std::reverse_iterator<const_iterator>(cbegin() + pos + 1);
        auto endIter = std::reverse_iterator<const_iterator>(cbegin());
        for (auto iter = begIter; iter != endIter; ++iter) {
            auto foundIter = std::find(other.cbegin(), other.cend(), *iter);
            if (foundIter != other.cend()) {
                return static_cast<std::size_t>(std::distance(iter, endIter)) - 1U;
            }
        }
 
        return npos;
    }
 
    size_type find_last_of(char c, size_type pos = npos)
    {
        return find_last_of(StringView(&c, 1), pos);
    }
 
    size_type find_last_of(const char* str, size_type pos, size_type count)
    {
        return find_last_of(StringView(str, count), pos);
    }
 
    size_type find_last_of(const char* str, size_type pos = npos)
    {
        return find_last_of(StringView(str), pos);
    }
 
    size_type find_first_not_of(const StringView& other, size_type pos = 0)
    {
        if (empty() || (size() <= pos)) {
            return npos;
        }
 
        pos = std::min(pos, size() - 1);
        for (auto iter = cbegin() + pos; iter != cend(); ++iter) {
            auto foundIter = std::find(other.cbegin(), other.cend(), *iter);
            if (foundIter == other.cend()) {
                return static_cast<SizeType>(std::distance(cbegin(), iter));
            }
        }
 
        return npos;
    }
 
    size_type find_first_not_of(char c, size_type pos = 0)
    {
        return find_first_not_of(StringView(&c, 1), pos);
    }
 
    size_type find_first_not_of(const char* str, size_type pos, size_type count)
    {
        return find_first_not_of(StringView(str, count), pos);
    }
 
    size_type find_first_not_of(const char* str, size_type pos = 0)
    {
        return find_first_not_of(StringView(str), pos);
    }
 
    size_type find_last_not_of(const StringView& other, size_type pos = npos)
    {
        if (empty()) {
            return npos;
        }
 
        pos = std::min(pos, size() - 1);
        auto begIter = std::reverse_iterator<const_iterator>(cbegin() + pos + 1);
        auto endIter = std::reverse_iterator<const_iterator>(cbegin());
        for (auto iter = begIter; iter != endIter; ++iter) {
            auto foundIter = std::find(other.cbegin(), other.cend(), *iter);
            if (foundIter == other.cend()) {
                return static_cast<std::size_t>(std::distance(iter, endIter)) - 1U;
            }
        }
 
        return npos;
    }
 
    size_type find_last_not_of(char c, size_type pos = 0)
    {
        return find_last_not_of(StringView(&c, 1), pos);
    }
 
    size_type find_last_not_of(const char* str, size_type pos, size_type count)
    {
        return find_last_not_of(StringView(str, count), pos);
    }
 
    size_type find_last_not_of(const char* str, size_type pos = npos)
    {
        return find_last_not_of(StringView(str), pos);
    }
 
};
 
inline
bool operator<(const StringView& str1, const StringView& str2)
{
    return std::lexicographical_compare(str1.begin(), str1.end(), str2.begin(), str2.end());
}
 
inline
bool operator<=(const StringView& str1, const StringView& str2)
{
    return !(str2 < str1);
}
 
inline
bool operator>(const StringView& str1, const StringView& str2)
{
    return (str2 < str1);
}
 
inline
bool operator>=(const StringView& str1, const StringView& str2)
{
    return !(str1 < str2);
}
 
inline
bool operator==(const StringView& str1, const StringView& str2)
{
    return
        (str1.size() == str2.size()) &&
        std::equal(str1.begin(), str1.end(), str2.begin());
}
 
inline
bool operator!=(const StringView& str1, const StringView& str2)
{
    return !(str1 == str2);
}
 
} // namespace util
 
} // namespace comms
 
namespace std
{
 
inline
void swap(comms::util::StringView& str1, comms::util::StringView& str2)
{
    str1.swap(str2);
}
 
}  // namespace std