mi32/bitsetd64.h

Go to the documentation of this file.

/**
 * BitsetDeque.h - Definitions for BITSET DEQUE64 classes.
 *
 * This class is designed so that an access violation beyond 
 * the array size results in a bit setting of 'false'.
 *
 * $Id: bitsetd64.h_v 1.1 2003/09/24 02:45:20 mju Exp $
 *
 * $Log: bitsetd64.h_v $
 * Revision 1.1  2003/09/24 02:45:20  mju
 * Initial revision
 *
 * Revision 1.5  2003/02/20 16:49:05  dwilliss
 * never mind...
 *
 * Revision 1.4  2002/11/15 23:11:50  dwilliss
 * *** empty log message ***
 *
 * Revision 1.3  2002/11/01 23:36:22  scowan
 * Added begin and end methods.
 *
 * Revision 1.2  2002/11/01 16:26:35  scowan
 * Added get legacy method.
 *
 * Revision 1.1  2002/10/31 23:28:40  scowan
 * Initial revision
 *
 **/

#ifndef INC_BITSETD64_H
#define INC_BITSETD64_H

#ifndef  INC_STDDEFNS_H
#include <mi32/stddefns.h>
#endif

class BITSET_DEQUE64 {
   public:
   
      // Iterator to step forward through all selected items in a BITSET_DEQUE64.
      class ITERATOR {
         public:

            // Dereference operator, returns item number set.
            INT64 operator* (
               ) const { return (m_SetItemIndex); }

            // Cast operator to INT64.
            operator INT64 (
               ) const { return (m_SetItemIndex); }

            // Pre-increment operator.
            ITERATOR& operator++ (
               );

            // Equality operator.
            bool operator== (
               const ITERATOR& rhs
               ) const { return (m_BitSet == rhs.m_BitSet && (m_SetItemIndex == rhs.m_SetItemIndex || (m_SetItemIndex >= m_BitSet->m_NumEntries && rhs.m_SetItemIndex >= m_BitSet->m_NumEntries))); }

            // Inequality operator.
            bool operator!= (
               const ITERATOR& rhs
               ) const { return (!(*this == rhs)); }

         private:
            const BITSET_DEQUE64* m_BitSet;
            UINT32 m_SetItemIndex;
            UINT8 m_TestBit;
            UINT8 m_SkipByte;

            // Construct for "begin".
            ITERATOR (const BITSET_DEQUE64* BitSet, bool testvalue);
            // Construct for "end".
            ITERATOR (const BITSET_DEQUE64* BitSet);

            friend class BITSET_DEQUE64;
         };
   
      BITSET_DEQUE64 (
         );
   
      BITSET_DEQUE64 (
         const BITSET_DEQUE64& rhs
         );
   
      ~BITSET_DEQUE64 (
         );
   
      BITSET_DEQUE64& operator= (
         const BITSET_DEQUE64& rhs
         );
         
      // Initialize iterator with first set or unset item in the bit set.
      // Returns iterator to first set entry, otherwise the last+1 item if no matching item.
      ITERATOR Begin (
         bool value = true                // Value to iterate through
         ) const { return (ITERATOR(this, value)); }

      // Clear value at specified position.
      void Clear (
         INT64 posn
         );

      // Clear bit array with false.
      // Makes all the entries in the bit set 'false'.
      void ClearAll (
         );

      // Set range of entries to "false".
      void ClearRange (
         INT64 min,
         INT64 max
         );
         
      // Transfer value from source to dest entry.
      // Replaces putbit(set, DestPosn, getbit(set, SourcePosn)).
      void CopyBit (
         INT64 DestPosn,                  // where setting goes to
         INT64 SourcePosn                 // where setting comes from
         );
   
      // Initialize iterator with last+1 item in the bit set.
      // Returns iterator to last+1 item
      ITERATOR End (
         ) const { return (ITERATOR(this)); }

      // Erase BITSET_DEQUE64 internals, same as calling destructor.
      void Free (
         );
   
      // Retrieve value at the requested position, true or false.
      // Returns 'false' if the position given is outside the range of the BITSET
      bool GetBit (
         INT64 posn                       // position where value is retrieved from
         ) const;
/*
      // Retrieve legacy bit array from 'this'
      // Returns number of items in the array
      INT32 GetBitArray (
         UINT8*& array                    // Must be freed by the caller
         ) const;
*/       
      // Return the number of valid entries.
      INT64 GetNumEntries (            
         ) const { return (m_NumEntries); }

      // Get a range of entries that are set continuously in the bitset
      // @return 'True' if a true range, 'false' if a false range
      bool GetRange (
         INT64 StartPosn,        // Staring position
         INT64 MaxEnd,           // Maximum ending position
         INT64& EndPosn       // Ending position (inclusive) RETURNED
         ) const;
   
      // Does bit set have any entries?
      bool HasEntries (
         ) const { return (m_NumEntries > 0); }

      // Invert value at specified position.
      void Invert (
         INT64 posn                       // Position to be inverted
         );
         
      // Invert all entries in bit set.
      void InvertAll (
         );
         
      // Set range of entries to inverse
      void InvertRange (
         INT64 min,
         INT64 max
         );
         
      // Resize BITSET to a new number of entries.
      ERRVALUE Resize (
         INT64 NumEntries                 // Number of elements to resize to
         );
         
      // Set a value at the requested position to "true".
      // Does nothing if the position given is outside range.
      void Set (              
         INT64 posn                       // Position to set
         );
         
      // Set all entries to true, opposite of ClearAll().
      // Turn all bit positions to true.
      void SetAll (              
         );
         
      // Set a value at the requested position, true or false.
      // Does nothing if the position given is outside range.
      void SetBit (              
         INT64 posn,                   // Position where value is set
         bool value                       // Value to be set at position
         );
         
      // Set range of entries to "true".
      void SetRange (
         INT64 min,
         INT64 max
         );
         
   private:
      struct TILE {
         UINT8* m_Array;
         bool m_IsValid;                  // Is the tile valid?  The tile can be allocated and be invalid
         bool m_IsSet;
         };

      TILE* m_Tiles; 
      INT64 m_NumEntries;                 // Actual number of bits used
      UINT32 m_NumTiles;                  // Number of tiles allocated
      UINT32 m_NumFreeTiles;              // Number of free tiles
      static const UINT32 s_TileSize;
      
      ERRVALUE GetTile (UINT32 ti);

      friend class ITERATOR;
   };


#endif      // INC_BITSETD_H

---