mi32/bitset.h

Go to the documentation of this file.

#ifndef INC_MI32_BITSET_H
#define INC_MI32_BITSET_H

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

#ifndef  INC_MEMORY_H
#include <memory.h>     // Includes defn for memset()
#define  INC_MEMORY_H
#endif


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


#ifndef GENERATING_DOXYGEN_OUTPUT
class BITSET_SHARED;
#endif // GENERATING_DOXYGEN_OUTPUT


enum SET_OPERATION {
   SET_OPERATION_Null =          0,
   SET_OPERATION_Clear =         1,
   SET_OPERATION_Set =           2,
   SET_OPERATION_Negate =        3,
   SET_OPERATION_Copy =          4,
   SET_OPERATION_Union =         5,
   SET_OPERATION_Add =           SET_OPERATION_Union,
   SET_OPERATION_Subtract =      6,
   SET_OPERATION_ExUnion =       7,
   SET_OPERATION_Intersection =  8,
   };


//=====================================================================================================================
class CLASSLIBEXPORT BITSET_UNOWNED {

   protected:                          
      UINT8 *m_Array;                     
      UINT32 m_NumEntries;                
      UINT32 m_ArraySize;                 
      
   public:

      class ITERATOR;
      friend class ITERATOR;

      class CLASSLIBEXPORT ITERATOR {
         public:

            ITERATOR ();

            UINT32 operator* (
               ) const {
               return (m_SetItemIndex);
               }

            operator UINT32 (
               ) const {
               return (m_SetItemIndex);
               }

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

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

         protected:
            #ifndef GENERATING_DOXYGEN_OUTPUT
            const BITSET_UNOWNED* GetBitSet () const { return m_BitSet; }
            #endif

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

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

            // Construct for "end".
            ITERATOR (
               const BITSET_UNOWNED* BitSet
               ) : 
               m_BitSet(BitSet),
               m_SetItemIndex(BitSet->GetNumEntries()),
               m_TestBit(0),
               m_SkipByte(0)
               {
               }

            friend class BITSET_UNOWNED;
         #endif // GENERATING_DOXYGEN_OUTPUT
         };
      

      BITSET_UNOWNED (                    
         );

      BITSET_UNOWNED (
         UINT8 *set,                      
         UINT32 NumEntries                
         );

      virtual ~BITSET_UNOWNED (
         );

      operator UINT8* (
         ) {
         return (m_Array);
         }

      operator const UINT8* (
         ) const {
         return (m_Array);
         }

      BITSET_UNOWNED& operator&= (
         const BITSET_UNOWNED& rhs
         );

      BITSET_UNOWNED& operator|= (
         const BITSET_UNOWNED& rhs
         );

      BITSET_UNOWNED& operator^= (
         const BITSET_UNOWNED& rhs
         );

      virtual ERRVALUE Assign (
         UINT8 *set,                      
         UINT32 NumEntries                
         );
         
      ITERATOR Begin (
         bool value = true                
         ) const {
         return (ITERATOR(this, value));
         }

      void Clear (
         UINT32 posn
         ) {
         if (posn < m_NumEntries) {
            m_Array[posn/8] &= ~(1 << (posn & 7));
            }
         return;
         }

      void ClearAll (
         ) {
         if (m_ArraySize > 0) memset(m_Array, 0, m_ArraySize);
         return;
         }

      void ClearRange (
         UINT32 min,
         UINT32 max
         );

      void CopyBit (
         UINT32 DestPosn,                 
         UINT32 SourcePosn                
         );

      INT32 CountValues (
         bool value = true
         ) const;
         
      ITERATOR End (
         ) const {
         return (ITERATOR(this));
         }

      bool GetBit (
         UINT32 posn                      
         ) const {
         if (posn >= m_NumEntries) return (false);
         return ((m_Array[posn/8] & (1 << (posn & 7))) != 0);
         }

      UINT32 GetNumEntries (           
         ) const {
         return (m_NumEntries);
         }

      bool GetRange (
         UINT32 StartPosn,       
         UINT32 MaxEnd,          
         UINT32& EndPosn         
         ) const;

      bool HasEntries (
         ) const {
         return (m_NumEntries > 0);
         }

      bool HasMultiple (
         bool value
         ) const;

      bool HasValue (
         bool value
         ) const { return (Begin(value) != End()); }

      void Invert (
         UINT32 posn                      
         ) {
         if (posn >= m_NumEntries) return;
         m_Array[posn/8] ^= 1 << (posn & 7);
         return;
         }
         
      void InvertAll (
         );
         
      void InvertRange (
         UINT32 min,
         UINT32 max
         );
         
      bool IsEqual (
         const BITSET_UNOWNED& rhs
         ) const;

      void Set (              
         UINT32 posn                      
         ) {
         if (posn < m_NumEntries) {
            m_Array[posn/8] |= 1 << (posn & 7);
            }
         return;
         }

      void SetAll (              
         );

      void SetBit (              
         UINT32 posn,                     
         bool value                       
         ) {
         if (posn >= m_NumEntries) return;
         if (value) {
            m_Array[posn/8] |= 1 << (posn & 7);
            }
         else {
            m_Array[posn/8] &= ~(1 << (posn & 7));
            }
         return;
         }

      void SetRange (
         UINT32 min,
         UINT32 max
         );
         
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      // Disallowed operations.
      const UINT8& operator[](int) const;
      UINT8& operator[](int);
      #endif // GENERATING_DOXYGEN_OUTPUT

   };

//=====================================================================================================================
class CLASSLIBEXPORT BITSET : public BITSET_UNOWNED {

   public:

      BITSET (
         );

      BITSET (
         const BITSET& rhs
         );

      BITSET (
         const BITSET_UNOWNED& rhs
         );

      BITSET (
         UINT8 *set,                      
         UINT32 NumEntries                
         );

      virtual ~BITSET (
         );

      BITSET& operator= (
         const BITSET& rhs
         );

      BITSET& operator= (
         const BITSET_UNOWNED& rhs
         );

      virtual ERRVALUE Assign (
         UINT8 *set,                      
         UINT32 NumEntries                
         );
         
      void Attach (
         UINT8*& items,                
         int numitems               
         );
         
      UINT8* Detach (
         );

      void Exchange (
         BITSET& other                    
         );

      void Free (
         );

      ERRVALUE Resize (
         UINT32 NumEntries                
         );
         
      private:
         #ifndef GENERATING_DOXYGEN_OUTPUT
         friend class BITSET_SHARED;
         #endif // GENERATING_DOXYGEN_OUTPUT
   };


//=====================================================================================================================
class CLASSLIBEXPORT BITSET_SHARED : public BITSET_UNOWNED {

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      struct BITSET_COUNT {
         mutable UINT32 m_RefCount;
         BITSET m_Bitset;
         BITSET_COUNT () : m_RefCount(1) {}
         BITSET_COUNT (const BITSET_UNOWNED& rhs) : m_RefCount(1), m_Bitset(rhs) {}
         BITSET_COUNT (UINT8 *set, UINT32 NumEntries) : m_RefCount(1), m_Bitset(set, NumEntries) {}
         ERRVALUE Resize (UINT32 NumEntries) {return (m_Bitset.Resize(NumEntries));}
         };

      BITSET_COUNT* m_SharedBitset;
      #endif // GENERATING_DOXYGEN_OUTPUT
      
   public:

      BITSET_SHARED (
         );

      BITSET_SHARED (
         const BITSET_SHARED& rhs
         );

      BITSET_SHARED (
         const BITSET_UNOWNED& rhs
         );

      BITSET_SHARED (
         UINT8 *set,                      
         UINT32 NumEntries                
         );

      virtual ~BITSET_SHARED (
         );

      BITSET_SHARED& operator= (
         const BITSET_SHARED& rhs
         );

      BITSET_SHARED& operator= (
         const BITSET_UNOWNED& rhs
         );

      virtual ERRVALUE Assign (
         UINT8 *set,                      
         UINT32 NumEntries                
         );
         
      void Attach (
         UINT8*& items,                
         int numitems               
         );
         
      // Detach() method cannot work here!!

      void Free (
         );

      ERRVALUE Resize (
         UINT32 NumEntries                
         );
         
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      void AttachPointers ();
      void DecrementCount ();
      #endif // GENERATING_DOXYGEN_OUTPUT
         
   };

//=====================================================================================================================

#undef   CLASSLIBEXPORT

#endif      // INC_MI32_BITSET_H

---