BitArray.h

#pragma once


#include <libutl/Vector.h>


UTL_NS_BEGIN;


class BitArrayElem;



class BitArray : public Object
{
    UTL_CLASS_DECL(BitArray, Object);

public:
    BitArray(uint64_t size, uint_t numBits = 1)
    {
        init();
        initialize(size, numBits);
    }

    virtual size_t innerAllocatedSize() const;

    virtual int compare(const Object& rhs) const;

    virtual void copy(const Object& rhs);

    virtual void steal(Object& rhs);

    virtual void dump(Stream& os, uint_t level = uint_t_max) const;

    virtual void serialize(Stream& stream, uint_t io, uint_t mode = ser_default);

    void clear();

    void initialize(uint64_t size, uint_t numBits = 1);

    uint64_t
    size() const
    {
        return _size;
    }

    void
    grow(uint64_t size)
    {
        if (size > this->size()) setSize(size);
    }

    void setSize(uint64_t size);

    uint64_t get(uint64_t pos) const;

    void set(uint64_t idx, uint64_t val);

    void setAll(uint64_t val);

    uint64_t operator[](uint_t idx) const
    {
        return get((uint64_t)idx);
    }

    uint64_t operator[](int idx) const
    {
        return get((uint64_t)idx);
    }

    uint64_t operator[](uint64_t idx) const
    {
        return get((uint64_t)idx);
    }

    uint64_t operator[](int64_t idx) const
    {
        return get((uint64_t)idx);
    }

    BitArrayElem operator[](uint_t idx);

    BitArrayElem operator[](int idx);

    BitArrayElem operator[](uint64_t idx);

    BitArrayElem operator[](int64_t idx);

private:
    void init();
    void deInit();

private:
    uint_t _numBits;
    uint64_t _size;
    size_t _arraySize;
    uint64_t* _array;
};


UTL_NS_END;


#include <libutl/BitArrayElem.h>