BitArray Class Reference

#include <bitarray.h>

Classes
class	NumberSetProxy

Public Member Functions
	BitArray ()
	BitArray (int n)
	BitArray (const BitArray &b)
	~BitArray ()
void	SetSize (int n, int save=0)
int	GetSize () const
void	ClearAll ()
void	SetAll ()
void	Set (int i)
void	Clear (int i)
void	Set (int i, int b)
__forceinline int	operator[] (int i) const
bool	IsEmpty () const
bool	AnyBitSet () const
NumberSetProxy	NumberSet () const
void	Compress ()
void	Expand ()
void	Reverse (bool keepZero=false)
void	Rotate (int direction, int count)
void	Shift (int direction, int count, int where=0)
void	EnumSet (BitArrayCallback &cb)
void	DeleteSet (BitArray &dset, int mult=1)
void	DeleteSetAndResize (const BitArray &dset, int mult=1)
UTILGEOMEXPORT IOResult	Save (ISave *isave)
UTILGEOMEXPORT IOResult	Load (ILoad *iload)
bool	operator== (const BitArray &b) const
BitArray &	operator= (const BitArray &b)
BitArray &	operator&= (const BitArray &b)
BitArray &	operator|= (const BitArray &b)
BitArray &	operator^= (const BitArray &b)
BitArray	operator& (const BitArray &) const
BitArray	operator| (const BitArray &) const
BitArray	operator^ (const BitArray &) const
BitArray	operator~ () const
void	Swap (BitArray &other)
	Swap the contents of two bitarrays.

Friends
class	NumberSetProxy

Detailed Description

See also

Template Class Tab, Class BitArrayCallback.

Description:

This class allows the developer to define a set of bit flags that may be treated as a virtual array and are stored in an efficient manner. The class has methods to set, clear and return the i-th bit, resize the BitArray, etc. All methods are implemented by the system.

Constructor & Destructor Documentation

BitArray() [1/3]

BitArray ( )

inline

Remarks

Default constructor. Sets the number of bits to 0.

    {
        bits = nullptr;
        numBits = 0;
        BitArrayAllocated();
    }

BitArray() [2/3]

BitArray ( int  n )

inline

Remarks

Constructor.

Parameters:

int i

The size of the BitArray in bits.

    {
        assert(n >= 0);
        if (n < 0)
        {
            n = 0;
        }
        if (UseLocalBits(n))
        {
            numBits = n;
            localBits = 0;
 
            BitArrayAllocated();
        }
        else
        {
            CreateBitArrayImpl(n);
        }
    }

BitArray() [3/3]

BitArray ( const BitArray &  b )

inline

Remarks

Constructor. Duplicates the BitArray passed.

Parameters:

const BitArray& b

The BitArray to duplicate.

    {
        if (b.UseLocalBits())
        {
            localBits = b.localBits;
            numBits = b.numBits;
 
            BitArrayAllocated();
        }
        else
        {
            SetBitsFromImpl(b);
        }
    }

~BitArray()

~BitArray ( )

inline

    {
        if (!UseLocalBits())
            FreeBitsImpl();
        else
            BitArrayDeallocated();
    }

Member Function Documentation

SetSize()

void SetSize	(	int	n,
		int	save = 0
	)

Remarks

Sets the number of bits used.

Parameters

n	- The number of bits in to be in the array. If this value is a negative number, or equal to the current size of the BitArray then nothing will happen.
save	- If passed as 1, the old bit values will be preserved when the array is resized.

GetSize()

int GetSize ( ) const

inline

Remarks

Returns the size of the bit array in bits.

    {
        return numBits;
    }

ClearAll()

void ClearAll ( )

inline

Remarks

Clears all the bits in the array (sets them to 0).

    {
        if (UseLocalBits())
        {
            localBits = 0;
        }
        else
        {
            ClearAllImpl();
        }
    }

SetAll()

void SetAll ( )

inline

Remarks

Sets all the bits in the array to 1.

    {
        if (UseLocalBits())
        {
            localBits = BitMask(numBits) - 1;
        }
        else
        {
            SetAllImpl();
        }
    }

Set() [1/2]

void Set ( int  i )

inline

Remarks

Set the i-th bit to 1.

Parameters

i	- The array index of the bit to set.

    {
        assert(i > -1 && i < numBits);
        if ((i > -1) && (i < numBits))
        {
            if (UseLocalBits())
            {
                localBits |= BitMask(i);
            }
            else
            {
                bits[i >> NSHIFT] |= BitMask(i & BITS_PER_DWORD_PTR_MASK);
            }
        }
    }

Clear()

void Clear ( int  i )

inline

Remarks

Sets the i-th bit to 0.

Parameters:

int i

The array index of the bit to clear.

    {
        assert(i > -1 && i < numBits);
        if ((i > -1) && (i < numBits))
        {
            if (UseLocalBits())
            {
                localBits &= ~BitMask(i);
            }
            else
            {
                bits[i >> NSHIFT] &= ~BitMask(i & BITS_PER_DWORD_PTR_MASK);
            }
        }
    }

Set() [2/2]

void Set ( int  i, int  b  )

inline

Remarks

Set the i-th bit to b.

Parameters

i	- The index of the bit to set.
b	- The value to set, either 1 or 0.

    {
        b ? Set(i) : Clear(i);
    }

operator[]()

__forceinline int operator[] ( int  i ) const

inline

Remarks

Gets the i-th bit.

Parameters

i	- The index of the bit. If the index is a negative or bigger than the array size, it returns 0

    {
        assert(i > -1);
        assert(i < numBits);
        if ((i > -1) && (i < numBits))
            return UseLocalBits() ? (localBits & BitMask(i) ? 1 : 0) : GetBit(i);
        else
            return 0;
    }

IsEmpty()

bool IsEmpty ( ) const

inline

Remarks

Returns true if no bits are set; otherwise false. This method is much faster than checking if NumberSet() returns 0.

    {
        return UseLocalBits() ? !localBits : IsEmptyImpl();
    }

AnyBitSet()

bool AnyBitSet ( ) const

inline

    {
        return !IsEmpty();
    }

NumberSet()

NumberSetProxy NumberSet ( ) const

inline

Remarks

how many bits are 1's? use IsEmpty() for faster checks

Returns

Returns a proxy object which can optimize client code depending on the type of access required (ie: != 0 would call IsEmpty(), etc)

    {
        return NumberSetProxy(*this);
    }

Compress()

void Compress

(

)

Remarks

This is not currently implemented and is reserved for future use.

Expand()

void Expand

(

)

Remarks

This is not currently implemented and is reserved for future use.

Reverse()

void Reverse

(

bool

keepZero = false

)

Remarks

Reverses the bits in the BitArray.

Parameters:

BOOL keepZero = FALSE

If TRUE the zero bit is kept where it is.

Rotate()

void Rotate	(	int	direction,
		int	count
	)

Remarks

Rotates the bits in the BitArray (with wraparound).

Parameters:

int direction

The direction to rotate.

int count

The number of bits to rotate.

Shift()

void Shift	(	int	direction,
		int	count,
		int	where = 0
	)

Remarks

Shifts the bits in the BitArray (without wraparound).

Parameters:

int direction

One of the following values:

LEFT_BITSHIFT

RIGHT_BITSHIFT

int count

The number of bits to shift.

int where=0

This indicates where the shift will begin. For example, if you have a BitArray containing: 10101010

and you Shift(LEFT_BITSHIFT, 1, 4) you'll get: 10100100

All the bits from 4 to 8 are shifted one bit left, with zeroes shifted in from the right. The first bit affected is the where bit. If you leave off the where parameter you'd get the usual: 01010100

The RIGHT_BITSHIFT starts at that bit; it is unaffected because the operation proceeds to the right: 10101010.

Shift(RIGHT_BITSHIFT, 1, 4) results in: 10101101.

EnumSet()

void EnumSet

(

BitArrayCallback &

cb

)

Remarks

This method is used to enumerate all the elements that have a "1" value, and call the callback proc() with the index of the element.

Parameters:

BitArrayCallback &cb

The callback object whose proc() method is called.

DeleteSet()

void DeleteSet	(	BitArray &	dset,
		int	mult = 1
	)

Remarks

This method allows you to delete a selection of elements from this BitArray. This is useful, for instance, if you're deleting a set of vertices from a mesh and wish to keep the vertSel and vertHide arrays up to date.

Parameters:

BitArray & dset

This is a bit array which represents which elements should be deleted. Typically (if mult==1) dset will have the same size as (this).

int mult=1

This is a multiplier which indicates how many elements in (*this) are deleted for each entry in dset. For instance, when deleting faces in a mesh, you also need to delete the corresponding edge selection data. Since edgeSel[f*3], edgeSel[f*3+1], and edgeSel[f*3+2] correspond to face f, you'd use mult=3:

If the bit array has more values than correspond to the size of dset, the extra values will be retained at the end after deleting. The alternate method 'DeleteSetAndResize' will remove the extra values by resizing if needed.

faceSel.DeleteSet (fdel);

edgeSel.DeleteSet (fdel, 3);

DeleteSetAndResize()

void DeleteSetAndResize	(	const BitArray &	dset,
		int	mult = 1
	)

Save()

UTILGEOMEXPORT IOResult Save

(

ISave *

isave

)

Remarks

Save and Load are only forward declared in this header! If you need to use Save or Load, you must link with maxutil, which is where these methods are implemented. This way, geom.dll is independent from maxsdk.

Load()

UTILGEOMEXPORT IOResult Load

(

ILoad *

iload

)

Remarks

Save and Load are only forward declared in this header! If you need to use Save or Load, you must link with maxutil, which is where these methods are implemented. This way, geom.dll is independent from maxsdk.

operator==()

bool operator== ( const BitArray &  b ) const

inline

Remarks

This operator is available in release 3.0 and later only.

Comparison operator.

Parameters:

const BitArray& b

The BitArray to compare with this one.

Returns

true if the BitArrays are 'equal' (same size and same bits set); otherwise false.

    {
        return (numBits == b.numBits) && (UseLocalBits() ? (localBits == b.localBits) : CompareBitsImpl(b));
    }

operator=()

BitArray & operator=

(

const BitArray &

b

)

Remarks

Assignment operator.

operator&=()

BitArray & operator&=

(

const BitArray &

b

)

Remarks

AND= this BitArray with the specified BitArray.

operator|=()

BitArray & operator|=

(

const BitArray &

b

)

Remarks

OR= this BitArray with the specified BitArray.

operator^=()

BitArray & operator^=

(

const BitArray &

b

)

Remarks

XOR= this BitArray with the specified BitArray.

operator&()

BitArray operator&

(

const BitArray &

)

const

Remarks

AND two BitArrays

operator|()

BitArray operator|

(

const BitArray &

)

const

Remarks

OR two BitArrays

operator^()

BitArray operator^

(

const BitArray &

)

const

Remarks

XOR two BitArrays

operator~()

BitArray operator~ ( ) const

inline

Remarks

Unary NOT function

    {
        return UseLocalBits() ? BitArray(~localBits, numBits, true) : OperatorNotImpl();
    }

Swap()

void Swap

(

BitArray &

other

)

Swap the contents of two bitarrays.

This is an efficient way of transfering the contents of a temporary bitarray object into a more permanent instance, such as a data member. For instance:

{
BitArray    tmp(size);
// do something with tmp...
m_MyBitArray.Swap(tmp);
}

would be more efficient than using operator= in this case.

Parameters

[in,out]

other

The contents of 'other' will be swaped with the contents of 'this'

Friends And Related Function Documentation

NumberSetProxy

friend class NumberSetProxy

friend

Member Data Documentation

bits

uint64_t* bits

localBits

uint64_t localBits