BitArray Class Reference
 
 
 
BitArray Class Reference

#include <bitarray.h>

Inheritance diagram for BitArray:
MaxHeapOperators

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.

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.

Friends

class  NumberSetProxy

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]
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


Member Data Documentation