struct TurboBuffer
{
    void*  buffer;
    size_t size;
    size_t capacity;

    TurboBuffer()
    {
        buffer = new uint8_t[16];
        size = 0;
        capacity = 16;
    }

    void extend_buffer(size_t new_capacity)
    {
        uint8_t* old_buffer = (uint8_t*)buffer;

        buffer = new uint8_t[new_capacity];
        memcpy(buffer, old_buffer, size);

        delete[] old_buffer;

        capacity = new_capacity;
    }

    void add_something(const void* data, size_t data_size)
    {
        if (capacity - size <= data_size)
            extend_buffer(capacity + data_size);

        memcpy((uint8_t*)buffer + size, data, data_size);
        size += data_size;
    }

    template <typename T>
    void add_entry(const T& value)
    {
        uint32_t next_offset = size + sizeof(value) + 4;

        add_something(&next_offset, 4);
        add_something(&value, sizeof(T));
    }

    template <typename T>
    T* get_first()
    {
        if (size == 0)
            return nullptr;

        return (T*)((uint8_t*)buffer + 4);
    }

    template <typename T>
    T* get_next(void* current)
    {
        uint32_t next_offset = *(uint32_t*)((uint8_t*)current - 4) + 4;
        if (next_offset >= size)
            return nullptr;

        return (T*)((uint8_t*)buffer + next_offset);
    }
};