Class BitArray

library/include/BitArray.h:39–209

{
    template <typename T = int>
    class BitArray
    {
    private:
        // note that these are mandated by the implementation of flagarrayst in DF code, and must be exactly as below
        using buffer_type = unsigned char;
        using size_type = int32_t;

        buffer_type* _bits;
        size_type _size;

        void resize(size_type newsize, const BitArray<T>* replacement)
        {
            if (newsize == _size)
                return;

            if (newsize == 0)
            {
                delete[] _bits;
                _bits = nullptr;
                _size = 0;
                return;
            }

            buffer_type* old_data = _bits;

            _bits = new buffer_type[newsize];

            buffer_type* copysrc = replacement ? replacement->_bits : old_data;
            size_type copysize = replacement ? replacement->_size : _size;

            if (copysrc)
                std::memcpy(_bits, copysrc, std::min(copysize, newsize));

            if (newsize > _size)
                std::memset(_bits + _size, 0, newsize - _size);

            delete[] old_data;

            _size = newsize;
        }

        void extend(T index)
        {
            size_type newsize = (index + 7 ) / 8;
            if (newsize > _size)
                resize(newsize);
        }

    public:
        BitArray() : _bits(nullptr), _size(0) {}
        BitArray(const BitArray<T> &other) : _bits(nullptr), _size(0)
        {
            resize(other._size, &other);
        }
        ~BitArray()
        {
            delete [] _bits;
        }