stream_buffer.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) 2024 Cisco Systems
// SPDX-License-Identifier: BSD-2-Clause
 
#pragma once
 
#include "quicr/messages/uintvar.h"
 
#include <algorithm>
#include <any>
#include <cstring>
#include <optional>
#include <span>
#include <type_traits>
#include <vector>
 
namespace quicr {
 
    template<typename T, class Allocator = std::allocator<T>>
    class StreamBuffer
    {
        using BufferT = std::vector<T, Allocator>;
 
      public:
        StreamBuffer(std::size_t compact_threshold = 4096)
          : compact_threshold_(compact_threshold)
        {
        }
 
        template<typename D>
        void InitAny()
        {
            parsed_data_.emplace<D>();
        }
 
        template<typename D>
        void InitAnyB()
        {
            parsed_dataB_.emplace<D>();
        }
 
        template<typename D>
        void InitAny(uint64_t type)
        {
            parsed_data_.emplace<D>();
            parsed_data_type_ = type;
        }
 
        template<typename D>
        D& GetAny()
        {
            return std::any_cast<D&>(parsed_data_);
        }
 
        template<typename D>
        D& GetAnyB()
        {
            return std::any_cast<D&>(parsed_dataB_);
        }
 
        std::optional<uint64_t> GetAnyType() { return parsed_data_type_; }
 
        void SetAnyType(uint64_t type) { parsed_data_type_ = type; }
 
        void Clear()
        {
            ResetAny();
            buffer_.clear();
            read_offset_ = 0;
        }
 
        void ResetAny()
        {
            parsed_data_.reset();
            parsed_dataB_.reset();
            parsed_data_type_ = std::nullopt;
        }
 
        void ResetAnyB() { parsed_dataB_.reset(); }
 
        template<class D>
        void ResetAnyB()
        {
            ResetAnyB();
            InitAnyB<D>();
        }
 
        bool AnyHasValue() { return parsed_data_.has_value(); }
 
        bool AnyHasValueB() { return parsed_dataB_.has_value(); }
 
        bool Empty() const noexcept { return read_offset_ >= buffer_.size(); }
 
        size_t Size() noexcept { return read_offset_ >= buffer_.size() ? 0 : buffer_.size() - read_offset_; }
 
        std::span<const T> Front() noexcept
        {
            if (Empty()) {
                return {};
            }
 
            return { buffer_.data() + read_offset_, 1 };
        }
 
        std::span<const T> Front(std::size_t length) noexcept
        {
            if (Empty()) {
                return {};
            }
 
            const auto logical_size = buffer_.size() - read_offset_;
            return logical_size < length ? std::span<const T>{}
                                         : std::span<const T>{ buffer_.data() + read_offset_, length };
        }
 
        std::span<const T> Data() noexcept
        {
            if (Empty()) {
                return {};
            }
 
            return { buffer_.data() + read_offset_, buffer_.size() - read_offset_ };
        }
 
        BufferT TakeAll()
        {
            BufferT taken;
            if (read_offset_ == 0) {
                taken = std::move(buffer_);
            } else {
                taken.assign(buffer_.begin() + static_cast<std::ptrdiff_t>(read_offset_), buffer_.end());
            }
 
            buffer_.clear();
            read_offset_ = 0;
 
            return taken;
        }
 
        void Pop()
        {
            if (Empty()) {
                return;
            }
 
            PopInternal(1);
        }
 
        void Pop(std::size_t length)
        {
            if (length == 0 || Empty()) {
                return;
            }
 
            PopInternal(length);
        }
 
        bool Available(std::size_t length) const noexcept
        {
            return length == 0 || (read_offset_ < buffer_.size() && buffer_.size() - read_offset_ >= length);
        }
 
        void Push(const T& value)
        {
            CompactFrontIfNeeded();
 
            buffer_.push_back(value);
        }
 
        void Push(T&& value)
        {
            CompactFrontIfNeeded();
 
            buffer_.push_back(std::move(value));
        }
 
        void Push(std::span<const T> value)
        {
            CompactFrontIfNeeded();
 
            buffer_.insert(buffer_.end(), value.begin(), value.end());
        }
 
        void PushLengthBytes(std::span<const T> value)
        {
            CompactFrontIfNeeded();
 
            UintVar len(static_cast<uint64_t>(value.size()));
            buffer_.insert(buffer_.end(), len.begin(), len.end());
            buffer_.insert(buffer_.end(), value.begin(), value.end());
        }
 
        std::optional<uint64_t> DecodeUintV(bool pop = true)
        {
            const auto uintv = ReadUintV(pop);
            if (uintv) {
                return uint64_t(*uintv);
            }
            return std::nullopt;
        }
 
        std::optional<UintVar> ReadUintV(bool pop = true)
        {
            if (Empty()) {
                return std::nullopt;
            }
 
            const auto& uv_msb = buffer_[read_offset_];
            std::size_t uv_len = UintVar::Size(uv_msb);
 
            const auto logical_size = buffer_.size() - read_offset_;
            if (logical_size >= uv_len) {
                auto val = UintVar(std::span<const T>{ buffer_.data() + read_offset_, uv_len });
                if (pop) {
                    PopInternal(uv_len);
                }
 
                return val;
            }
 
            return std::nullopt;
        }
 
        std::optional<std::vector<uint8_t>> DecodeBytes()
        {
            if (Empty()) {
                return std::nullopt;
            }
 
            const auto& uv_msb = buffer_[read_offset_];
            std::size_t uv_len = UintVar::Size(uv_msb);
 
            auto logical_size = buffer_.size() - read_offset_;
            if (logical_size >= uv_len) {
                auto len = UintVar(std::span<const T>{ buffer_.data() + read_offset_, uv_len });
                if (logical_size >= uv_len + uint64_t(len)) {
                    PopInternal(uv_len);
                    auto v = std::span<const T>{ buffer_.data() + read_offset_, uint64_t(len) };
                    auto bytes = std::vector<uint8_t>(v.begin(), v.end());
                    PopInternal(uint64_t(len));
 
                    return bytes;
                }
            }
 
            return std::nullopt;
        }
 
      private:
        void CompactFrontIfNeeded()
        {
 
            if (read_offset_ == 0) {
                return;
            }
 
            const std::size_t logical_size = buffer_.size() - read_offset_;
 
            if (read_offset_ < compact_threshold_ && read_offset_ <= logical_size) {
                return;
            }
 
            if (read_offset_ >= buffer_.size()) {
                buffer_.clear();
                read_offset_ = 0;
                return;
            }
 
            if constexpr (std::is_trivially_copyable_v<T>) {
                std::memmove(buffer_.data(), buffer_.data() + read_offset_, logical_size * sizeof(T));
            } else {
                std::move(buffer_.begin() + static_cast<std::ptrdiff_t>(read_offset_), buffer_.end(), buffer_.begin());
            }
 
            buffer_.resize(logical_size);
            read_offset_ = 0;
        }
 
        void PopInternal(std::size_t length)
        {
            if (read_offset_ >= buffer_.size() || length >= buffer_.size() - read_offset_) {
                buffer_.clear();
                read_offset_ = 0;
                return;
            }
 
            read_offset_ += length;
        }
 
      private:
        BufferT buffer_;
        std::any parsed_data_;                     
        std::any parsed_dataB_;                    
        std::optional<uint64_t> parsed_data_type_; 
        std::size_t read_offset_{ 0 };
        std::size_t compact_threshold_{ 4096 };
    };
 
}