mi32/bitsetd.h

Go to the documentation of this file.

/**
 * \file bitsetd.h <mi32/bitsetd.h>
 * \brief Definitions for BITSET_DEQUE classes.
 *
 * This class is designed so that an access violation beyond 
 * the array size results in a bit setting of 'false'.
 *
 * \if NODOC
 * $Id: bitsetd.h_v 1.10 2005/03/01 17:15:38 scowan Exp $
 *
 * $Log: bitsetd.h_v $
 * Revision 1.10  2005/03/01 17:15:38  scowan
 * Mimic methods added to bitset.
 *
 * Revision 1.9  2003/11/07 20:38:54  scowan
 * Export iterator too.
 *
 * Revision 1.8  2003/11/07 17:53:02  dwilliss
 * Moving to misystem.  Export the class and remove inlines
 *
 * Revision 1.7  2003/09/15 17:36:03  dwilliss
 * Fixed mismatched ifdef from doxygen cleanup
 *
 * Revision 1.6  2003/09/15 13:49:56  fileserver!dwilliss
 * Doxygen
 *
 * 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
 *
 * \endif
 **/

#ifndef INC_MI32_BITSETD_H
#define INC_MI32_BITSETD_H

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

#ifdef MISYSTEMDLL
   #define CLASSLIBEXPORT MI_DLLCLASSEXPORT
#else
   #define CLASSLIBEXPORT MI_DLLCLASSIMPORT
#endif

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

            //! Dereference operator, returns item number set.
            UINT32 operator* (
               ) const;

            //! Cast operator to UINT32.
            operator UINT32 (
               ) const;

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

            //! Equality operator.
            bool operator== (
               const ITERATOR& rhs
               ) const;

            //! Inequality operator.
            bool operator!= (
               const ITERATOR& rhs
               ) const;

         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT
            const BITSET_DEQUE* m_BitSet;
            UINT32 m_SetItemIndex;
            UINT8 m_TestBit;
            UINT8 m_SkipByte;

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

            friend class BITSET_DEQUE;
            #endif // GENERATING_DOXYGEN_OUTPUT
         };
   
      BITSET_DEQUE (
         );
   
      BITSET_DEQUE (
         const BITSET_DEQUE& rhs
         );
   
      ~BITSET_DEQUE (
         );
   
      BITSET_DEQUE& operator= (
         const BITSET_DEQUE& 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;

      //! Clear value at specified position.
      void Clear (
         UINT32 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 (
         UINT32 min,
         UINT32 max
         );
         
      //! Count the values in the set.
      //! Iterates through the set, so should not be used in time-critical code.
      INT32 CountValues (
         bool value = true
         ) const;
         
      //! Transfer value from source to dest entry.
      //! Replaces putbit(set, DestPosn, getbit(set, SourcePosn)).
      void CopyBit (
         UINT32 DestPosn,                 //!< where setting goes to
         UINT32 SourcePosn                //!< where setting comes from
         );
   
      //! Initialize iterator with last+1 item in the bit set.
      //! Returns iterator to last+1 item
      ITERATOR End (
         ) const;

      //! Erase BITSET_DEQUE 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 (
         UINT32 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.
      UINT32 GetNumEntries (           
         ) const;

      //! 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 (
         UINT32 StartPosn,       //!< Staring position
         UINT32 MaxEnd,          //!< Maximum ending position
         UINT32& EndPosn         //!< Ending position (inclusive) RETURNED
         ) const;
   
      //! Does bit set have any entries?
      bool HasEntries (
         ) const;

      //! Determine if has multiple entries with specified value.
      bool HasMultiple (
         bool value
         ) const;

      //! Determine if has at least one entry with specified value;
      bool HasValue (
         bool value
         ) const;

      //! Invert value at specified position.
      void Invert (
         UINT32 posn                      //!< Position to be inverted
         );
         
      //! Invert all entries in bit set.
      void InvertAll (
         );
         
      //! Set range of entries to inverse
      void InvertRange (
         UINT32 min,
         UINT32 max
         );
         
      //! Resize BITSET to a new number of entries.
      ERRVALUE Resize (
         UINT32 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 (              
         UINT32 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 (              
         UINT32 posn,                     //!< Position where value is set
         bool value                       //!< Value to be set at position
         );
         
      //! Set range of entries to "true".
      void SetRange (
         UINT32 min,
         UINT32 max
         );
         
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      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; 
      UINT32 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 // GENERATING_DOXYGEN_OUTPUT
   };

#undef CLASSLIBEXPORT

#endif      // INC_MI32_BITSETD_H

---