DataCont/interface/BitMask.h

//--------------------------------------------------------------------------------------------------
// $Id: BitMask.h,v 1.1 2009/03/08 12:08:31 loizides Exp $
//
// BitMask
//
// Helper class implementing a Nx8 bit bitmask where N is a template parameter.
//
// Authors: J.Bendavid, C.Loizides
//--------------------------------------------------------------------------------------------------

#ifndef MITANA_DATACONT_BITMASK_H
#define MITANA_DATACONT_BITMASK_H
 
#include <Rtypes.h>
#include <TError.h>

typedef UInt_t unsignedint;
typedef UChar_t unsignedchar;
typedef UShort_t unsignedshort;
typedef ULong64_t unsignedlonglong;

namespace mithep
{
  template<UInt_t N>
  class BitMask
  {
    public:
      BitMask()                                             { Clear();                     }
      BitMask(const char *bits)                             { SetBits(bits);               }
      BitMask(const BitMask<N> &copy)                       { SetBits(copy.Bits());        }
      BitMask(Long64_t bits)                                { SetBits(bits);               }
      virtual ~BitMask() {}

      const char             *Bits()                  const { return fBitMask;             }
      void                    Clear(Option_t */*opt*/="")   { memset(fBitMask,0,N);        }
      void                    ClearBit(UInt_t n)            { SetBit(n,0);                 }
      UInt_t                  NBitsSet(UInt_t first=0, UInt_t last=N*8) const;
      void                    Print(Option_t *opt="") const;
      void                    SetBit(UInt_t n, Bool_t b=1);
      void                    SetBits(const BitMask<N> &b)  { memcpy(fBitMask,b.Bits(),N); }
      void                    SetBits(const Char_t *bits)   { memcpy(fBitMask,bits,N);     }
      void                    SetBits(Long64_t bits);
      UInt_t                  Size()                  const { return N*8;                  }
      Bool_t                  TestBit(UInt_t n)       const;

      BitMask                &operator&=(const BitMask<N> &rhs) 
        { for (UInt_t n=0; n<N; ++n) fBitMask[n] &= rhs.fBitMask[n]; return *this; }
      BitMask                &operator|=(const BitMask<N> &rhs)
        { for (UInt_t n=0; n<N; ++n) fBitMask[n] |= rhs.fBitMask[n]; return *this; }
      BitMask                &operator^=(const BitMask<N> &rhs)
        { for (UInt_t n=0; n<N; ++n) fBitMask[n] ^= rhs.fBitMask[n]; return *this; }        
      Bool_t                  operator!=(const BitMask<N> &other) const;
      Bool_t                  operator==(const BitMask<N> &other) const;    
      BitMask                 operator& (const BitMask<N> &other) const
        { return BitMask<N>(*this) &= other; }
      BitMask                 operator| (const BitMask<N> &other) const
        { return BitMask<N>(*this) |= other; }
      BitMask                 operator^ (const BitMask<N> &other) const
        { return BitMask<N>(*this) ^= other; }        
      BitMask                 operator~ ()                        const;
        
    protected:
      Char_t                  fBitMask[N]; //the actual bitmask
    
    ClassDef(BitMask, 1) // Generic templated bitmask
  };
}

namespace mithep
{
  template<class T>
  class BitMaskT
  {
    public:
      BitMaskT() : fBitMask(0)                              {}
      BitMaskT(const char *bits) : fBitMask(0)              { SetBits(bits);                 }
      BitMaskT(const BitMaskT<T> &copy) : fBitMask(0)       { SetBits(copy.Mask());          }
      BitMaskT(T bits) : fBitMask(0)                        { SetBits(bits);                 }
      virtual ~BitMaskT() {}

      const char             *Bits()                  const 
        { return reinterpret_cast<const char*>(&fBitMask); }
      void                    Clear(Option_t */*opt*/="")   { fBitMask = 0;                  }
      void                    ClearBit(UInt_t n)            { SetBit(n,0);                   }
      T                       Mask()                  const { return fBitMask;               }
      UInt_t                  NBitsSet(UInt_t first=0, UInt_t last=sizeof(T)*8) const;
      void                    Print(Option_t *opt="") const 
        { printf("%llX\n", ULong64_t(fBitMask));      }

      void                    SetBit(UInt_t n, Bool_t b=1)
        { if ((n>=sizeof(T)*8) || (TestBit(n)==b)) return; fBitMask = fBitMask ^ (1 << n);   }
      void                    SetBits(const BitMaskT<T> &b) { fBitMask = b.Mask();           }
      void                    SetBits(const Char_t *bits)   { fBitMask = T(*bits);           }
      void                    SetBits(T mask)               { fBitMask = mask;               }
      UInt_t                  Size()                  const { return sizeof(T)*8;            }
      Bool_t                  TestBit(UInt_t n)       const;

      BitMaskT               &operator&=(const BitMaskT<T> &rhs) 
        { fBitMask &= rhs.fBitMask; return *this; }
      BitMaskT               &operator|=(const BitMaskT<T> &rhs)
        { fBitMask |= rhs.fBitMask; return *this; }
      BitMaskT               &operator^=(const BitMaskT<T> &rhs)
        { fBitMask ^= rhs.fBitMask; return *this; }        
      Bool_t                  operator!=(const BitMaskT<T> &other) const
        { return fBitMask != other.fBitMask;      }
      Bool_t                  operator==(const BitMaskT<T> &other) const
        { return fBitMask == other.fBitMask;      }
      BitMaskT                operator& (const BitMaskT<T> &other) const
        { return BitMaskT<T>(*this) &= other;     }
      BitMaskT                operator| (const BitMaskT<T> &other) const
        { return BitMaskT<T>(*this) |= other;     }
      BitMaskT                operator^ (const BitMaskT<T> &other) const
        { return BitMaskT<T>(*this) ^= other;     }        
      BitMaskT                operator~ ()                         const
        { return BitMaskT<T>(~fBitMask);          }
   
    protected:
      T                       fBitMask; //the actual bitmask
    
    ClassDef(BitMaskT, 1) // Generic templated bitmask
  };
}

//--------------------------------------------------------------------------------------------------
template<UInt_t N>
inline UInt_t mithep::BitMask<N>::NBitsSet(UInt_t first, UInt_t last) const
{
  // Count number of bits which are set.

  UInt_t numBits = 0;
  for (UInt_t i=first; i<=last; i++)
    numBits += TestBit(i);
  return numBits;
}

//--------------------------------------------------------------------------------------------------
template<UInt_t N>
inline void mithep::BitMask<N>::Print(Option_t */*opt*/) const
{
  // Print bitmask.

  for (UInt_t i=0;i<N;++i) 
    printf("%X",fBitMask[i]);
  printf("\n");
}

//--------------------------------------------------------------------------------------------------
template<UInt_t N>
inline void mithep::BitMask<N>::SetBit(UInt_t n, Bool_t b)
{
  // Set nth bit to given value.

  if(n>=N*8) 
    return;

  UInt_t loc = n/8;
  UChar_t bit = n%8;
  if (b)
    fBitMask[loc] |= (1<<bit);
  else
    fBitMask[loc] &= (0xFF ^ (1<<bit));
}

//--------------------------------------------------------------------------------------------------
template<UInt_t N>
inline void mithep::BitMask<N>::SetBits(Long64_t bits)
{
  // Set bits given by bits.

  R__ASSERT(sizeof(Long64_t)>=N);
  SetBits(reinterpret_cast<const char*>(&bits));
}

//--------------------------------------------------------------------------------------------------
template<UInt_t N>
inline Bool_t mithep::BitMask<N>::TestBit(UInt_t n) const
{
  // Return true if nth bit is set.

  if(n>=N*8) 
    return 0;

  UInt_t loc = n/8;
  UChar_t bit = n%8;
  Char_t val = fBitMask[loc];
  Bool_t result = (val & (1<<bit)) != 0;
  return result;
}

//--------------------------------------------------------------------------------------------------
template<UInt_t N>
inline Bool_t mithep::BitMask<N>::operator==(const mithep::BitMask<N> &other) const
{
  // Equal operator.

  for (UInt_t n=0; n<N; ++n) {
    if (fBitMask[n]!=other.fBitMask[n]) 
      return kFALSE;
  }
  return kTRUE;
}    

//--------------------------------------------------------------------------------------------------
template<UInt_t N>
inline Bool_t mithep::BitMask<N>::operator!=(const mithep::BitMask<N> &other) const
{
  // Unequal operator.

  for (UInt_t n=0; n<N; ++n) {
    if (fBitMask[n]!=other.fBitMask[n]) 
      return kTRUE;
  }
  return kFALSE;
}

//--------------------------------------------------------------------------------------------------
template<UInt_t N>
inline mithep::BitMask<N> mithep::BitMask<N>::operator~() const
{
  // bitwise inversion operator
  BitMask<N> bits;
  for (UInt_t n=0; n<N; ++n) {
    bits.fBitMask[n] = ~fBitMask[n];
  }
  return bits;
}     


//--------------------------------------------------------------------------------------------------
template<class T>
inline UInt_t mithep::BitMaskT<T>::NBitsSet(UInt_t first, UInt_t last) const
{
  // Count number of bits which are set.

  UInt_t numBits = 0;
  for (UInt_t i=first; i<=last; i++)
    numBits += TestBit(i);
  return numBits;
}

//--------------------------------------------------------------------------------------------------
template<class T>
inline Bool_t mithep::BitMaskT<T>::TestBit(UInt_t n) const
{
  // Return true if nth bit is set.

  if(n>=sizeof(T)*8) 
    return 0;

  Bool_t result = (fBitMask & (1<<n)) != 0;
  return result;
}
#endif
Revision:	1.2
Committed:	Fri Mar 11 04:02:38 2011 UTC (14 years, 1 month ago) by bendavid
Content type:	text/plain
Branch:	MAIN
CVS Tags:	Mit_032, Mit_031, Mit_025c_branch2, Mit_025c_branch1, Mit_030, Mit_029c, Mit_029b, Mit_030_pre1, Mit_029a, Mit_029, Mit_029_pre1, Mit_028a, Mit_025c_branch0, Mit_028, Mit_027a, Mit_027, Mit_026, Mit_025e, Mit_025d, Mit_025c, Mit_025b, Mit_025a, Mit_025, Mit_025pre2, Mit_024b, Mit_025pre1, Mit_024a, Mit_024, Mit_023, Mit_022a, Mit_022, Mit_020d, TMit_020d, Mit_020c, Mit_021, Mit_021pre2, Mit_021pre1, Mit_020b, Mit_020a, Mit_020, Mit_020pre1, HEAD
Branch point for:	Mit_025c_branch
Changes since 1.1:	+6 -1 lines
Log Message:	unspeakable hacks to workaround unspeakable cint bugs
#	Content
1	//--------------------------------------------------------------------------------------------------
2	// $Id: BitMask.h,v 1.1 2009/03/08 12:08:31 loizides Exp $
3	//
4	// BitMask
5	//
6	// Helper class implementing a Nx8 bit bitmask where N is a template parameter.
7	//
8	// Authors: J.Bendavid, C.Loizides
9	//--------------------------------------------------------------------------------------------------
10
11	#ifndef MITANA_DATACONT_BITMASK_H
12	#define MITANA_DATACONT_BITMASK_H
13
14	#include <Rtypes.h>
15	#include <TError.h>
16
17	typedef UInt_t unsignedint;
18	typedef UChar_t unsignedchar;
19	typedef UShort_t unsignedshort;
20	typedef ULong64_t unsignedlonglong;
21
22	namespace mithep
23	{
24	template<UInt_t N>
25	class BitMask
26	{
27	public:
28	BitMask() { Clear(); }
29	BitMask(const char *bits) { SetBits(bits); }
30	BitMask(const BitMask<N> &copy) { SetBits(copy.Bits()); }
31	BitMask(Long64_t bits) { SetBits(bits); }
32	virtual ~BitMask() {}
33
34	const char *Bits() const { return fBitMask; }
35	void Clear(Option_t /opt*/="") { memset(fBitMask,0,N); }
36	void ClearBit(UInt_t n) { SetBit(n,0); }
37	UInt_t NBitsSet(UInt_t first=0, UInt_t last=N*8) const;
38	void Print(Option_t *opt="") const;
39	void SetBit(UInt_t n, Bool_t b=1);
40	void SetBits(const BitMask<N> &b) { memcpy(fBitMask,b.Bits(),N); }
41	void SetBits(const Char_t *bits) { memcpy(fBitMask,bits,N); }
42	void SetBits(Long64_t bits);
43	UInt_t Size() const { return N*8; }
44	Bool_t TestBit(UInt_t n) const;
45
46	BitMask &operator&=(const BitMask<N> &rhs)
47	{ for (UInt_t n=0; n<N; ++n) fBitMask[n] &= rhs.fBitMask[n]; return *this; }
48	BitMask &operator\|=(const BitMask<N> &rhs)
49	{ for (UInt_t n=0; n<N; ++n) fBitMask[n] \|= rhs.fBitMask[n]; return *this; }
50	BitMask &operator^=(const BitMask<N> &rhs)
51	{ for (UInt_t n=0; n<N; ++n) fBitMask[n] ^= rhs.fBitMask[n]; return *this; }
52	Bool_t operator!=(const BitMask<N> &other) const;
53	Bool_t operator==(const BitMask<N> &other) const;
54	BitMask operator& (const BitMask<N> &other) const
55	{ return BitMask<N>(*this) &= other; }
56	BitMask operator\| (const BitMask<N> &other) const
57	{ return BitMask<N>(*this) \|= other; }
58	BitMask operator^ (const BitMask<N> &other) const
59	{ return BitMask<N>(*this) ^= other; }
60	BitMask operator~ () const;
61
62	protected:
63	Char_t fBitMask[N]; //the actual bitmask
64
65	ClassDef(BitMask, 1) // Generic templated bitmask
66	};
67	}
68
69	namespace mithep
70	{
71	template<class T>
72	class BitMaskT
73	{
74	public:
75	BitMaskT() : fBitMask(0) {}
76	BitMaskT(const char *bits) : fBitMask(0) { SetBits(bits); }
77	BitMaskT(const BitMaskT<T> &copy) : fBitMask(0) { SetBits(copy.Mask()); }
78	BitMaskT(T bits) : fBitMask(0) { SetBits(bits); }
79	virtual ~BitMaskT() {}
80
81	const char *Bits() const
82	{ return reinterpret_cast<const char*>(&fBitMask); }
83	void Clear(Option_t /opt*/="") { fBitMask = 0; }
84	void ClearBit(UInt_t n) { SetBit(n,0); }
85	T Mask() const { return fBitMask; }
86	UInt_t NBitsSet(UInt_t first=0, UInt_t last=sizeof(T)*8) const;
87	void Print(Option_t *opt="") const
88	{ printf("%llX\n", ULong64_t(fBitMask)); }
89
90	void SetBit(UInt_t n, Bool_t b=1)
91	{ if ((n>=sizeof(T)*8) \|\| (TestBit(n)==b)) return; fBitMask = fBitMask ^ (1 << n); }
92	void SetBits(const BitMaskT<T> &b) { fBitMask = b.Mask(); }
93	void SetBits(const Char_t bits) { fBitMask = T(bits); }
94	void SetBits(T mask) { fBitMask = mask; }
95	UInt_t Size() const { return sizeof(T)*8; }
96	Bool_t TestBit(UInt_t n) const;
97
98	BitMaskT &operator&=(const BitMaskT<T> &rhs)
99	{ fBitMask &= rhs.fBitMask; return *this; }
100	BitMaskT &operator\|=(const BitMaskT<T> &rhs)
101	{ fBitMask \|= rhs.fBitMask; return *this; }
102	BitMaskT &operator^=(const BitMaskT<T> &rhs)
103	{ fBitMask ^= rhs.fBitMask; return *this; }
104	Bool_t operator!=(const BitMaskT<T> &other) const
105	{ return fBitMask != other.fBitMask; }
106	Bool_t operator==(const BitMaskT<T> &other) const
107	{ return fBitMask == other.fBitMask; }
108	BitMaskT operator& (const BitMaskT<T> &other) const
109	{ return BitMaskT<T>(*this) &= other; }
110	BitMaskT operator\| (const BitMaskT<T> &other) const
111	{ return BitMaskT<T>(*this) \|= other; }
112	BitMaskT operator^ (const BitMaskT<T> &other) const
113	{ return BitMaskT<T>(*this) ^= other; }
114	BitMaskT operator~ () const
115	{ return BitMaskT<T>(~fBitMask); }
116
117	protected:
118	T fBitMask; //the actual bitmask
119
120	ClassDef(BitMaskT, 1) // Generic templated bitmask
121	};
122	}
123
124	//--------------------------------------------------------------------------------------------------
125	template<UInt_t N>
126	inline UInt_t mithep::BitMask<N>::NBitsSet(UInt_t first, UInt_t last) const
127	{
128	// Count number of bits which are set.
129
130	UInt_t numBits = 0;
131	for (UInt_t i=first; i<=last; i++)
132	numBits += TestBit(i);
133	return numBits;
134	}
135
136	//--------------------------------------------------------------------------------------------------
137	template<UInt_t N>
138	inline void mithep::BitMask<N>::Print(Option_t /opt*/) const
139	{
140	// Print bitmask.
141
142	for (UInt_t i=0;i<N;++i)
143	printf("%X",fBitMask[i]);
144	printf("\n");
145	}
146
147	//--------------------------------------------------------------------------------------------------
148	template<UInt_t N>
149	inline void mithep::BitMask<N>::SetBit(UInt_t n, Bool_t b)
150	{
151	// Set nth bit to given value.
152
153	if(n>=N*8)
154	return;
155
156	UInt_t loc = n/8;
157	UChar_t bit = n%8;
158	if (b)
159	fBitMask[loc] \|= (1<<bit);
160	else
161	fBitMask[loc] &= (0xFF ^ (1<<bit));
162	}
163
164	//--------------------------------------------------------------------------------------------------
165	template<UInt_t N>
166	inline void mithep::BitMask<N>::SetBits(Long64_t bits)
167	{
168	// Set bits given by bits.
169
170	R__ASSERT(sizeof(Long64_t)>=N);
171	SetBits(reinterpret_cast<const char*>(&bits));
172	}
173
174	//--------------------------------------------------------------------------------------------------
175	template<UInt_t N>
176	inline Bool_t mithep::BitMask<N>::TestBit(UInt_t n) const
177	{
178	// Return true if nth bit is set.
179
180	if(n>=N*8)
181	return 0;
182
183	UInt_t loc = n/8;
184	UChar_t bit = n%8;
185	Char_t val = fBitMask[loc];
186	Bool_t result = (val & (1<<bit)) != 0;
187	return result;
188	}
189
190	//--------------------------------------------------------------------------------------------------
191	template<UInt_t N>
192	inline Bool_t mithep::BitMask<N>::operator==(const mithep::BitMask<N> &other) const
193	{
194	// Equal operator.
195
196	for (UInt_t n=0; n<N; ++n) {
197	if (fBitMask[n]!=other.fBitMask[n])
198	return kFALSE;
199	}
200	return kTRUE;
201	}
202
203	//--------------------------------------------------------------------------------------------------
204	template<UInt_t N>
205	inline Bool_t mithep::BitMask<N>::operator!=(const mithep::BitMask<N> &other) const
206	{
207	// Unequal operator.
208
209	for (UInt_t n=0; n<N; ++n) {
210	if (fBitMask[n]!=other.fBitMask[n])
211	return kTRUE;
212	}
213	return kFALSE;
214	}
215
216	//--------------------------------------------------------------------------------------------------
217	template<UInt_t N>
218	inline mithep::BitMask<N> mithep::BitMask<N>::operator~() const
219	{
220	// bitwise inversion operator
221	BitMask<N> bits;
222	for (UInt_t n=0; n<N; ++n) {
223	bits.fBitMask[n] = ~fBitMask[n];
224	}
225	return bits;
226	}
227
228
229	//--------------------------------------------------------------------------------------------------
230	template<class T>
231	inline UInt_t mithep::BitMaskT<T>::NBitsSet(UInt_t first, UInt_t last) const
232	{
233	// Count number of bits which are set.
234
235	UInt_t numBits = 0;
236	for (UInt_t i=first; i<=last; i++)
237	numBits += TestBit(i);
238	return numBits;
239	}
240
241	//--------------------------------------------------------------------------------------------------
242	template<class T>
243	inline Bool_t mithep::BitMaskT<T>::TestBit(UInt_t n) const
244	{
245	// Return true if nth bit is set.
246
247	if(n>=sizeof(T)*8)
248	return 0;
249
250	Bool_t result = (fBitMask & (1<<n)) != 0;
251	return result;
252	}
253	#endif