StringView.h

// Copyright (c) Stefano Cristiano
// SPDX-License-Identifier: MIT
#pragma once
#include "../Foundation/Span.h"
#include "../Strings/StringIterator.h"
 
namespace SC
{
struct SC_COMPILER_EXPORT StringView;
struct SC_COMPILER_EXPORT StringViewTokenizer;
struct SC_COMPILER_EXPORT StringAlgorithms;
 
} // namespace SC
 
 
 
 
struct SC::StringView : public StringSpan
{
    StringView() : StringSpan() {}
 
    using StringSpan::StringSpan;
 
    constexpr StringView(StringSpan ssv) : StringSpan(ssv) {}
 
    static constexpr StringView fromNullTerminated(const char* text, StringEncoding encoding)
    {
        return StringSpan::fromNullTerminated(text, encoding);
    }
 
#if SC_PLATFORM_WINDOWS
    static constexpr StringView fromNullTerminated(const wchar_t* text, StringEncoding encoding)
    {
        return StringSpan::fromNullTerminated(text, encoding);
    }
#endif
 
    auto getNullTerminatedNative() const;
 
    Span<const uint8_t> toBytesSpan() const SC_LANGUAGE_LIFETIME_BOUND
    {
        return Span<const uint8_t>::reinterpret_bytes(text, textSizeInBytes);
    }
 
    enum class Comparison
    {
        Smaller = -1, 
        Equals  = 0,  
        Bigger  = 1   
    };
 
    [[nodiscard]] Comparison compare(StringView other) const;
 
    [[nodiscard]] bool operator<(StringView other) const { return compare(other) == Comparison::Smaller; }
 
    template <typename Func>
    [[nodiscard]] constexpr auto withIterator(Func&& func) const;
 
    template <typename Func>
    [[nodiscard]] static constexpr auto withIterators(StringView s1, StringView s2, Func&& func);
 
    template <typename StringIterator>
    constexpr StringIterator getIterator() const;
 
    [[nodiscard]] constexpr bool operator!=(StringView other) const { return not operator==(other); }
 
    [[nodiscard]] constexpr bool operator==(StringSpan other) const;
 
    [[nodiscard]] constexpr bool fullyOverlaps(StringView other, size_t& commonOverlappingPoints) const;
 
    [[nodiscard]] constexpr bool isEmpty() const { return text == nullptr or textSizeInBytes == 0; }
 
    [[nodiscard]] constexpr bool isNullTerminated() const { return hasNullTerm; }
 
    [[nodiscard]] constexpr size_t sizeInBytes() const { return textSizeInBytes; }
 
    [[nodiscard]] bool endsWithAnyOf(Span<const StringCodePoint> codePoints) const;
 
    [[nodiscard]] bool startsWithAnyOf(Span<const StringCodePoint> codePoints) const;
 
    [[nodiscard]] bool startsWith(const StringView str) const;
 
    [[nodiscard]] bool endsWith(const StringView str) const;
 
    [[nodiscard]] bool containsString(const StringView str) const;
 
    [[nodiscard]] bool splitAfter(const StringView stringToMatch, StringView& remainingAfterSplit) const;
 
    [[nodiscard]] bool splitBefore(const StringView stringToMatch, StringView& stringBeforeSplit) const;
 
    [[nodiscard]] bool containsCodePoint(StringCodePoint c) const;
 
    [[nodiscard]] constexpr bool hasCompatibleEncoding(StringView str) const;
 
    template <typename StringIterator>
    static StringView fromIterators(StringIterator from, StringIterator to);
 
    template <typename StringIterator>
    static StringView fromIteratorUntilEnd(StringIterator it);
 
    template <typename StringIterator>
    static constexpr StringView fromIteratorFromStart(StringIterator it);
 
    [[nodiscard]] StringView sliceStartEnd(size_t start, size_t end) const;
 
    [[nodiscard]] StringView sliceStartLength(size_t start, size_t length) const;
 
    [[nodiscard]] StringView sliceStart(size_t offset) const;
 
    [[nodiscard]] StringView sliceEnd(size_t offset) const;
 
    [[nodiscard]] StringView trimEndAnyOf(Span<const StringCodePoint> codePoints) const;
 
    [[nodiscard]] StringView trimStartAnyOf(Span<const StringCodePoint> codePoints) const;
 
    [[nodiscard]] StringView trimAnyOf(Span<const StringCodePoint> codePoints) const;
 
    [[nodiscard]] StringView trimWhiteSpaces() const;
 
 
    [[nodiscard]] bool isIntegerNumber() const;
 
    [[nodiscard]] bool isFloatingNumber() const;
 
    [[nodiscard]] bool parseInt32(int32_t& value) const;
 
    [[nodiscard]] bool parseFloat(float& value) const;
 
    [[nodiscard]] bool parseDouble(double& value) const;
 
  private:
    template <typename T>
    struct identity
    {
    };
    template <typename Type>
    constexpr StringIteratorASCII getIterator(identity<Type>) const;
    constexpr StringIteratorUTF8  getIterator(identity<StringIteratorUTF8>) const;
    constexpr StringIteratorUTF16 getIterator(identity<StringIteratorUTF16>) const;
    template <typename StringIterator1, typename StringIterator2>
    static constexpr bool equalsIterator(StringIterator1 t1, StringIterator2 t2, size_t& points);
 
    template <typename StringIterator>
    constexpr bool equalsIterator(StringView other, size_t& points) const;
};
 
struct SC::StringViewTokenizer
{
    StringCodePoint splittingCharacter = 0; 
 
    size_t numSplitsNonEmpty = 0; 
    size_t numSplitsTotal    = 0; 
 
    StringView component; 
    StringView processed; 
    StringView remaining; 
 
    enum Options
    {
        IncludeEmpty, 
        SkipEmpty     
    };
 
    StringViewTokenizer(StringView text) : remaining(text), originalText(text) {}
 
    [[nodiscard]] bool tokenizeNext(Span<const StringCodePoint> separators, Options options = Options::SkipEmpty);
 
    [[nodiscard]] bool tokenizeNextLine() { return tokenizeNext({'\n'}); }
 
    StringViewTokenizer& countTokens(Span<const StringCodePoint> separators);
 
    [[nodiscard]] bool isFinished() const;
 
  private:
    StringView originalText; // Original text as passed in the constructor
};
 
struct SC::StringAlgorithms
{
    [[nodiscard]] static bool matchWildcard(StringView s1, StringView s2);
 
  private:
    template <typename StringIterator1, typename StringIterator2>
    [[nodiscard]] static bool matchWildcardIterator(StringIterator1 pattern, StringIterator2 text);
};
 
 
//-----------------------------------------------------------------------------------------------------------------------
// Implementations Details
//-----------------------------------------------------------------------------------------------------------------------
namespace SC
{
constexpr SC::StringView operator""_a8(const char* txt, size_t sz)
{
    return StringView({txt, sz}, true, StringEncoding::Ascii);
}
constexpr StringView operator""_u8(const char* txt, size_t sz)
{
    return StringView({txt, sz}, true, StringEncoding::Utf8);
}
constexpr StringView operator""_u16(const char* txt, size_t sz)
{
    const bool isNullTerminated = sz > 0 and sz % 2 == 1 and txt[sz - 1] == 0;
    return StringView({txt, isNullTerminated ? sz - 1 : sz}, isNullTerminated, StringEncoding::Utf16);
}
} // namespace SC
 
template <typename StringIterator>
constexpr StringIterator SC::StringView::getIterator() const
{
    // For GCC complaining about specialization in non-namespace scope
    return getIterator(identity<StringIterator>());
}
 
template <typename Type>
constexpr SC::StringIteratorASCII SC::StringView::getIterator(identity<Type>) const
{
    return StringIteratorASCII(text, text + textSizeInBytes);
}
constexpr SC::StringIteratorUTF8 SC::StringView::getIterator(identity<StringIteratorUTF8>) const
{
    return StringIteratorUTF8(text, text + textSizeInBytes);
}
constexpr SC::StringIteratorUTF16 SC::StringView::getIterator(identity<StringIteratorUTF16>) const
{
    return StringIteratorUTF16(text, text + textSizeInBytes);
}
 
template <typename StringIterator1, typename StringIterator2>
constexpr bool SC::StringView::equalsIterator(StringIterator1 t1, StringIterator2 t2, size_t& points)
{
    StringCodePoint c1 = 0;
    StringCodePoint c2 = 0;
    while (t1.advanceRead(c1) and t2.advanceRead(c2))
    {
        if (c1 != c2)
        {
            return false;
        }
        points++;
    }
    return t1.isAtEnd() and t2.isAtEnd();
}
 
template <typename StringIterator>
constexpr bool SC::StringView::equalsIterator(StringView other, size_t& points) const
{
    auto it = getIterator<StringIterator>();
    switch (other.getEncoding())
    {
    case StringEncoding::Ascii: return equalsIterator(it, other.getIterator<StringIteratorASCII>(), points);
    case StringEncoding::Utf8: return equalsIterator(it, other.getIterator<StringIteratorUTF8>(), points);
    case StringEncoding::Utf16: return equalsIterator(it, other.getIterator<StringIteratorUTF16>(), points);
    }
    Assert::unreachable();
}
 
[[nodiscard]] inline auto SC::StringView::getNullTerminatedNative() const
{
#if SC_PLATFORM_WINDOWS
    SC_ASSERT_RELEASE(hasNullTerm && (getEncoding() == StringEncoding::Utf16));
    return reinterpret_cast<const wchar_t*>(text);
#else
    SC_ASSERT_RELEASE(hasNullTerm && (getEncoding() == StringEncoding::Utf8 || getEncoding() == StringEncoding::Ascii));
    return text;
#endif
}
 
[[nodiscard]] constexpr bool SC::StringView::operator==(StringSpan other) const
{
#if defined(__clang__)
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunreachable-code"
#endif
    if (hasCompatibleEncoding(other))
    {
        if (textSizeInBytes != other.textSizeInBytes)
            return false;
        if (__builtin_is_constant_evaluated())
        {
            auto it1 = text;
            auto it2 = other.text;
            auto sz  = textSizeInBytes;
            for (size_t idx = 0; idx < sz; ++idx)
                if (it1[idx] != it2[idx])
                    return false;
        }
        else
        {
            if (text == nullptr)
            {
                return other.textSizeInBytes == 0;
            }
            if (other.text == nullptr)
            {
                return textSizeInBytes == 0;
            }
            return memcmp(text, other.text, textSizeInBytes) == 0;
        }
    }
    size_t commonOverlappingPoints = 0;
    return fullyOverlaps(other, commonOverlappingPoints);
#if defined(__clang__)
#pragma clang diagnostic pop
#endif
}
 
constexpr bool SC::StringView::fullyOverlaps(StringView other, size_t& commonOverlappingPoints) const
{
    commonOverlappingPoints = 0;
    switch (getEncoding())
    {
    case StringEncoding::Ascii: return equalsIterator<StringIteratorASCII>(other, commonOverlappingPoints);
    case StringEncoding::Utf8: return equalsIterator<StringIteratorUTF8>(other, commonOverlappingPoints);
    case StringEncoding::Utf16: return equalsIterator<StringIteratorUTF16>(other, commonOverlappingPoints);
    }
    Assert::unreachable();
}
 
template <typename Func>
constexpr auto SC::StringView::withIterator(Func&& func) const
{
    switch (getEncoding())
    {
    case StringEncoding::Ascii: return func(getIterator<StringIteratorASCII>());
    case StringEncoding::Utf8: return func(getIterator<StringIteratorUTF8>());
    case StringEncoding::Utf16: return func(getIterator<StringIteratorUTF16>());
    }
    Assert::unreachable();
}
 
template <typename Func>
constexpr auto SC::StringView::withIterators(StringView s1, StringView s2, Func&& func)
{
    return s1.withIterator([&s2, &func](auto it1)
                           { return s2.withIterator([&it1, &func](auto it2) { return func(it1, it2); }); });
}
 
constexpr bool SC::StringView::hasCompatibleEncoding(StringView str) const
{
    return StringEncodingAreBinaryCompatible(getEncoding(), str.getEncoding());
}
 
template <typename StringIterator>
inline SC::StringView SC::StringView::fromIterators(StringIterator from, StringIterator to)
{
    const ssize_t numBytes = to.bytesDistanceFrom(from);
    if (numBytes >= 0)
    {
        StringIterator fromEnd = from;
        fromEnd.setToEnd();
        if (fromEnd.bytesDistanceFrom(to) >= 0) // If current iterator of to is inside from range
            return StringView({from.it, static_cast<size_t>(numBytes)}, false, StringIterator::getEncoding());
    }
    return StringView(); // TODO: Make StringView::fromIterators return bool to make it fallible
}
 
template <typename StringIterator>
inline SC::StringView SC::StringView::fromIteratorUntilEnd(StringIterator it)
{
    StringIterator endIt = it;
    endIt.setToEnd();
    const size_t numBytes = static_cast<size_t>(endIt.bytesDistanceFrom(it));
    return StringView({it.it, numBytes}, false, StringIterator::getEncoding());
}
 
template <typename StringIterator>
constexpr SC::StringView SC::StringView::fromIteratorFromStart(StringIterator it)
{
    StringIterator start = it;
    start.setToStart();
    const size_t numBytes = static_cast<size_t>(it.bytesDistanceFrom(start));
    return StringView({start.it, numBytes}, false, StringIterator::getEncoding());
}