utf_iterator.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_STRING_UTF_ITERATOR_HPP__
#define NEFORCE_CORE_STRING_UTF_ITERATOR_HPP__

 
#include "NeForce/core/string/codepoint.hpp"
NEFORCE_BEGIN_NAMESPACE__


class utf8_iterator {
public:
    using value_type = codepoint;                   
    using reference = const codepoint&;             
    using pointer = const codepoint*;               
    using difference_type = ptrdiff_t;              
    using iterator_category = forward_iterator_tag; 
 
private:
    const byte_t* data_ = nullptr;
    size_t remaining_ = 0;
    size_t consumed_ = 0;
    codepoint current_;
 
    void decode_current() noexcept {
        if ((data_ != nullptr) && remaining_ > 0) {
            size_t pos = 0;
            current_ = codepoint::decode_utf8(data_, pos, remaining_);
            consumed_ = pos;
        } else {
            current_ = codepoint::null();
            consumed_ = 0;
        }
    }
 
public:
    utf8_iterator() noexcept = default;

    utf8_iterator(const byte_t* data, size_t remaining) noexcept :
    data_(data),
    remaining_(remaining) {
        decode_current();
    }

    NEFORCE_NODISCARD reference operator*() const noexcept { return current_; }

    NEFORCE_NODISCARD pointer operator->() const noexcept { return &current_; }

    utf8_iterator& operator++() noexcept {
        if ((data_ != nullptr) && remaining_ > 0) {
            data_ += consumed_;
            remaining_ -= _NEFORCE min(remaining_, consumed_);
            decode_current();
        }
        return *this;
    }

    utf8_iterator operator++(int) noexcept {
        const utf8_iterator tmp = *this;
        ++*this;
        return move(tmp);
    }

    NEFORCE_NODISCARD bool operator==(const utf8_iterator& other) const noexcept {
        if (remaining_ == 0 && other.remaining_ == 0) {
            return true;
        }
        return data_ == other.data_ && remaining_ == other.remaining_;
    }

    NEFORCE_NODISCARD bool operator!=(const utf8_iterator& other) const noexcept { return !(*this == other); }
};

class utf8_range {
    const byte_t* data_; 
    size_t size_;        
 
public:
    explicit utf8_range(const string_view sv) noexcept :
    data_(reinterpret_cast<const byte_t*>(sv.data())),
    size_(sv.size()) {}
 
    explicit utf8_range(const byte_t* data, const size_t size) noexcept :
    data_(data),
    size_(size) {}

    NEFORCE_NODISCARD utf8_iterator begin() const noexcept { return {data_, size_}; }

    NEFORCE_NODISCARD utf8_iterator end() const noexcept { return {nullptr, 0}; }
};
 // UtfIterator
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_STRING_UTF_ITERATOR_HPP__