StringView.hpp

[詳解]

//
//    文字列参照クラス (std::string_view代替)
//
//    Copyright (c) 2022-2024 udonrobo
//
 
#pragma once
 
#include <Udon/Stl/EnableSTL.hpp>
#include <string>
#include <vector>
#include <algorithm>
#include <iterator>
#include <Udon/Algorithm/StringToNumberParser.hpp>
#include <Udon/Utility/Platform.hpp>
 
#if UDON_PLATFORM_OUTPUT_STREAM == UDON_PLATFORM_OUTPUT_CONSOLE
#    include <iostream>
#endif
 
namespace Udon
{
 
    template <typename CharType, typename Traits = std::char_traits<CharType>>
    class BasicStringView
    {
        static_assert(not std::is_array<CharType>::value, "CharType cannot be an array.");
 
        static_assert(std::is_trivial<CharType>::value, "CharType must be a trivial type.");
 
        static_assert(std::is_standard_layout<CharType>::value, "CharType must be a standard layout type.");
 
    public:
        using size_type              = size_t;
        using traits_type            = Traits;
        using char_type              = typename traits_type::char_type;
        using int_type               = typename traits_type::int_type;
        using off_type               = typename traits_type::off_type;
        using pos_type               = typename traits_type::pos_type;
        using state_type             = typename traits_type::state_type;
        using const_reference        = const char_type&;
        using const_pointer          = const char_type*;
        using const_iterator         = const char_type*;
        using const_receive_iterator = std::reverse_iterator<const_iterator>;
 
        static constexpr size_type npos = static_cast<size_type>(-1);
 
    private:
        const_pointer m_data;    // ビューの先頭を指すポインタ
        size_type     m_size;    // ビューの要素数
 
    public:
        constexpr BasicStringView()
            : m_data()
            , m_size()
        {
        }
 
        BasicStringView(const_pointer string)
            : m_data(string)
            , m_size(strlen(string))
        {
        }
 
        constexpr BasicStringView(const_pointer string, const size_type length)
            : m_data(string)
            , m_size(length)
        {
        }
 
        template <typename InputIterator, typename = typename std::enable_if<std::is_convertible<typename std::iterator_traits<InputIterator>::iterator_category, std::input_iterator_tag>::value>::type>
        constexpr BasicStringView(InputIterator begin, InputIterator end)
            : m_data(begin)
            , m_size(std::distance(begin, end))
        {
        }
 
        BasicStringView(const std::basic_string<CharType>& string)
            : m_data(string.data())
            , m_size(string.size())
        {
        }
 
        
#ifdef ARDUINO
 
        template <typename T = CharType, typename = typename std::enable_if<std::is_same<T, char>::value>::type>
        BasicStringView(const String& str)
            : m_data(str.c_str())
            , m_size(str.length())
        {
        }
#endif
 
        BasicStringView(const BasicStringView&) = default;
 
        BasicStringView& operator=(const BasicStringView&) = default;
 
        constexpr explicit operator bool() const noexcept
        {
            return m_size;
        }
 
        constexpr const_pointer data() const noexcept
        {
            return m_data;
        }
 
        constexpr size_type size() const noexcept
        {
            return m_size;
        }
 
        // const_pointer c_str() const noexcept = delete;
 
        constexpr bool empty() const noexcept
        {
            return m_size == 0;
        }
 
        constexpr const_reference operator[](const size_type index) const noexcept
        {
            return m_data[index];
        }
 
        const_reference at(const size_type index) const noexcept
        {
            if (index >= m_size)
            {
                // throw std::out_of_range
                return back();
            }
            return m_data[index];
        }
 
        constexpr const_reference front() const noexcept
        {
            return m_data[0];
        }
 
        constexpr const_reference back() const noexcept
        {
            return m_data[m_size - 1];
        }
 
        BasicStringView substring(const size_type beginIndex, const size_type endIndex = npos) const
        {
            if (beginIndex >= m_size)
            {
                return {};
            }
            if (endIndex == npos)
            {
                return {
                    std::next(cbegin(), beginIndex),
                    m_size - beginIndex
                };
            }
            if (endIndex <= beginIndex)
            {
                return {};
            }
            return {
                std::next(cbegin(), beginIndex),
                std::next(cbegin(), std::min(endIndex, m_size)),
            };
        }
 
        BasicStringView substringUntil(const char_type terminate) const
        {
            return {
                cbegin(),
                std::find(cbegin(), cend(), terminate)
            };
        }
 
        BasicStringView removePrefix(const size_type n) const
        {
            if (n >= m_size)
            {
                return {};
            }
            return {
                std::next(cbegin(), n),
                m_size - n
            };
        }
 
        BasicStringView removeSuffix(const size_type n) const
        {
            if (n >= m_size)
            {
                return {};
            }
            return {
                cbegin(),
                m_size - n
            };
        }
 
        bool startsWith(const BasicStringView& string) const noexcept
        {
            return m_size >= string.m_size and traits_type::compare(m_data, string.m_data, string.m_size) == 0;
        }
 
        bool endsWith(const BasicStringView& string) const noexcept
        {
            return m_size >= string.m_size and traits_type::compare(m_data + m_size - string.m_size, string.m_data, string.m_size) == 0;
        }
 
        std::vector<BasicStringView> split(const char_type delimiter) const
        {
            std::vector<BasicStringView> tokens;
 
            const_iterator begin = cbegin();
            for (auto it = cbegin(); it != cend(); ++it)
            {
                const auto next = std::next(it);
                if (*it == delimiter)    // 区切り文字検索
                {
                    tokens.emplace_back(begin, it);
                    begin = next;    // it は 区切り文字を指しているので飛ばす
                }
                else if (next == cend())    // 最後は普通に追加
                {
                    tokens.emplace_back(begin, cend());
                }
            }
            return tokens;
        }
 
        template <typename T = int>
        Udon::Optional<T> toNumber(const int radix = 10) const
        {
            static_assert(std::is_arithmetic<T>::value, "T must be arithmetic type.");
 
            return StringToNumberParser::Parse<T>(cbegin(), cend(), radix);
        }
 
        std::basic_string<char_type> toString() const
        {
            return { cbegin(), cend() };
        }
 
        void swap(BasicStringView& other) noexcept
        {
            std::swap(m_data, other.m_data);
            std::swap(m_size, other.m_size);
        }
 
        friend bool operator==(const BasicStringView& lhs, const BasicStringView& rhs) noexcept
        {
            return lhs.m_size == rhs.m_size and traits_type::compare(lhs.m_data, rhs.m_data, lhs.m_size) == 0;
        }
 
        friend bool operator!=(const BasicStringView& lhs, const BasicStringView& rhs) noexcept
        {
            return not(lhs == rhs);
        }
 
#if UDON_PLATFORM_OUTPUT_STREAM == UDON_PLATFORM_OUTPUT_CONSOLE
 
        friend std::basic_ostream<char_type>& operator<<(std::basic_ostream<char_type>& os, const BasicStringView& string)
        {
            return os.write(string.m_data, string.m_size);
        }
 
#endif
 
#ifdef ARDUINO
        void show() const
        {
            Serial.print("[");
            for (size_type i = 0; i < m_size; ++i)
            {
                Serial.print(m_data[i]);
                if (i < m_size - 1)
                {
                    Serial.print(", ");
                }
            }
            Serial.print("]");
        }
        void showString() const
        {
            Serial.write(m_data, m_size);
        }
#endif
 
        // iterator 要件
        const_iterator begin() const noexcept { return m_data; }
        const_iterator end() const noexcept { return m_data + m_size; }
 
        const_iterator cbegin() const noexcept { return m_data; }
        const_iterator cend() const noexcept { return m_data + m_size; }
 
        const_receive_iterator rbegin() const noexcept { return const_receive_iterator(end()); }
        const_receive_iterator rend() const noexcept { return const_receive_iterator(begin()); }
 
        const_receive_iterator crbegin() const noexcept { return const_receive_iterator(cend()); }
        const_receive_iterator crend() const noexcept { return const_receive_iterator(cbegin()); }
    };
 
}    // namespace Udon
 
namespace Udon
{
    using StringView  = BasicStringView<char>;
    using WStringView = BasicStringView<wchar_t>;
}    // namespace Udon
 
namespace Udon
{
 
    namespace Literals
    {
 
        constexpr StringView operator""_sv(const char* string, size_t length) noexcept
        {
            return { string, length };
        }
 
        constexpr WStringView operator""_sv(const wchar_t* string, size_t length) noexcept
        {
            return { string, length };
        }
 
    }    // namespace Literals
 
}    // namespace Udon