BitArray Class Reference

#include <bitarray.h>

Class 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.

Inheritance diagram for BitArray:

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)
IOResult	Save (ISave *isave)
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. More...

Friends
class	NumberSetProxy

Additional Inherited Members
Static Public Member Functions inherited from MaxHeapOperators
static UtilExport void *	operator new (size_t size)
	Standard new operator used to allocate objects If there is insufficient memory, an exception will be thrown. More...
static UtilExport void *	operator new (size_t size, const std::nothrow_t &e)
	Standard new operator used to allocate objects if there is insufficient memory, NULL will be returned. More...
static UtilExport void *	operator new (size_t size, const char *filename, int line)
	New operator used to allocate objects that takes the filename and line number where the new was called If there is insufficient memory, an exception will be thrown. More...
static UtilExport void *	operator new (size_t size, int block_type, const char *filename, int line)
	New operator used to allocate objects that takes the type of memory, filename and line number where the new was called If there is insufficient memory, an exception will be thrown. More...
static UtilExport void *	operator new (size_t size, const std::nothrow_t &e, const char *filename, int line)
	New operator used to allocate objects that takes the filename and line number where the new was called If there is insufficient memory, NULL will be returned. More...
static UtilExport void *	operator new (size_t size, unsigned long flags)
	New operator used to allocate objects that takes extra flags to specify special operations If there is insufficient memory, an exception will be thrown. More...
static UtilExport void *	operator new (size_t size, const std::nothrow_t &e, unsigned long flags)
	New operator used to allocate objects that takes extra flags to specify special operations If there is insufficient memory, NULL will be returned. More...
static UtilExport void *	operator new[] (size_t size)
	New operator used to allocate arrays of objects If there is insufficient memory, an exception will be thrown. More...
static UtilExport void *	operator new[] (size_t size, const std::nothrow_t &e)
	New operator used to allocate arrays of objects If there is insufficient memory, NULL will be returned. More...
static UtilExport void *	operator new[] (size_t size, const char *filename, int line)
	New operator used to allocate arrays of objects If there is insufficient memory, an exception will be thrown. More...
static UtilExport void *	operator new[] (size_t size, int block_type, const char *filename, int line)
	New operator used to allocate arrays of objects. More...
static UtilExport void *	operator new[] (size_t size, const std::nothrow_t &e, const char *filename, int line)
	New operator used to allocate arrays of objects If there is insufficient memory, NULL will be returned. More...
static UtilExport void *	operator new[] (size_t size, unsigned long flags)
	New operator used to allocate arrays of objects If there is insufficient memory, an exception will be thrown. More...
static UtilExport void *	operator new[] (size_t size, const std::nothrow_t &e, unsigned long flags)
	New operator used to allocate arrays of objects If there is insufficient memory, NULL will be returned. More...
static UtilExport void	operator delete (void *ptr)
	Standard delete operator used to deallocate an object If the pointer is invalid, an exception will be thrown. More...
static UtilExport void	operator delete (void *ptr, const std::nothrow_t &e)
	Standard delete operator used to deallocate an object If the pointer is invalid, nothing will happen. More...
static UtilExport void	operator delete (void *ptr, const char *filename, int line)
	Delete operator used to deallocate an object that takes the filename and line number where the delete was called If the pointer is invalid, an exception will be thrown. More...
static UtilExport void	operator delete (void *ptr, int block_type, const char *filename, int line)
	Delete operator used to deallocate an object that takes the type of memory, filename and line number where the delete was called If the pointer is invalid, an exception will be thrown. More...
static UtilExport void	operator delete (void *ptr, const std::nothrow_t &e, const char *filename, int line)
	Delete operator used to deallocate an object that takes the filename and line number where the delete was called If the pointer is invalid, nothing will happen. More...
static UtilExport void	operator delete (void *ptr, unsigned long flags)
	Delete operator used to deallocate an object that takes extra flags to specify special operations If the pointer is invalid, an exception will be thrown. More...
static UtilExport void	operator delete (void *ptr, const std::nothrow_t &e, unsigned long flags)
	Delete operator used to deallocate an object that takes extra flags to specify special operations If the pointer is invalid, nothing will happen. More...
static UtilExport void	operator delete[] (void *ptr)
	Standard delete operator used to deallocate an array of objects If the pointer is invalid, an exception will be thrown. More...
static UtilExport void	operator delete[] (void *ptr, const std::nothrow_t &e)
	Standard delete operator used to deallocate an array of objects If the pointer is invalid, nothing will happen. More...
static UtilExport void	operator delete[] (void *ptr, const char *filename, int line)
	Delete operator used to deallocate an array of objects that takes the filename and line number where the delete was called If the pointer is invalid, an exception will be thrown. More...
static UtilExport void	operator delete[] (void *ptr, int block_type, const char *filename, int line)
	Delete operator used to deallocate an array of objects that takes the type of memory, filename and line number where the delete was called If the pointer is invalid, an exception will be thrown. More...
static UtilExport void	operator delete[] (void *ptr, const std::nothrow_t &e, const char *filename, int line)
	Delete operator used to deallocate an array of objects that takes the filename and line number where the delete was called If the pointer is invalid, nothing will happen. More...
static UtilExport void	operator delete[] (void *ptr, unsigned long flags)
	Delete operator used to deallocate an array of objects that takes extra flags to specify special operations If the pointer is invalid, an exception will be thrown. More...
static UtilExport void	operator delete[] (void *ptr, const std::nothrow_t &e, unsigned long flags)
	Delete operator used to deallocate an array of objects that takes extra flags to specify special operations If the pointer is invalid, an exception will be thrown. More...
static UtilExport void *	operator new (size_t size, void *placement_ptr)
	Placement new operator. More...
static UtilExport void	operator delete (void *ptr, void *placement_ptr)
	Placement delete operator. More...
static UtilExport void *	aligned_malloc (size_t size, size_t alignment)
	Allocates memory on a specified alignment boundary. More...
static UtilExport void *	aligned_realloc (void *ptr, size_t size, size_t alignment)
	Reallocates memory on a specified alignment boundary. More...
static UtilExport void	aligned_free (void *ptr)
	Frees a block of memory that was allocated with aligned_malloc/aligned_realloc. More...

Constructor & Destructor Documentation

BitArray ( )

inline

Remarks

Default constructor. Sets the number of bits to 0.

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

BitArray ( int  n )

inline

Remarks

Constructor.

Parameters:

int i

The size of the BitArray in bits.

    {
        DbgAssert( n >= 0 );
        if (n < 0)
        {
            n = 0;
        }
        if( UseLocalBits(n) )
        {
            numBits     = n;
            localBits   = 0;

            BitArrayAllocated();
        }
        else
        {
            CreateBitArrayImpl(n);
        }
    }

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 ( )

inline

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

Member Function Documentation

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.

int GetSize ( ) const

inline

Remarks

Returns the size of the bit array in bits.

{ return numBits; }

void ClearAll ( )

inline

Remarks

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

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

void SetAll ( )

inline

Remarks

Sets all the bits in the array to 1.

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

void Set ( int  i )

inline

Remarks

Set the i-th bit to 1.

Parameters

i	- The array index of the bit to set.

    {
        DbgAssert(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);
            }
        }
    }

void Clear ( int  i )

inline

Remarks

Sets the i-th bit to 0.

Parameters:

int i

The array index of the bit to clear.

    {
        DbgAssert(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);
            }
        }
    }

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); }

__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

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

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(); }

bool AnyBitSet ( ) const

inline

{ return !IsEmpty(); }

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);
    }

void Compress

(

)

Remarks

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

void Expand

(

)

Remarks

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

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.

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.

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.

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.

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:

faceSel.DeleteSet (fdel);

edgeSel.DeleteSet (fdel, 3);

IOResult Save

(

ISave *

isave

)

Remarks

Saves the BitArray to the 3ds Max file.

IOResult Load

(

ILoad *

iload

)

Remarks

Loads the BitArray from the 3ds Max file.

Operators:

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));
    }

BitArray& operator=

(

const BitArray &

b

)

Remarks

Assignment operator.

BitArray& operator&=

(

const BitArray &

b

)

Remarks

AND= this BitArray with the specified BitArray.

BitArray& operator|=

(

const BitArray &

b

)

Remarks

OR= this BitArray with the specified BitArray.

BitArray& operator^=

(

const BitArray &

b

)

Remarks

XOR= this BitArray with the specified BitArray.

BitArray operator&

(

const BitArray &

)

const

Remarks

AND two BitArrays

BitArray operator|

(

const BitArray &

)

const

Remarks

OR two BitArrays

BitArray operator^

(

const BitArray &

)

const

Remarks

XOR two BitArrays

BitArray operator~ ( ) const

inline

Remarks

Unary NOT function

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

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

friend class NumberSetProxy

friend

Member Data Documentation

DWORD_PTR* bits

DWORD_PTR localBits