Frame.h

// SPDX-License-Identifier: MIT
#pragma once
 
#include "wrap_endian.h"
#include <memory>
 
struct Frame {
    Frame(size_t length, const void* data = nullptr);
 
    uint8_t operator[](size_t index) const;
 
    size_t capacity() const;
 
    Frame& clear();
 
    Frame& limit(size_t newSize);
 
    Frame& reset(size_t newSize = 4096);
 
    const uint8_t* data() const;
 
    template<typename T> T pop()
    {
        T value {};
        if (sizeof(value) <= capacity()) {
            value = *reinterpret_cast<T*>(m_Pos);
        }
        remove(sizeof(T));
        return value;
    }
 
    template<typename T> T pop_letoh()
    {
        return bhf::ads::letoh(pop<T>());
    }
 
    Frame& prepend(const void* const data, const size_t size);
 
    template<class T> Frame& prepend(const T& header)
    {
        return prepend(&header, sizeof(T));
    }
 
    uint8_t* rawData() const;
 
    Frame& remove(size_t numBytes);
 
    template<class T> T remove()
    {
        const auto p = m_Pos;
        remove(sizeof(T));
        return T(p);
    }
 
    size_t size() const;
 
private:
    std::unique_ptr<uint8_t[]> m_Data;
    uint8_t* m_Pos;
    size_t m_Size;
    size_t m_OriginalSize;
};