BitAlignedBuffer.h

#pragma once
#include <NDEVR/Buffer.h>
namespace NDEVR
{
    class BitAlignedBuffer
    {
    public:
        BitAlignedBuffer(uint04 bits_per_element)
            : m_bits_per_element(bits_per_element)
        {
            lib_assert(bits_per_element != 0 && bits_per_element < 64, "Bad Bit Alignment");
        }

        void setSize(uint04 size)
        {
            ensureCapacity(size);
            m_size = size;
        }

        void loadFromBytes(const uint8_t* data, uint04 byteCount)
        {
            lib_assert(data && byteCount > 0, "Invalid input data");
 
            // Resize storage to hold the incoming bytes
            uint04 word_count = (byteCount + 7) / 8;
            storage.setSize(word_count, 0);
 
            // Copy bytes into storage
            for (uint04 i = 0; i < byteCount; ++i)
            {
                uint04 wordIndex = i / 8;
                uint04 byte_offset = i % 8;
                storage[wordIndex] |= static_cast<uint08>(data[i]) << (byte_offset * 8);
            }
 
            // Compute new size (number of elements)
            uint04 total_bits = byteCount * 8;
            m_size = total_bits / m_bits_per_element;;
        }

        void add(uint08 value)
        {
            lib_assert(value < (1ULL << m_bits_per_element), "value too large");
            ensureCapacity(m_size + 1);
 
            uint04 bitPos = m_size * m_bits_per_element;
            uint04 wordIndex = bitPos / 64;
            uint04 bitOffset = bitPos % 64;
 
            // Clear destination bits
            storage[wordIndex] &= ~(((1ULL << m_bits_per_element) - 1) << bitOffset);
            // Write the value
            storage[wordIndex] |= (value << bitOffset);
 
            // Handle spillover to next word
            if (bitOffset + m_bits_per_element > 64) {
                uint08 spillBits = (bitOffset + m_bits_per_element) - 64;
                storage[wordIndex + 1] &= ~((1ULL << spillBits) - 1);
                storage[wordIndex + 1] |= (value >> (m_bits_per_element - spillBits));
            }
 
            ++m_size;
        }

        uint08 getValueAtBitOffset(uint04 bit_pos) const
        {
            lib_assert(bit_pos < m_size * m_bits_per_element, "Index out of range");
            uint04 word_index = bit_pos / 64;
            uint04 bit_offset = bit_pos % 64;
            uint04 and_value = ((1ULL << m_bits_per_element) - 1);
            uint08 value = (storage[word_index] >> bit_offset) & and_value;
 
            // Handle spillover to next word
            if (bit_offset + m_bits_per_element > 64)
            {
                uint08 spillBits = (bit_offset + m_bits_per_element) - 64;
                uint08 nextBits = storage[word_index + 1] & ((1ULL << spillBits) - 1);
                value |= (nextBits << (m_bits_per_element - spillBits));
            }
 
            return value;
        }

        void clear()
        {
            storage.clear();
            m_size = 0;
        }

        uint08 operator[](uint04 index) const
        {
            lib_assert(index < m_size, "Index out of range");
            return getValueAtBitOffset(index * m_bits_per_element);
        }

        void set(uint04 index, uint08 value)
        {
            lib_assert(index < m_size, "Index out of range");
            lib_assert(value < (1ULL << m_bits_per_element), "Value exceeds bit limit");
 
            uint04 bitPos = index * m_bits_per_element;
            uint04 wordIndex = bitPos / 64;
            uint04 bitOffset = bitPos % 64;
 
            // Clear destination bits
            storage[wordIndex] &= ~(((1ULL << m_bits_per_element) - 1) << bitOffset);
            // Write value
            storage[wordIndex] |= (value << bitOffset);
 
            // Handle spillover
            if (bitOffset + m_bits_per_element > 64) {
                uint08 spillBits = (bitOffset + m_bits_per_element) - 64;
                storage[wordIndex + 1] &= ~((1ULL << spillBits) - 1);
                storage[wordIndex + 1] |= (value >> (m_bits_per_element - spillBits));
            }
        }

        uint04 bitSize() const
        {
            return m_bits_per_element;
        }

        uint04 size() const
        {
            return m_size;
        }

        void ensureCapacity(uint04 newSize)
        {
            uint04 totalBits = newSize * m_bits_per_element;
            uint04 requiredWords = (totalBits + 63) / 64;
            if (storage.size() < requiredWords)
            {
                storage.setSize(requiredWords, 0U);
            }
        }
    private:
        uint04 m_bits_per_element; 
        uint04 m_size = 0; 
        Buffer<uint08> storage; 
    };
 
}