MtFmt: inc/mm_string.hpp 源文件

浏览该文件的文档.
// SPDX-License-Identifier: LGPL-3.0
#if !defined(_INCLUDE_MM_STRING_HPP_)
#define _INCLUDE_MM_STRING_HPP_ 1
#include "mm_cfg.h"
#include "mm_fmt.h"
#include "mm_result.hpp"
#include "mm_string.h"
#include <array>
#include <cstddef>
#include <functional>
#include <iterator>
#include <limits>
#include <string.h>
#include <string>
namespace mtfmt
{
class string;
 
using unicode_t = mstr_codepoint_t;
 
namespace details
{
#if _MSTR_USE_UTF_8
template <std::size_t N>
constexpr uint32_t utf8_meta(
    const mstr_char_t (&u8char)[N], std::size_t idx, uint32_t mask
)
{
    // 取得utf-8编码有效的部份: u8char[idx] & mask
    return static_cast<uint32_t>(
        static_cast<uint8_t>(u8char[idx]) & mask
    );
}
 
template <std::size_t N>
constexpr typename std::enable_if<N == 3, unicode_t>::type unicode_char(
    const mstr_char_t (&u8char)[N]
)
{
    return (utf8_meta(u8char, 1, 0x3f)) |
           (utf8_meta(u8char, 0, 0x1f) << 6);
}
 
template <std::size_t N>
constexpr typename std::enable_if<N == 4, unicode_t>::type unicode_char(
    const mstr_char_t (&u8char)[N]
)
{
    return (utf8_meta(u8char, 2, 0x3f)) |
           (utf8_meta(u8char, 1, 0x3f) << 6) |
           (utf8_meta(u8char, 0, 0x0f) << 12);
}
 
template <std::size_t N>
constexpr typename std::enable_if<N == 5, unicode_t>::type unicode_char(
    const mstr_char_t (&u8char)[N]
)
{
    return (utf8_meta(u8char, 3, 0x3f)) |
           (utf8_meta(u8char, 2, 0x3f) << 6) |
           (utf8_meta(u8char, 1, 0x3f) << 12) |
           (utf8_meta(u8char, 0, 0x07) << 18);
}
#endif // _MSTR_USE_UTF_8
 
template <std::size_t N>
constexpr typename std::enable_if<N <= 2, unicode_t>::type unicode_char(
    const mstr_char_t (&u8char)[N]
)
{
    return u8char[0];
}
 
class string_iterator
{
    const char* beg;
 
    const char* it;
 
    usize_t rem_length;
 
public:
    using value_type = unicode_t;
    using pointer = const value_type*;
    using reference = const value_type&;
    using difference_type = iptr_t;
    using iterator_category = std::bidirectional_iterator_tag;
 
    string_iterator(
        const mstr_char_t* _beg, const mstr_char_t* _buff, usize_t _leng
    )
        : beg(_beg), it(_buff), rem_length(_leng)
    {
    }
 
    string_iterator(string_iterator&&) = default;
    string_iterator(const string_iterator&) = default;
    string_iterator& operator=(string_iterator&&) = default;
    string_iterator& operator=(const string_iterator&) = default;
 
    reference operator*() const
    {
        static mstr_codepoint_t code;
#if _MSTR_USE_UTF_8
        usize_t len = mstr_char_length(*it);
        mstr_result_t res = mstr_codepoint_of(&code, it, len);
        if (MSTR_FAILED(res)) {
#if _MSTR_USE_CPP_EXCEPTION
            throw mtfmt_error(MStr_Err_UnicodeEncodingError);
#else
            mstr_cause_exception(MStr_Err_UnicodeEncodingError);
#endif // _MSTR_USE_CPP_EXCEPTION
        }
#else
        code = *it;
#endif
        // 因为code是计算出来的
        // 因此用static吧...c++11似乎无法延续const reference&的lifetime
        return code;
    }
 
    string_iterator& operator++()
    {
        if (rem_length > 0) {
            usize_t len = mstr_char_length(*it);
            it += len;
            rem_length -= 1;
        }
        else {
#if _MSTR_USE_CPP_EXCEPTION
            throw mtfmt_error(MStr_Err_IteratorOutOfBound);
#else
            mstr_cause_exception(MStr_Err_IteratorOutOfBound);
#endif // _MSTR_USE_CPP_EXCEPTION
        }
        return *this;
    }
 
    string_iterator operator++(int)
    {
        string_iterator tmp = *this;
        ++*this;
        return tmp;
    }
 
    string_iterator& operator--()
    {
        if (it > beg) {
            usize_t run = static_cast<usize_t>(it - beg);
            // 因为迭代器是[begin, end)
            // 因此先减掉1
            usize_t len = mstr_lead_char_offset(it - 1, run);
            it -= len;
            rem_length += 1;
        }
        else {
#if _MSTR_USE_CPP_EXCEPTION
            throw mtfmt_error(MStr_Err_IteratorOutOfBound);
#else
            mstr_cause_exception(MStr_Err_IteratorOutOfBound);
#endif // _MSTR_USE_CPP_EXCEPTION
        }
        return *this;
    }
 
    string_iterator operator--(int)
    {
        string_iterator tmp = *this;
        --*this;
        return tmp;
    }
 
    bool operator==(const string_iterator& rhs) const noexcept
    {
        return it == rhs.it;
    }
 
    bool operator!=(const string_iterator& rhs) const noexcept
    {
        return it != rhs.it;
    }
};
 
template <typename T> struct fixed_wrapper
{
    using value_t = T;
 
    T value;
};
 
template <typename T> using wrapper_t = typename T::value_t;
 
} // namespace details
 
class string final
{
    MString this_obj;
 
public:
    using value_t = mstr_char_t;
    using pointer = value_t*;
    using const_pointer = const value_t*;
    using reference = value_t&;
    using const_reference = const value_t&;
    using size_type = size_t;
    using difference_type = ptrdiff_t;
    using const_iterator = details::string_iterator;
    using const_reverse_iterator =
        std::reverse_iterator<const_iterator>;
 
    using repeat_char_t = std::tuple<unicode_t, std::size_t>;
 
    string() noexcept
    {
        mstr_init(&this_obj);
    }
 
    string(const value_t* c_str)
    {
        mstr_create(&this_obj, c_str);
    }
 
    string(const std::string& str)
    {
        mstr_create(&this_obj, str.c_str());
    }
 
    string(const string& str) noexcept
    {
        mstr_init(&this_obj);
        mstr_copy_from(&this_obj, &str.this_obj);
    }
 
    ~string()
    {
        mstr_free(&this_obj);
    }
 
    string& operator=(const string& str) noexcept
    {
        mstr_clear(&this_obj);
        mstr_concat(&this_obj, &str.this_obj);
        return *this;
    }
 
    usize_t length() const noexcept
    {
        return this_obj.length;
    }
 
    usize_t byte_count() const noexcept
    {
        return this_obj.count;
    }
 
    bool operator==(const string& str) const noexcept
    {
        return !!mstr_equal(&this_obj, &str.this_obj);
    }
 
    template <std::size_t N>
    bool operator==(const value_t (&str)[N]) const noexcept
    {
        return !!mstr_equal_cstr(&this_obj, str, N - 1);
    }
 
    template <std::size_t N>
    friend bool operator==(
        const value_t (&str)[N], const string& pthis
    ) noexcept
    {
        return pthis == str;
    }
 
    bool operator!=(const string& str) const noexcept
    {
        return !(*this == str);
    }
 
    template <std::size_t N>
    bool operator!=(const value_t (&str)[N]) const noexcept
    {
        return !(*this == str);
    }
 
    template <std::size_t N>
    friend bool operator!=(
        const value_t (&str)[N], const string& pthis
    ) noexcept
    {
        return !(pthis == str);
    }
 
    result<unit_t, mstr_result_t> reserve(usize_t new_size) noexcept
    {
        mstr_result_t code = mstr_reserve(&this_obj, new_size);
        if (MSTR_SUCC(code)) {
            return unit_t();
        }
        else {
            return code;
        }
    }
 
    template <std::size_t N>
    bool start_with(const value_t (&prefix)[N]) const noexcept
    {
        return !!mstr_start_with(&this_obj, prefix, N);
    }
 
    bool start_with(const value_t* prefix) const noexcept
    {
        return !!mstr_start_with(&this_obj, prefix, strlen(prefix));
    }
 
    bool start_with(const string* prefix) const noexcept
    {
        const char* buff = prefix->this_obj.buff;
        usize_t buff_len = prefix->this_obj.count;
        return !!mstr_start_with(&this_obj, buff, buff_len);
    }
 
    template <std::size_t N>
    bool end_with(const value_t (&suffix)[N]) const noexcept
    {
        return !!mstr_end_with(&this_obj, suffix, N);
    }
 
    bool end_with(const value_t* suffix) const noexcept
    {
        return !!mstr_end_with(&this_obj, suffix, strlen(suffix));
    }
 
    bool end_with(const string* suffix) const noexcept
    {
        const char* buff = suffix->this_obj.buff;
        usize_t buff_len = suffix->this_obj.count;
        return !!mstr_end_with(&this_obj, buff, buff_len);
    }
 
    result<unit_t, mstr_result_t> push(unicode_t uni_char) noexcept
    {
        mstr_result_t code = mstr_append(&this_obj, uni_char);
        if (MSTR_SUCC(code)) {
            return unit_t();
        }
        else {
            return code;
        }
    }
 
    result<unit_t, mstr_result_t> push(
        unicode_t ch, std::size_t repeat
    ) noexcept
    {
        mstr_result_t code = mstr_repeat_append(&this_obj, ch, repeat);
        if (MSTR_SUCC(code)) {
            return unit_t();
        }
        else {
            return code;
        }
    }
 
    result<unit_t, mstr_result_t> concat(const string& rhs) noexcept
    {
        mstr_result_t code = mstr_concat(&this_obj, &rhs.this_obj);
        if (MSTR_SUCC(code)) {
            return unit_t();
        }
        else {
            return code;
        }
    }
 
    template <std::size_t N>
    result<unit_t, mstr_result_t> concat(const value_t (&rhs)[N]
    ) noexcept
    {
        mstr_result_t code = mstr_concat_cstr(&this_obj, rhs);
        if (MSTR_SUCC(code)) {
            return unit_t();
        }
        else {
            return code;
        }
    }
 
    string& operator+=(const string& rhs)
    {
        concat(rhs).or_exception([](error_code_t e) {
            return mtfmt_error(e);
        });
        return *this;
    }
 
    template <std::size_t N> string& operator+=(const value_t (&rhs)[N])
    {
        concat(rhs).or_exception([](error_code_t e) {
            return mtfmt_error(e);
        });
        return *this;
    }
 
    string& operator+=(unicode_t rhs)
    {
        push(rhs).or_exception([](error_code_t e) {
            return mtfmt_error(e);
        });
        return *this;
    }
 
    string& operator+=(const repeat_char_t& rhs)
    {
        auto ch = std::get<0>(rhs);
        auto cnt = std::get<1>(rhs);
        push(ch, cnt).or_exception([](error_code_t e) {
            return mtfmt_error(e);
        });
        return *this;
    }
 
    void clear() noexcept
    {
        mstr_clear(&this_obj);
    }
 
    void reverse() noexcept
    {
        mstr_reverse_self(&this_obj);
    }
 
    result<unit_t, error_code_t> insert(
        usize_t idx, unicode_t ch
    ) noexcept
    {
        error_code_t res = mstr_insert(&this_obj, idx, ch);
        if (MSTR_SUCC(res)) {
            return unit_t{};
        }
        else {
            return res;
        }
    }
 
    result<unicode_t, error_code_t> remove(usize_t idx) noexcept
    {
        unicode_t value = 0;
        error_code_t res = mstr_remove(&this_obj, &value, idx);
        if (MSTR_SUCC(res)) {
            return value;
        }
        else {
            return res;
        }
    }
 
    bool contains(const value_t* patt) const noexcept
    {
        return mstr_contains(&this_obj, patt, strlen(patt));
    }
 
    template <std::size_t N>
    bool contains(const value_t (&patt)[N]) const noexcept
    {
        return mstr_contains(&this_obj, patt, N);
    }
 
    bool contains(const string& patt) const noexcept
    {
        return mstr_contains(
            &this_obj, patt.this_obj.buff, patt.this_obj.count
        );
    }
 
    result<isize_t, error_code_t> find(
        const value_t* patt, usize_t begin_pos = 0, usize_t patt_len = 0
    ) const noexcept
    {
        mstr_result_t res;
        MStringMatchResult find_result;
        res = mstr_find(
            &this_obj,
            &find_result,
            begin_pos,
            patt,
            patt_len == 0 ? strlen(patt) : patt_len
        );
        if (MSTR_FAILED(res)) {
            return res;
        }
        else if (find_result.is_matched) {
            return static_cast<isize_t>(find_result.begin_pos);
        }
        else {
            return static_cast<isize_t>(-1);
        }
    }
 
    template <std::size_t N>
    result<isize_t, error_code_t> find(
        const value_t (&patt)[N], usize_t begin_pos = 0
    ) const noexcept
    {
        return find(patt, begin_pos, N);
    }
 
    result<isize_t, error_code_t> find(
        const mtfmt::string& patt, usize_t begin_pos = 0
    ) const noexcept
    {
        return find(patt.this_obj.buff, begin_pos, patt.this_obj.count);
    }
 
    result<usize_t, error_code_t> find_or_err(
        const value_t* patt, usize_t begin_pos = 0, usize_t patt_cnt = 0
    ) const noexcept
    {
        mstr_result_t res;
        MStringMatchResult find_result;
        res = mstr_find(
            &this_obj,
            &find_result,
            begin_pos,
            patt,
            patt_cnt == 0 ? strlen(patt) : patt_cnt
        );
        if (MSTR_FAILED(res)) {
            return res;
        }
        else if (find_result.is_matched) {
            return static_cast<isize_t>(find_result.begin_pos);
        }
        else {
            return MStr_Err_NoSubstrFound;
        }
    }
 
    template <std::size_t N>
    result<usize_t, error_code_t> find_or_err(
        const value_t (&patt)[N], usize_t begin_pos = 0
    ) const noexcept
    {
        return find_or_err(patt, begin_pos, N);
    }
 
    result<usize_t, error_code_t> find_or_err(
        const mtfmt::string& patt, usize_t begin_pos = 0
    ) const noexcept
    {
        return find_or_err(
            patt.this_obj.buff, begin_pos, patt.this_obj.count
        );
    }
 
    result<unit_t, error_code_t> retain(
        const value_t* patt,
        MStringReplaceOption mode = MStringReplaceOption_All,
        usize_t patt_cnt = 0
    ) noexcept
    {
        mstr_result_t res;
        res = mstr_retain(
            &this_obj,
            mode,
            patt,
            patt_cnt == 0 ? strlen(patt) : patt_cnt
        );
        if (MSTR_SUCC(res)) {
            return unit_t{};
        }
        else {
            return res;
        }
    }
 
    template <std::size_t N>
    result<unit_t, error_code_t> retain(
        const value_t (&patt)[N],
        MStringReplaceOption mode = MStringReplaceOption_All
    ) noexcept
    {
        return retain(patt, mode, N);
    }
 
    result<unit_t, error_code_t> retain(
        const mtfmt::string& patt,
        MStringReplaceOption mode = MStringReplaceOption_All
    ) noexcept
    {
        return retain(patt.this_obj.buff, mode, patt.this_obj.count);
    }
 
    const value_t* c_str() noexcept
    {
        return mstr_c_str(&this_obj);
    }
 
    std::string as_std_string()
    {
        return std::string(this_obj.buff, this_obj.count);
    }
 
    const_iterator begin() const noexcept
    {
        return const_iterator(
            this_obj.buff, this_obj.buff, this_obj.length
        );
    }
 
    const_iterator end() const noexcept
    {
        return const_iterator(
            this_obj.buff, this_obj.buff + this_obj.count, 0
        );
    }
 
    const_reverse_iterator rbegin() const noexcept
    {
        return const_reverse_iterator(end());
    }
 
    const_reverse_iterator rend() const noexcept
    {
        return const_reverse_iterator(begin());
    }
 
    unicode_t operator[](std::size_t i) const
    {
        unicode_t code = mstr_char_at(&this_obj, i);
        if (code == 0) {
#if _MSTR_USE_CPP_EXCEPTION
            throw mtfmt_error(MStr_Err_IndexOutOfBound);
#else
            mstr_cause_exception(MStr_Err_IndexOutOfBound);
#endif // _MSTR_USE_CPP_EXCEPTION
        }
        return code;
    }
 
    template <typename T>
    details::enable_if_t<
        std::is_signed<T>::value &&
            std::numeric_limits<T>::is_integer &&
            sizeof(T) <= sizeof(int32_t),
        result<unit_t, error_code_t>>
        append_from(
            const T& value,
            MStrFmtIntIndex index = MStrFmtIntIndex_Dec,
            MStrFmtSignDisplay sign = MStrFmtSignDisplay_NegOnly
        ) noexcept
    {
        error_code_t res = mstr_fmt_itoa(
            &this_obj, static_cast<int32_t>(value), index, sign
        );
        if (MSTR_SUCC(res)) {
            return unit_t{};
        }
        else {
            return res;
        }
    }
 
    template <typename T>
    details::enable_if_t<
        std::is_unsigned<T>::value &&
            std::numeric_limits<T>::is_integer &&
            sizeof(T) <= sizeof(uint32_t),
        result<unit_t, error_code_t>>
        append_from(
            const T& value, MStrFmtIntIndex index = MStrFmtIntIndex_Dec
        ) noexcept
    {
        error_code_t res = mstr_fmt_utoa(
            &this_obj, static_cast<uint32_t>(value), index
        );
        if (MSTR_SUCC(res)) {
            return unit_t{};
        }
        else {
            return res;
        }
    }
 
    template <typename T>
    details::enable_if_t<
        std::is_signed<details::wrapper_t<T>>::value &&
            details::is_instance_of<details::fixed_wrapper, T>::value,
        result<unit_t, error_code_t>>
        append_from(
            const T& value,
            int32_t p,
            MStrFmtSignDisplay sign = MStrFmtSignDisplay_NegOnly
        ) noexcept
    {
        error_code_t res = mstr_fmt_iqtoa(
            &this_obj, static_cast<int32_t>(value.value), p, sign
        );
        if (MSTR_SUCC(res)) {
            return unit_t{};
        }
        else {
            return res;
        }
    }
 
    template <typename T>
    details::enable_if_t<
        std::is_unsigned<details::wrapper_t<T>>::value &&
            details::is_instance_of<details::fixed_wrapper, T>::value,
        result<unit_t, error_code_t>>
        append_from(const T& value, uint32_t p) noexcept
    {
        error_code_t res = mstr_fmt_uqtoa(
            &this_obj, static_cast<uint32_t>(value.value), p
        );
        if (MSTR_SUCC(res)) {
            return unit_t{};
        }
        else {
            return res;
        }
    }
 
    template <typename T>
    static details::enable_if_t<
        std::is_signed<T>::value &&
            std::numeric_limits<T>::is_integer &&
            sizeof(T) <= sizeof(int32_t),
        result<string, error_code_t>>
        from(
            const T& value,
            MStrFmtIntIndex index = MStrFmtIntIndex_Dec,
            MStrFmtSignDisplay sign = MStrFmtSignDisplay_NegOnly
        ) noexcept
    {
        string ret_str;
        error_code_t res = mstr_fmt_itoa(
            &ret_str.this_obj, static_cast<int32_t>(value), index, sign
        );
        if (MSTR_SUCC(res)) {
            return ret_str;
        }
        else {
            return res;
        }
    }
 
    template <typename T>
    static details::enable_if_t<
        std::is_unsigned<T>::value &&
            std::numeric_limits<T>::is_integer &&
            sizeof(T) <= sizeof(uint32_t),
        result<string, error_code_t>>
        from(
            const T& value, MStrFmtIntIndex index = MStrFmtIntIndex_Dec
        ) noexcept
    {
        string ret_str;
        error_code_t res = mstr_fmt_utoa(
            &ret_str.this_obj, static_cast<uint32_t>(value), index
        );
        if (MSTR_SUCC(res)) {
            return ret_str;
        }
        else {
            return res;
        }
    }
 
    template <typename T>
    static details::enable_if_t<
        std::is_signed<details::wrapper_t<T>>::value &&
            details::is_instance_of<details::fixed_wrapper, T>::value,
        result<string, error_code_t>>
        from(
            const T& value,
            int32_t p,
            MStrFmtSignDisplay sign = MStrFmtSignDisplay_NegOnly
        ) noexcept
    {
        string ret_str;
        error_code_t res = mstr_fmt_iqtoa(
            &ret_str.this_obj,
            static_cast<int32_t>(value.value),
            p,
            sign
        );
        if (MSTR_SUCC(res)) {
            return ret_str;
        }
        else {
            return res;
        }
    }
 
    template <typename T>
    static details::enable_if_t<
        std::is_unsigned<details::wrapper_t<T>>::value &&
            details::is_instance_of<details::fixed_wrapper, T>::value,
        result<string, error_code_t>>
        from(const T& value, uint32_t p) noexcept
    {
        string ret_str;
        error_code_t res = mstr_fmt_uqtoa(
            &ret_str.this_obj, static_cast<uint32_t>(value.value), p
        );
        if (MSTR_SUCC(res)) {
            return ret_str;
        }
        else {
            return res;
        }
    }
 
    template <std::size_t N>
    constexpr static unicode_t unicode_char(const value_t (&u8char)[N])
    {
#if _MSTR_USE_UTF_8
        return details::unicode_char(u8char);
#else
        return static_cast<unicode_t>(u8char[0]);
#endif // _MSTR_USE_UTF_8
    }
 
    template <std::size_t N, typename... Args>
    static result<string, error_code_t> format(
        const value_t (&fmt_str)[N], Args&&... args
    )
    {
        return format_variable(fmt_str, std::forward<Args&&>(args)...);
    }
 
    template <typename... Args>
    static result<string, error_code_t> format_variable(
        const string::value_t* fmt_str, Args&&... args
    )
    {
        string str;
        error_code_t code = mstr_format(
            &str.raw_object_mut(),
            fmt_str,
            sizeof...(args),
            std::forward<Args&&>(args)...
        );
        if (MSTR_SUCC(code)) {
            return str;
        }
        else {
            return code;
        }
    }
 
protected:
    const MString& raw_object() const noexcept
    {
        return this_obj;
    }
 
    MString& raw_object_mut() noexcept
    {
        return this_obj;
    }
};
 
template <typename T>
details::fixed_wrapper<T> fixed_value(const T& value)
{
    return details::fixed_wrapper<T>{value};
}
 
namespace literals
{
inline string operator""_ms(const char* str)
{
    return string(str);
}
} // namespace literals
 
} // namespace mtfmt
#endif // _INCLUDE_MM_STRING_HPP_