Subversion Repositories thor

#ifndef SET_H

#define SET_H

#ifndef STRING_H

#include <string.h>

#endif

/*      Header file for set routines.

*/

#define SET_DEFAULT_SIZE     (128 / (sizeof(int) << 3))

#define SET_DIV_WSIZE(bit)   (bit) / (sizeof(int) << 3)

#define SET_ROUND(bit)       (((SET_DIV_WSIZE(bit) + 8) >> 3) << 3)

#define SET_GBIT(s,bit,op) \

    (((s).map)[SET_DIV_WSIZE(bit)] (op) (1 << (bit) & 15))

#define SET_BPW              (sizeof(int) << 3)

#define SET_BMASK            (SET_BPW - 1)

#define SET_NBIT             ((SET_BPW & 32) ? 5 : 4)

#define SET_EQUIV   0

#define SET_DISJ    1

#define SET_INTER   2

#define SET_UNKNOWN     3

extern void *allocx(int);

class CSet //: public CObject

{

   unsigned int dmap[SET_DEFAULT_SIZE];  // Default bitmap - 128 bits

   unsigned int *map;                           // Pointer to bit map of elements

   unsigned __int16 MemberPtr;    // for NextMember

   unsigned __int16 nbits;        // Number of bits in map.

   unsigned __int8 size;          // number of int's of bitmap.

   unsigned __int8 compl;         // Negative true set if compl is true

   void enlarge(int);            // increase size of set

   int cmp(CSet&) const;

   int SetTest(CSet &);

   void allocBitStorage();

public:

        void Create() {

                map = dmap;

                size = SET_DEFAULT_SIZE;

                nbits = SET_DEFAULT_SIZE * sizeof(int) << 3;

                MemberPtr = 0;

                compl = 0;

                clear();

        };

        static CSet *MakeNew() {

                CSet *p;

                p = (CSet *)allocx(sizeof(CSet));

                p->Create();

                return (p);

        };

        CSet() {

                Create();

        };

        CSet(const CSet &s) { copy(s); };

        ~CSet() {

                //if (map != dmap)

                //      delete[] map;

        };

   // Assignment other operators

   //---------------------------

        void copy(const CSet &s);

    CSet& operator=(CSet&);                             // Assignment (copy)

        CSet operator!();                               // s = not s1

        CSet operator|(CSet);                           // s = s1 union s2

        CSet& operator|=(CSet);                         // s1 = s1 union s2

        CSet operator&(CSet);                           // s = s1 intersection s2

        CSet& operator&=(CSet);                         // s1 = s1 intersection s2

        int operator&(int bit)

        { return isMember(bit); };  // is n a member of s ?

        CSet operator+(int);        // s = s1 plus element

        CSet operator-(int);        // s = s1 minus element

        CSet operator-(CSet);     // s = (symmetric) difference bewteen s1, s2

        // Relational operators

    //---------------------

        int operator==(CSet &s) const { return cmp(s) ? 0 : 1; };

        int operator!=(CSet &s) const { return cmp(s) ? 1 : 0; };

        int operator>(CSet &s) const { return (cmp(s) > 0) ? 1 : 0; };

        int operator<(CSet &s) const { return (cmp(s) < 0) ? 1 : 0; };

        int operator>=(CSet &s) const { return (cmp(s) >= 0) ? 1 : 0; };

        int operator<=(CSet &s) const { return (cmp(s) <= 0) ? 1 : 0; };

   // Functions

   //----------

        // Add a new element to the set.

        inline void add(int bit)

        {

                if (bit > nbits)

                        enlarge(bit >> SET_NBIT);

                map[bit >> SET_NBIT] |= (1 << (bit & SET_BMASK));

        };

        void add(CSet &s);

        void add(CSet *s);

//      inline void add(int);       // add member to set

        void remove(int);    // Remove member - clears bit in map

        inline void remove(CSet &s)

        {

                int ii;

                ii = min(size, s.size);

                while (--ii >= 0)

                        map[ii] &= ~s.map[ii];

        }

        inline void remove(CSet *s)

        {

                int ii;

                ii = min(size, s->size);

                while (--ii >= 0)

                        map[ii] &= ~s->map[ii];

        }

        int resetPtr() {

      int i = MemberPtr;

      MemberPtr = 0;

      return i; };

        int SetPtr(int n) {

      int i = MemberPtr;

      MemberPtr = (unsigned __int16)n;

      return i; };

          int Member(int n);

        int nextMember();

        int prevMember();

        int lastMember();

        int length() const { return sizeof(int) * size << 3; };

        int NumMember() const;  // Number of 'ON' elements in set

        int print(int (*)(void *,...), void*);

        int sprint(char *, int);

        unsigned hash() const;

        int subset(CSet &) const;

        void truncate();

        void clear();                                   // Zero all bits

        void fill();                                    // Set all bits

        void complement();

        int isDisjoint(CSet &s) { return (SetTest(s) == SET_DISJ); };

        int isIntersecting(CSet &s) { return (SetTest(s) == SET_INTER); };

        int isEmpty() { return NumMember() == 0; };

        int isMember(int bit) { return ((bit >= nbits)||bit < 0 ? 0 : (map[bit >> SET_NBIT] & (1 << (bit & SET_BMASK)))) != 0; }; // is n a member of s ?

        int test(int x) { return (isMember(x)) ? !compl : compl; };

        int isSubset(CSet &);

//      void Serialize(CArchive& ar);

};

#endif