byte_cursor.hpp

浏览该文件的文档.

#ifndef NEFORCE_NETWORK_HTTP_BYTE_CURSOR_HPP__
#define NEFORCE_NETWORK_HTTP_BYTE_CURSOR_HPP__

 
#include "NeForce/core/memory/endian.hpp"
#include "NeForce/core/memory/memory_view.hpp"
#include "NeForce/core/utility/optional.hpp"
NEFORCE_BEGIN_NAMESPACE__
NEFORCE_BEGIN_HTTP__


class byte_cursor {
private:
    const byte_t* data_ = nullptr;
    size_t size_ = 0;
    size_t pos_ = 0;
    uint64_t bit_buf_ = 0;
    size_t bits_in_buf_ = 0;
 
public:
    byte_cursor() noexcept = default;

    byte_cursor(const byte_t* data, size_t size) noexcept :
    data_(data),
    size_(size) {}

    explicit byte_cursor(cbyte_view view) noexcept :
    data_(view.data()),
    size_(view.size()) {}

    NEFORCE_NODISCARD size_t remaining() const noexcept { return size_ - pos_; }
    NEFORCE_NODISCARD size_t consumed_bytes() const noexcept { return pos_; }
    NEFORCE_NODISCARD bool exhausted() const noexcept { return pos_ >= size_; }
    NEFORCE_NODISCARD const byte_t* data() const noexcept { return data_; }
    NEFORCE_NODISCARD size_t size() const noexcept { return size_; }

    NEFORCE_NODISCARD optional<byte_t> try_read_byte() noexcept {
        if (pos_ >= size_) {
            return none;
        }
        return data_[pos_++];
    }

    NEFORCE_NODISCARD optional<byte_t> peek_byte() const noexcept {
        if (pos_ >= size_) {
            return none;
        }
        return data_[pos_];
    }

    NEFORCE_NODISCARD optional<uint16_t> try_read_be16() noexcept {
        if (pos_ + 2 > size_) {
            return none;
        }
        const uint16_t val = endian::read_be16(data_ + pos_);
        pos_ += 2;
        return val;
    }

    NEFORCE_NODISCARD optional<uint32_t> try_read_be24() noexcept {
        if (pos_ + 3 > size_) {
            return none;
        }
        const uint32_t val = endian::read_be24(data_ + pos_);
        pos_ += 3;
        return val;
    }

    NEFORCE_NODISCARD optional<uint32_t> try_read_be32() noexcept {
        if (pos_ + 4 > size_) {
            return none;
        }
        const uint32_t val = endian::read_be32(data_ + pos_);
        pos_ += 4;
        return val;
    }

    NEFORCE_NODISCARD optional<uint64_t> try_read_be64() noexcept {
        if (pos_ + 8 > size_) {
            return none;
        }
        const uint64_t val = endian::read_be64(data_ + pos_);
        pos_ += 8;
        return val;
    }

    NEFORCE_NODISCARD optional<uint16_t> try_read_le16() noexcept {
        if (pos_ + 2 > size_) {
            return none;
        }
        const uint16_t val = endian::read_le16(data_ + pos_);
        pos_ += 2;
        return val;
    }

    NEFORCE_NODISCARD optional<uint32_t> try_read_le32() noexcept {
        if (pos_ + 4 > size_) {
            return none;
        }
        const uint32_t val = endian::read_le32(data_ + pos_);
        pos_ += 4;
        return val;
    }

    NEFORCE_NODISCARD optional<uint64_t> try_read_le64() noexcept {
        if (pos_ + 8 > size_) {
            return none;
        }
        const uint64_t val = endian::read_le64(data_ + pos_);
        pos_ += 8;
        return val;
    }

    NEFORCE_NODISCARD optional<cbyte_view> try_read_bytes(size_t count) noexcept {
        if (pos_ + count > size_) {
            return none;
        }
        cbyte_view view(data_ + pos_, count);
        pos_ += count;
        return view;
    }

    bool skip(size_t count) noexcept {
        if (pos_ + count > size_) {
            return false;
        }
        pos_ += count;
        return true;
    }

    void reset(const byte_t* data, size_t size) noexcept {
        data_ = data;
        size_ = size;
        pos_ = 0;
        bit_buf_ = 0;
        bits_in_buf_ = 0;
    }

    NEFORCE_NODISCARD optional<uint64_t> try_read_bits(uint8_t n) noexcept {
        if (n > 64) {
            return none;
        }
        while (bits_in_buf_ < n) {
            auto b = try_read_byte();
            if (!b) {
                return none;
            }
            bit_buf_ = (bit_buf_ << 8) | *b;
            bits_in_buf_ += 8;
        }
        bits_in_buf_ -= n;
        const uint64_t mask = (n == 64) ? numeric_traits<uint64_t>::max() : ((1ULL << n) - 1);
        return (bit_buf_ >> bits_in_buf_) & mask;
    }

    NEFORCE_NODISCARD optional<uint64_t> try_peek_bits(uint8_t n) const noexcept {
        if (n > 64 || bits_in_buf_ < n) {
            return none;
        }
        const uint64_t mask = (n == 64) ? numeric_traits<uint64_t>::max() : ((1ULL << n) - 1);
        return (bit_buf_ >> (bits_in_buf_ - n)) & mask;
    }

    void skip_bits(uint8_t n) noexcept {
        if (n <= bits_in_buf_) {
            bits_in_buf_ -= n;
        } else {
            bits_in_buf_ = 0;
        }
    }

    NEFORCE_NODISCARD size_t bits_remaining() const noexcept { return bits_in_buf_; }

    bool refill_bits() noexcept {
        if (exhausted()) {
            return false;
        }
        bit_buf_ = (bit_buf_ << 8) | data_[pos_++];
        bits_in_buf_ += 8;
        return true;
    }
};
 // ByteCursor
 
NEFORCE_END_HTTP__
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_NETWORK_HTTP_BYTE_CURSOR_HPP__