Class BitSet

source/MRMesh/MRBitSet.h:68–271

std::vector like container (random-access, size_t - index type, bool - value type) with all bits after size() considered off during testing

/// std::vector<bool> like container (random-access, size_t - index type, bool - value type)
/// with all bits after size() considered off during testing
class BitSet
{
public:
    using block_type = std::uint64_t;
    inline static constexpr size_t bits_per_block = sizeof( block_type ) * 8;
    inline static constexpr size_t npos = (size_t)-1;

    using size_type = size_t;
    using IndexType = size_t;

    /// creates empty bitset
    BitSet() noexcept = default;

    /// creates bitset of given size filled with given value
    explicit BitSet( size_t numBits, bool fillValue = false ) { resize( numBits, fillValue ); }

    /// creates bitset from the given blocks of bits
    static BitSet fromBlocks( std::vector<block_type> && blocks )
    {
        BitSet res;
        res.blocks_ = std::move( blocks );
        res.numBits_ = res.blocks_.size() * bits_per_block;
        return res;
    }

    void reserve( size_type numBits ) { blocks_.reserve( calcNumBlocks_( numBits ) ); }
    MRMESH_API void resize( size_type numBits, bool fillValue = false );
    void clear() { numBits_ = 0; blocks_.clear(); }
    void shrink_to_fit() { blocks_.shrink_to_fit(); }

    [[nodiscard]] bool empty() const noexcept { return numBits_ == 0; }
    [[nodiscard]] size_type size() const noexcept { return numBits_; }
    [[nodiscard]] size_type num_blocks() const noexcept { return blocks_.size(); }
    [[nodiscard]] size_type capacity() const noexcept { return blocks_.capacity() * bits_per_block; }

    [[nodiscard]] bool uncheckedTest( IndexType n ) const { assert( n < size() ); return blocks_[blockIndex_( n )] & bitMask_( n ); }
    [[nodiscard]] bool uncheckedTestSet( IndexType n, bool val = true ) { assert( n < size() ); bool b = uncheckedTest( n ); if ( b != val ) set( n, val ); return b; }

    // all bits after size() we silently consider as not-set
    [[nodiscard]] bool test( IndexType n ) const { return n < size() ? uncheckedTest( n ) : false; } // return n < size() && uncheckedTest( n ); was compiled with extra conditional jump inside uncheckedTest() by MSVC
    [[nodiscard]] bool test_set( IndexType n, bool val = true ) { return ( val || n < size() ) ? uncheckedTestSet( n, val ) : false; }

    MRMESH_API BitSet & set( IndexType n, size_type len, bool val );
    BitSet & set( IndexType n, bool val ) { return val ? set( n ) : reset( n ); } // Not using a default argument for `val` to get better C bindings.
    BitSet & set( IndexType n ) { assert( n < size() ); blocks_[blockIndex_( n )] |= bitMask_( n ); return * this; }
    MRMESH_API BitSet & set();

    MRMESH_API BitSet & reset( IndexType n, size_type len );
    BitSet & reset( IndexType n ) { if ( n < size() ) blocks_[blockIndex_( n )] &= ~bitMask_( n ); return * this; }
    MRMESH_API BitSet & reset();

    MRMESH_API BitSet & flip( IndexType n, size_type len );
    BitSet & flip( IndexType n ) { assert( n < size() ); blocks_[blockIndex_( n )] ^= bitMask_( n ); return * this; }
    MRMESH_API BitSet & flip();

    /// changes the order of bits on the opposite
    MRMESH_API void reverse();