UT/UT_BitArray.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * Produced by:
 *      Paul Breslin and Dale Ducharme  
 *      Side Effects Software Inc.
 *      20 Maud St.
 *      Toronto, Ontario,  M5V 2M5
 *      Canada
 *      416-366-4607
 *
 * NAME:        BitArray.h      
 *
 * COMMENTS:
 *
 */

#ifndef _UT_BitArray_
#define _UT_BitArray_

#include "UT_API.h"
#include <SYS/SYS_Types.h>
#include <iostream.h>

class UT_IStream;

//
//  This class implements a one dimensional array of bits.
//
class UT_API UT_BitArray {
public:
     UT_BitArray();
     UT_BitArray(const UT_BitArray &src);
     explicit UT_BitArray(int size);
    ~UT_BitArray();

    void        insert(int index, bool value);
    void        append(bool value) { insert(myBitCount, value); }
    void        remove(int index);

    void        resize(int size);
    int         getSize() const { return myBitCount; }

    int         numBitsSet() const;
    int         numBitsClear() const;

    int         allBitsSet() const;
    int         allBitsClear() const;

    bool           getBit(int index) const;
    bool           setBit(int index, bool value);// Returns previous bit value.
    bool        toggleBit(int index);             // Returns previous bit value.

    void           setBits(int index, int nbits, bool value);
    void        toggleBits(int index, int nbits);

    void           setAllBits(bool value);
    void        toggleAllBits();

    // I/O methods:
    int          save(ostream &os, int binary = 0) const;
    bool         load(UT_IStream &is);

    /// Iterate over set bits
    ///
    /// eg. for (bits.iterateInit(i); i >= 0; i = bits.iterateNext(i))
    ///         ... do something with bits(i)
    ///
    // @{
    void        iterateInit(int &currentBit) const;     // Initialize traversal
    int         iterateNext(int currentBit) const;      // Find next set bit
    // @}

    /// Find first or last bit in the array.  The functions will return -1 if
    /// no bits are set (i.e. equivalent to allBitsClear())
    int         findFirstBit() const;
    int         findLastBit() const;

    //          operators

    int          operator()(int index) const { return getBit(index); }
    int          operator[](int index) const { return getBit(index); }
    UT_BitArray &operator&=(const UT_BitArray &inMap);  // and | intersection
    UT_BitArray &operator|=(const UT_BitArray &inMap);  // or | union
    UT_BitArray &operator^=(const UT_BitArray &inMap);  // exclusive or 
    UT_BitArray &operator-=(const UT_BitArray &inMap);  // minus
    UT_BitArray &operator=(const UT_BitArray &inMap);   // equal 
    unsigned     operator==(const UT_BitArray &inMap) const;    // compare

    /// Returns whether there are any intersections between the two arrays
    bool                intersects(const UT_BitArray &inMap) const;

    int64               getMemoryUsage() const
                         { return (sizeof(*this) + myWordCount*sizeof(int)); }

    uint                computeHash() const;

private:
    unsigned int        *myBits;
    int                  myBitCount;
    int                  myWordCount;

#ifdef DEBUG
    void                 outTo(ostream &os) const;
    friend ostream      &operator<<(ostream &os, const UT_BitArray &map)
                        {
                            map.outTo(os);
                            return os;
                        }
#endif
};
#endif

---