StringView.hpp

 
//
// TGUI - Texus' Graphical User Interface
// Copyright (C) 2012-2023 Bruno Van de Velde (vdv_b@tgui.eu)
//
// This software is provided 'as-is', without any express or implied warranty.
// In no event will the authors be held liable for any damages arising from the use of this software.
//
// Permission is granted to anyone to use this software for any purpose,
// including commercial applications, and to alter it and redistribute it freely,
// subject to the following restrictions:
//
// 1. The origin of this software must not be misrepresented;
// you must not claim that you wrote the original software.
// If you use this software in a product, an acknowledgment
// in the product documentation would be appreciated but is not required.
//
// 2. Altered source versions must be plainly marked as such,
// and must not be misrepresented as being the original software.
//
// 3. This notice may not be removed or altered from any source distribution.
//
 
 
#ifndef TGUI_STRING_VIEW_HPP
#define TGUI_STRING_VIEW_HPP
 
#if !TGUI_EXPERIMENTAL_USE_STD_MODULE
 #include <string>
 #include <cctype> // tolower
 
 #if TGUI_COMPILED_WITH_CPP_VER >= 17
 #include <string_view>
 #else
 #include <algorithm> // min
 #endif
#endif
 
 
#if TGUI_COMPILED_WITH_CPP_VER >= 17
namespace tgui
{
 inline namespace literals
 {
 inline namespace string_view_literals
 {
 // Allow using operator ""sv
 // Note that this only affects code placed inside the tgui namespace.
 using namespace std::literals::string_view_literals;
 }
 }
}
#endif
 
TGUI_MODULE_EXPORT namespace tgui
{
#if TGUI_COMPILED_WITH_CPP_VER >= 17
 using StringView = std::u32string_view;
 using CharStringView = std::string_view;
#else
 template <typename Type>
 struct TypeIdentity
 {
 using type = Type;
 };
 
 template<typename Type>
 using TypeIdentity_t = typename TypeIdentity<Type>::type;
 
 template <typename CharType>
 class StringViewImpl
 {
 public:
 using const_iterator = const CharType*;
 
 constexpr StringViewImpl() = default;
 constexpr StringViewImpl(const StringViewImpl& other) = default;
 
 constexpr StringViewImpl(const CharType* str, std::size_t strLength) :
 m_string(str),
 m_length(strLength)
 {
 }
 
 constexpr StringViewImpl(const CharType* str) :
 m_string(str),
 m_length(std::char_traits<CharType>::length(str))
 {
 }
 
 constexpr StringViewImpl(const std::basic_string<CharType>& str) :
 m_string(str.data()),
 m_length(str.length())
 {
 }
 
 TGUI_NODISCARD constexpr const_iterator begin() const noexcept
 {
 return m_string;
 }
 TGUI_NODISCARD constexpr const_iterator cbegin() const noexcept
 {
 return m_string;
 }
 
 TGUI_NODISCARD constexpr const_iterator end() const noexcept
 {
 return m_string + static_cast<std::ptrdiff_t>(m_length);
 }
 TGUI_NODISCARD constexpr const_iterator cend() const noexcept
 {
 return m_string + static_cast<std::ptrdiff_t>(m_length);
 }
 
 TGUI_NODISCARD constexpr const CharType& operator[](std::size_t index) const
 {
 return m_string[index];
 }
 
 TGUI_NODISCARD constexpr const CharType& front() const
 {
 return m_string[0];
 }
 
 TGUI_NODISCARD constexpr const CharType& back() const
 {
 return m_string[m_length-1];
 }
 
 TGUI_NODISCARD constexpr const CharType* data() const noexcept
 {
 return m_string;
 }
 
 TGUI_NODISCARD constexpr std::size_t size() const noexcept
 {
 return m_length;
 }
 TGUI_NODISCARD constexpr std::size_t length() const noexcept
 {
 return m_length;
 }
 
 TGUI_NODISCARD constexpr bool empty() const noexcept
 {
 return (m_length == 0);
 }
 
 TGUI_NODISCARD constexpr StringViewImpl substr(std::size_t pos = 0, std::size_t count = std::u32string::npos) const
 {
 if (count != std::u32string::npos)
 return StringViewImpl(&m_string[pos], count);
 else
 return StringViewImpl(&m_string[pos], m_length - pos);
 }
 
 TGUI_NODISCARD constexpr int compare(StringViewImpl strView) const noexcept
 {
 const std::size_t rlen = std::min(length(), strView.length());
 const int ret = std::char_traits<CharType>::compare(data(), strView.data(), rlen);
 if (ret != 0)
 return ret;
 
 if (length() < strView.length())
 return -1;
 else if (length() > strView.length())
 return 1;
 else
 return 0;
 }
 
 TGUI_NODISCARD constexpr std::size_t find(StringViewImpl strView, std::size_t pos = 0) const noexcept
 {
 if (empty() || (strView.length() > m_length))
 return std::u32string::npos;
 
 if (strView.empty())
 return pos;
 
 for (std::size_t i = pos; i <= m_length - strView.length(); ++i)
 {
 if (m_string[i] != strView[0])
 continue;
 
 bool found = true;
 for (std::size_t j = 1; j < strView.length(); ++j)
 {
 if (m_string[i+j] != strView[j])
 {
 found = false;
 break;
 }
 }
 
 if (found)
 return i;
 }
 
 return std::u32string::npos;
 }
 
 TGUI_NODISCARD constexpr std::size_t find(CharType ch, std::size_t pos = 0) const noexcept
 {
 return find(StringViewImpl(&ch, 1), pos);
 }
 TGUI_NODISCARD constexpr std::size_t find(const CharType* str, std::size_t pos, std::size_t count) const
 {
 return find(StringViewImpl(str, count), pos);
 }
 TGUI_NODISCARD constexpr std::size_t find(const CharType* str, std::size_t pos = 0) const
 {
 return find(StringViewImpl(str), pos);
 }
 
 private:
 const CharType* m_string = nullptr;
 std::size_t m_length = 0;
 };
 
 template <typename CharType>
 TGUI_NODISCARD constexpr bool operator==(StringViewImpl<CharType> lhs, TypeIdentity_t<StringViewImpl<CharType>> rhs) noexcept
 {
 return lhs.compare(rhs) == 0;
 }
 
 template <typename CharType>
 TGUI_NODISCARD constexpr bool operator!=(StringViewImpl<CharType> lhs, TypeIdentity_t<StringViewImpl<CharType>> rhs) noexcept
 {
 return lhs.compare(rhs) != 0;
 }
 
 template <typename CharType>
 TGUI_NODISCARD constexpr bool operator<(StringViewImpl<CharType> lhs, TypeIdentity_t<StringViewImpl<CharType>> rhs) noexcept
 {
 return lhs.compare(rhs) < 0;
 }
 
 template <typename CharType>
 TGUI_NODISCARD constexpr bool operator<=(StringViewImpl<CharType> lhs, TypeIdentity_t<StringViewImpl<CharType>> rhs) noexcept
 {
 return lhs.compare(rhs) <= 0;
 }
 
 template <typename CharType>
 TGUI_NODISCARD constexpr bool operator>(StringViewImpl<CharType> lhs, TypeIdentity_t<StringViewImpl<CharType>> rhs) noexcept
 {
 return lhs.compare(rhs) > 0;
 }
 
 template <typename CharType>
 TGUI_NODISCARD constexpr bool operator>=(StringViewImpl<CharType> lhs, TypeIdentity_t<StringViewImpl<CharType>> rhs) noexcept
 {
 return lhs.compare(rhs) >= 0;
 }
 
 using StringView = StringViewImpl<char32_t>;
 using CharStringView = StringViewImpl<char>;
 
 // Allow using operator ""sv
 // Note that this only affects code placed inside the tgui namespace.
#if defined(__clang__)
# pragma clang diagnostic push
# pragma clang diagnostic ignored "-Wuser-defined-literals"
#elif defined(__GNUC__)
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wliteral-suffix"
#elif defined (_MSC_VER)
# pragma warning(push)
# pragma warning(disable: 4455) // literal suffix identifiers that do not start with an underscore are reserved
#endif
 inline namespace literals
 {
 inline namespace string_view_literals
 {
 inline constexpr StringViewImpl<char> operator""sv(const char* str, size_t len) noexcept
 {
 return StringViewImpl<char>{str, len};
 }
 
 inline constexpr StringViewImpl<wchar_t> operator""sv(const wchar_t* str, size_t len) noexcept
 {
 return StringViewImpl<wchar_t>{str, len};
 }
 
 inline constexpr StringViewImpl<char16_t> operator""sv(const char16_t* str, size_t len) noexcept
 {
 return StringViewImpl<char16_t>{str, len};
 }
 
 inline constexpr StringViewImpl<char32_t> operator""sv(const char32_t* str, size_t len) noexcept
 {
 return StringViewImpl<char32_t>{str, len};
 }
 }
 }
#if defined(__clang__)
# pragma clang diagnostic pop
#elif defined(__GNUC__)
# pragma GCC diagnostic pop
#elif defined (_MSC_VER)
# pragma warning(pop)
#endif
 
#endif // TGUI_COMPILED_WITH_CPP_VER
 
 TGUI_NODISCARD inline bool viewEqualIgnoreCase(CharStringView view1, CharStringView view2)
 {
 return std::equal(view1.begin(), view1.end(), view2.begin(), view2.end(),
 [](char char1, char char2)
 {
 if (char1 == char2)
 return true;
 else
 return std::tolower(static_cast<unsigned char>(char1)) == std::tolower(static_cast<unsigned char>(char2));
 }
 );
 }
 
 TGUI_NODISCARD inline bool viewEqualIgnoreCase(StringView view1, StringView view2)
 {
 return std::equal(view1.begin(), view1.end(), view2.begin(), view2.end(),
 [](char32_t char1, char32_t char2)
 {
 if (char1 == char2)
 return true;
 else if ((char1 < 128) && (char2 < 128))
 return std::tolower(static_cast<unsigned char>(char1)) == std::tolower(static_cast<unsigned char>(char2));
 else
 return false;
 }
 );
 }
 
#if TGUI_COMPILED_WITH_CPP_VER >= 17 && defined(__cpp_lib_starts_ends_with) && (__cpp_lib_starts_ends_with >= 201711L)
 TGUI_NODISCARD inline bool viewStartsWith(CharStringView viewToLookInto, CharStringView viewToLookFor)
 {
 return viewToLookInto.starts_with(viewToLookFor);
 }
 
 TGUI_NODISCARD inline bool viewStartsWith(CharStringView viewToLookInto, char charToLookFor)
 {
 return viewToLookInto.starts_with(charToLookFor);
 }
 
 TGUI_NODISCARD inline bool viewEndsWith(CharStringView viewToLookInto, CharStringView viewToLookFor)
 {
 return viewToLookInto.ends_with(viewToLookFor);
 }
 
 TGUI_NODISCARD inline bool viewEndsWith(CharStringView viewToLookInto, char charToLookFor)
 {
 return viewToLookInto.ends_with(charToLookFor);
 }
 
 TGUI_NODISCARD inline bool viewStartsWith(StringView viewToLookInto, StringView viewToLookFor)
 {
 return viewToLookInto.starts_with(viewToLookFor);
 }
 
 TGUI_NODISCARD inline bool viewStartsWith(StringView viewToLookInto, char32_t charToLookFor)
 {
 return viewToLookInto.starts_with(charToLookFor);
 }
 
 TGUI_NODISCARD inline bool viewEndsWith(StringView viewToLookInto, StringView viewToLookFor)
 {
 return viewToLookInto.ends_with(viewToLookFor);
 }
 
 TGUI_NODISCARD inline bool viewEndsWith(StringView viewToLookInto, char32_t charToLookFor)
 {
 return viewToLookInto.ends_with(charToLookFor);
 }
#else
 TGUI_NODISCARD inline bool viewStartsWith(CharStringView viewToLookInto, CharStringView viewToLookFor)
 {
 if (viewToLookFor.length() > viewToLookInto.length())
 return false;
 
 return viewToLookInto.substr(0, viewToLookFor.length()) == viewToLookFor;
 }
 
 TGUI_NODISCARD inline bool viewStartsWith(CharStringView viewToLookInto, char charToLookFor)
 {
 return !viewToLookInto.empty() && (viewToLookInto.front() == charToLookFor);
 }
 
 TGUI_NODISCARD inline bool viewEndsWith(CharStringView viewToLookInto, CharStringView viewToLookFor)
 {
 if (viewToLookFor.length() > viewToLookInto.length())
 return false;
 
 return CharStringView(viewToLookInto.data() + (viewToLookInto.length() - viewToLookFor.length()), viewToLookFor.length()).compare(viewToLookFor) == 0;
 }
 
 TGUI_NODISCARD inline bool viewEndsWith(CharStringView viewToLookInto, char charToLookFor)
 {
 return !viewToLookInto.empty() && (viewToLookInto.back() == charToLookFor);
 }
 
 TGUI_NODISCARD inline bool viewStartsWith(StringView viewToLookInto, StringView viewToLookFor)
 {
 if (viewToLookFor.length() > viewToLookInto.length())
 return false;
 
 return viewToLookInto.substr(0, viewToLookFor.length()) == viewToLookFor;
 }
 
 TGUI_NODISCARD inline bool viewStartsWith(StringView viewToLookInto, char32_t charToLookFor)
 {
 return !viewToLookInto.empty() && (viewToLookInto.front() == charToLookFor);
 }
 
 TGUI_NODISCARD inline bool viewEndsWith(StringView viewToLookInto, StringView viewToLookFor)
 {
 if (viewToLookFor.length() > viewToLookInto.length())
 return false;
 
 return StringView(viewToLookInto.data() + (viewToLookInto.length() - viewToLookFor.length()), viewToLookFor.length()).compare(viewToLookFor) == 0;
 }
 
 TGUI_NODISCARD inline bool viewEndsWith(StringView viewToLookInto, char32_t charToLookFor)
 {
 return !viewToLookInto.empty() && (viewToLookInto.back() == charToLookFor);
 }
#endif
}
 
 
#endif // TGUI_STRING_VIEW_HPP