mi32/unsignedset.h

Go to the documentation of this file.

#ifndef INC_MI32_UNSIGNEDSET_H
#define INC_MI32_UNSIGNEDSET_H

#ifndef  INC_MI32_SIMPLEAR_H
#include <mi32/simplear.h>
#endif

#ifndef  INC_MI32_BITSET_H
#include <mi32/bitset.h>
#endif

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


//=====================================================================================================================
class CLASSLIBEXPORT UNSIGNEDSET {
   public:

      class CLASSLIBEXPORT ITERATOR32 {
         public:

            explicit ITERATOR32 (
               const UNSIGNEDSET& Set
               ) :
               m_Set(Set)
               { Reset(); }

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

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

            ITERATOR32& operator++ ();

            bool IsEnd () const
               { return (m_Num == UINT32_MAX); }

            void Reset ();

            void SetEnd ()
               { m_Num = UINT32_MAX; }

            UINT32 SkipCount ();

         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT
            const UNSIGNEDSET& m_Set;
            const UINT8 *m_pData;
            const UINT8 *m_pEnd;
            UINT32 m_Num;
            UINT32 m_CountLeft;
            #endif // GENERATING_DOXYGEN_OUTPUT
         };
      
      class CLASSLIBEXPORT ITERATOR64 {
         public:

            explicit ITERATOR64 (
               const UNSIGNEDSET& Set
               ) :
               m_Set(Set)
               { Reset(); }

            UINT64 operator* (
               ) const { return (m_Num); }

            operator UINT64 (
               ) const { return (m_Num); }

            ITERATOR64& operator++ ();

            bool IsEnd () const
               { return (m_Num == UINT64_MAX); }

            void Reset ();

            void SetEnd ()
               { m_Num = UINT64_MAX; }

            UINT32 SkipCount ();

         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT
            const UNSIGNEDSET& m_Set;
            const UINT8 *m_pData;
            const UINT8 *m_pEnd;
            UINT64 m_Num;
            UINT32 m_CountLeft;
            #endif // GENERATING_DOXYGEN_OUTPUT
         };
      
      class CLASSLIBEXPORT ITERATOR_RANGE32 {
         public:

            explicit ITERATOR_RANGE32 (
               const UNSIGNEDSET& Set
               ) :
               m_itNext(Set)
               { Reset(); }

            ITERATOR_RANGE32& operator++ ();

            UINT32 GetFirst () const
               { return (m_NumFirst); }

            UINT32 GetLast () const
               { return (m_NumLast); }

            bool IsEnd () const
               { return (m_NumFirst == UINT32_MAX); }

            void Reset ();

            void SetEnd ()
               { m_NumFirst = m_NumLast = UINT32_MAX; }

         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT
            ITERATOR32 m_itNext;
            UINT32 m_NumFirst;
            UINT32 m_NumLast;
            #endif // GENERATING_DOXYGEN_OUTPUT
         };
      
      class CLASSLIBEXPORT ITERATOR_RANGE64 {
         public:

            explicit ITERATOR_RANGE64 (
               const UNSIGNEDSET& Set
               ) :
               m_itNext(Set)
               { Reset(); }

            ITERATOR_RANGE64& operator++ ();

            UINT64 GetFirst () const
               { return (m_NumFirst); }

            UINT64 GetLast () const
               { return (m_NumLast); }

            bool IsEnd () const
               { return (m_NumFirst == UINT64_MAX); }

            void Reset ();

            void SetEnd ()
               { m_NumFirst = m_NumLast = UINT64_MAX; }

         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT
            ITERATOR64 m_itNext;
            UINT64 m_NumFirst;
            UINT64 m_NumLast;
            #endif // GENERATING_DOXYGEN_OUTPUT
         };

      class CLASSLIBEXPORT ITERATOR_INTERSECTION32 {
         public:

            explicit ITERATOR_INTERSECTION32 (
               const UNSIGNEDSET& set1,
               const UNSIGNEDSET& set2
               ) :
               m_it1(set1),
               m_it2(set2)
               { Reset(); }

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

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

            ITERATOR_INTERSECTION32& operator++ ();

            bool IsEnd () const
               { return (m_Num == UINT32_MAX); }

            void Reset ();

            void SetEnd ()
               { m_Num = UINT32_MAX; }

         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT
            ITERATOR_RANGE32 m_it1;
            ITERATOR_RANGE32 m_it2;
            UINT32 m_Num;
            #endif
         };
      
      class CLASSLIBEXPORT ITERATOR_INTERSECTION64 {
         public:

            explicit ITERATOR_INTERSECTION64 (
               const UNSIGNEDSET& set1,
               const UNSIGNEDSET& set2
               ) :
               m_it1(set1),
               m_it2(set2)
               { Reset(); }

            UINT64 operator* (
               ) const { return (m_Num); }

            operator UINT64 (
               ) const { return (m_Num); }

            ITERATOR_INTERSECTION64& operator++ ();

            bool IsEnd () const
               { return (m_Num == UINT64_MAX); }

            void Reset ();

            void SetEnd ()
               { m_Num = UINT64_MAX; }

         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT
            ITERATOR_RANGE64 m_it1;
            ITERATOR_RANGE64 m_it2;
            UINT64 m_Num;
            #endif
         };
      
      UNSIGNEDSET ();

      ~UNSIGNEDSET ();

      ERRVALUE AddRange (
         UINT32 min,                      
         UINT32 max                       
         );

      ERRVALUE AddRange (
         INT32 min,                       
         INT32 max                        
         ) { return (AddRange(static_cast<UINT32>(min),static_cast<UINT32>(max))); }

      ERRVALUE AddRange (
         UINT64 min,                      
         UINT64 max                       
         );

      ERRVALUE AddRange (
         INT64 min,                       
         INT64 max                        
         ) { return (AddRange(static_cast<UINT64>(min),static_cast<UINT64>(max))); }

      ERRVALUE AddSingle (
         UINT16 num                       
         ) { return (AddSingle(static_cast<UINT32>(num))); }

      ERRVALUE AddSingle (
         UINT32 num                       
         ) { return (AddRange(num,num)); }

      ERRVALUE AddSingle (
         INT32 num                        
         ) { return (AddRange(num,num)); }

      ERRVALUE AddSingle (
         UINT64 num                       
         ) { return (AddRange(num,num)); }

      ERRVALUE AddSingle (
         INT64 num                        
         ) { return (AddRange(num,num)); }

      ERRVALUE Assign (
         const UNSIGNEDSET& set           
         );

      ERRVALUE Assign (
         const BITSET_UNOWNED& bitset     
         );

      ERRVALUE AttachCompressed (
         UINT8 *& pData,                  
         UINT32 BufSize                   
         );

      ERRVALUE AttachCompressed (
         SIMPLE_ARRAY<UINT8>& Data        
         );

      void Clear ();

      ERRVALUE Compress ();

      bool Contains (
         UINT16 ItemNum
         ) const { return (Contains(static_cast<UINT32>(ItemNum))); }

      bool Contains (
         UINT32 ItemNum
         ) const;

      bool Contains (
         INT32 ItemNum
         ) const { return (Contains(static_cast<UINT32>(ItemNum))); }

      bool Contains (
         UINT64 ItemNum
         ) const;

      bool Contains (
         INT64 ItemNum
         ) const { return (Contains(static_cast<UINT64>(ItemNum))); }

      UINT64 CountItems () const;

      ERRVALUE Decompress ();

      ERRVALUE DecompressForContains ();

      void UNSIGNEDSET::Exchange (
         UNSIGNEDSET& other                  
         );

      ERRVALUE GetBitSet (
         BITSET& bitset,            
         UINT32 NumEntries          
         ) const;

      const SIMPLE_ARRAY<UINT8>& GetCompressed ();

      UINT64 GetFirstItem () const
         { return (m_FirstItem); }

      UINT64 GetLastItem () const
         { return (m_LastItem); }

      ERRVALUE Intersect (
         const UNSIGNEDSET& rhs
         );

      bool IsCompressed () const
         { return (!m_SpanAllInSet.HasEntries()); }

      bool IsEmpty () const
         { return (m_Data.IsEmpty() && !m_SpanAllInSet.HasEntries()); }

      ERRVALUE LoadCompressed (
         const UINT8 *pData,              
         UINT32 BufSize                   
         );

      ERRVALUE LoadCompressed (
         const SIMPLE_ARRAY<UINT8>& Data  
         ) { return (LoadCompressed(static_cast<const UINT8*>(Data),Data.GetNumItems())); }

      ERRVALUE RemoveRange (
         UINT32 min,                      
         UINT32 max                       
         );

      ERRVALUE RemoveRange (
         INT32 min,                       
         INT32 max                        
         ) { return (RemoveRange(static_cast<UINT32>(min),static_cast<UINT32>(max))); }

      ERRVALUE RemoveRange (
         UINT64 min,                      
         UINT64 max                       
         );

      ERRVALUE RemoveRange (
         INT64 min,                       
         INT64 max                        
         ) { return (RemoveRange(static_cast<UINT64>(min),static_cast<UINT64>(max))); }

      ERRVALUE RemoveSet (
         const UNSIGNEDSET& set           
         );

      ERRVALUE RemoveSingle (
         UINT32 num                       
         ) { return (RemoveRange(num,num)); }

      ERRVALUE RemoveSingle (
         INT32 num                        
         ) { return (RemoveRange(num,num)); }

      ERRVALUE RemoveSingle (
         UINT64 num                       
         ) { return (RemoveRange(num,num)); }

      ERRVALUE RemoveSingle (
         INT64 num                        
         ) { return (RemoveRange(num,num)); }

      ERRVALUE SetContains (
         UINT32 num,                      
         bool inset                       
         );

      ERRVALUE SetContains (
         UINT64 num,                      
         bool inset                       
         );

      ERRVALUE ToggleRange (
         UINT32 min,                      
         UINT32 max                       
         );

      ERRVALUE ToggleRange (
         UINT64 min,                      
         UINT64 max                       
         );

      int ToggleSingle (
         UINT64 num                       
         );

      ERRVALUE Union (
         const UNSIGNEDSET& rhs
         );

      ERRVALUE UnionExclusive (
         const UNSIGNEDSET& rhs
         );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      SIMPLE_ARRAY<UINT8> m_Data;
      UINT64 m_FirstItem;
      UINT64 m_LastItem;
      UINT64 m_LastCount;
      UINT32 m_LastCountIndex;
      UINT32 m_EndIndex;
      BITSET m_SpanAllInSet;
      SIMPLE_ARRAY<UINT32*> m_SpanData;
      SIMPLE_ARRAY<UINT32*> m_SpanPool;

      ERRVALUE AppendCount (UINT32 value);
      ERRVALUE AppendCount (UINT64 value);
      ERRVALUE AppendSkip (UINT32 value);
      ERRVALUE AppendSkip (UINT64 value);
      void FindNewFirstItemUncompressed ();
      void FindNewLastItemUncompressed ();
      void FreeSpans ();
      ERRVALUE GetSpan (UINT32 Span, bool initialize = true);
      ERRVALUE LoadFinish ();
      void ReleaseSpanToPool (UINT32 Span);
      ERRVALUE RangeAddCompressed (UINT32 First, UINT32 Last);
      ERRVALUE RangeAddCompressed (UINT64 First, UINT64 Last);
      ERRVALUE RangeAddUncompressed (UINT32 First, UINT32 Last);
      ERRVALUE RangeAddUncompressed (UINT64 First, UINT64 Last);
      ERRVALUE RangeRemoveUncompressed (UINT32 First, UINT32 Last);
      ERRVALUE RangeRemoveUncompressed (UINT64 First, UINT64 Last);
      ERRVALUE RangeToggleUncompressed (UINT32 First, UINT32 Last);
      ERRVALUE RangeToggleUncompressed (UINT64 First, UINT64 Last);
      ERRVALUE SpanClearRange (UINT32 Span, UINT32 MinPos, UINT32 MaxPos);
      ERRVALUE SpanSetRange (UINT32 Span, UINT32 MinPos, UINT32 MaxPos);
      ERRVALUE SpanToggleRange (UINT32 Span, UINT32 MinPos, UINT32 MaxPos);

      // Unimplemented.
      UNSIGNEDSET (const UNSIGNEDSET&);
      UNSIGNEDSET& operator= (const UNSIGNEDSET&);
      #endif // GENERATING_DOXYGEN_OUTPUT

   };

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

#undef   CLASSLIBEXPORT

#endif      // INC_MI32_UNSIGNEDSET_H

---