Logo ROOT   6.12/07
Reference Guide
TBits.h
Go to the documentation of this file.
1 // @(#)root/cont:$Id$
2 // Author: Philippe Canal 05/02/01
3 
4 /*************************************************************************
5  * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
6  * All rights reserved. *
7  * *
8  * For the licensing terms see $ROOTSYS/LICENSE. *
9  * For the list of contributors see $ROOTSYS/README/CREDITS. *
10  *************************************************************************/
11 
12 #ifndef ROOT_TBits
13 #define ROOT_TBits
14 
15 //////////////////////////////////////////////////////////////////////////
16 // //
17 // TBits //
18 // //
19 // Container of bits. //
20 // //
21 //////////////////////////////////////////////////////////////////////////
22 
23 #include "Rtypes.h"
24 #include "TObject.h"
25 #ifndef __CINT__
26 #include <string.h>
27 #endif
28 
29 class TBits : public TObject {
30 
31 protected:
32 
33  UInt_t fNbits; // Highest bit set + 1
34  UInt_t fNbytes; // Number of UChars in fAllBits
35  UChar_t *fAllBits; //[fNbytes] array of UChars
36 
37  void ReserveBytes(UInt_t nbytes);
38  void DoAndEqual(const TBits& rhs);
39  void DoOrEqual (const TBits& rhs);
40  void DoXorEqual(const TBits& rhs);
41  void DoLeftShift(UInt_t shift);
42  void DoRightShift(UInt_t shift);
43  void DoFlip();
44 
45 public:
46  TBits(UInt_t nbits = 8);
47  TBits(const TBits&);
48  TBits& operator=(const TBits&);
49  virtual ~TBits();
50 
51  class TReference {
52  friend class TBits;
53 
54  TBits &fBits; //!
55  UInt_t fPos; //!
56 
57  TReference(); // left undefined
58 
59 public:
60  TReference(TBits& bit, UInt_t pos) : fBits(bit),fPos(pos) { }
62 
63  // For b[i] = val;
65 
66  // For b[i] = b[__j];
67  TReference& operator=(const TReference& rhs);
68 
69 #ifndef __CINT__
70  // Flips the bit
71  Bool_t operator~() const;
72 #endif
73 
74  // For val = b[i];
75  operator Bool_t() const;
76  };
77 
78  //----- bit manipulation
79  //----- (note the difference with TObject's bit manipulations)
80  void ResetAllBits(Bool_t value=kFALSE); // if value=1 set all bits to 1
81  void ResetBitNumber(UInt_t bitnumber);
82  void SetBitNumber(UInt_t bitnumber, Bool_t value = kTRUE);
83  Bool_t TestBitNumber(UInt_t bitnumber) const;
84 
85  //----- Accessors and operator
86  TBits::TReference operator[](UInt_t bitnumber) { return TReference(*this,bitnumber); }
87  Bool_t operator[](UInt_t bitnumber) const;
88 
89  TBits& operator&=(const TBits& rhs) { DoAndEqual(rhs); return *this; }
90  TBits& operator|=(const TBits& rhs) { DoOrEqual(rhs); return *this; }
91  TBits& operator^=(const TBits& rhs) { DoXorEqual(rhs); return *this; }
92  TBits& operator<<=(UInt_t rhs) { DoLeftShift(rhs); return *this; }
93  TBits& operator>>=(UInt_t rhs) { DoRightShift(rhs); return *this; }
94  TBits operator<<(UInt_t rhs) { return TBits(*this)<<= rhs; }
95  TBits operator>>(UInt_t rhs) { return TBits(*this)>>= rhs; }
96  TBits operator~() { TBits res(*this); res.DoFlip(); return res; }
97 
98  //----- Optimized setters
99  // Each of these will replace the contents of the receiver with the bitvector
100  // in the parameter array. The number of bits is changed to nbits. If nbits
101  // is smaller than fNbits, the receiver will NOT be compacted.
102  void Set(UInt_t nbits, const Char_t *array);
103  void Set(UInt_t nbits, const UChar_t *array) { Set(nbits, (const Char_t*)array); }
104  void Set(UInt_t nbits, const Short_t *array);
105  void Set(UInt_t nbits, const UShort_t *array) { Set(nbits, (const Short_t*)array); }
106  void Set(UInt_t nbits, const Int_t *array);
107  void Set(UInt_t nbits, const UInt_t *array) { Set(nbits, (const Int_t*)array); }
108  void Set(UInt_t nbits, const Long64_t *array);
109  void Set(UInt_t nbits, const ULong64_t *array) { Set(nbits, (const Long64_t*)array); }
110 
111  //----- Optimized getters
112  // Each of these will replace the contents of the parameter array with the
113  // bits in the receiver. The parameter array must be large enough to hold
114  // all of the bits in the receiver.
115  // Note on semantics: any bits in the parameter array that go beyond the
116  // number of the bits in the receiver will have an unspecified value. For
117  // example, if you call Get(Int*) with an array of one integer and the TBits
118  // object has less than 32 bits, then the remaining bits in the integer will
119  // have an unspecified value.
120  void Get(Char_t *array) const;
121  void Get(UChar_t *array) const { Get((Char_t*)array); }
122  void Get(Short_t *array) const;
123  void Get(UShort_t *array) const { Get((Short_t*)array); }
124  void Get(Int_t *array) const;
125  void Get(UInt_t *array) const { Get((Int_t*)array); }
126  void Get(Long64_t *array) const;
127  void Get(ULong64_t *array) const { Get((Long64_t*)array); }
128 
129  //----- Utilities
130  void Clear(Option_t *option="");
131  void Compact(); // Reduce the space used.
132  UInt_t CountBits(UInt_t startBit=0) const ; // return number of bits set to 1
133  UInt_t FirstNullBit(UInt_t startBit=0) const;
134  UInt_t FirstSetBit(UInt_t startBit=0) const;
135  UInt_t LastNullBit(UInt_t startBit=999999999) const;
136  UInt_t LastSetBit(UInt_t startBit=999999999) const;
137  UInt_t GetNbits() const { return fNbits; }
138  UInt_t GetNbytes() const { return fNbytes; }
139 
140  Bool_t operator==(const TBits &other) const;
141  Bool_t operator!=(const TBits &other) const { return !(*this==other); }
142 
143  void Paint(Option_t *option=""); // to visualize the bits array as an histogram, etc
144  void Print(Option_t *option="") const; // to show the list of active bits
145  void Output(std::ostream &) const;
146 
147  ClassDef(TBits,1) // Bit container
148 };
149 
150 
151 inline Bool_t operator&(const TBits::TReference& lhs, const TBits::TReference& rhs)
152 {
153  return (Bool_t)lhs & rhs;
154 }
155 
156 inline Bool_t operator|(const TBits::TReference& lhs, const TBits::TReference& rhs)
157 {
158  return (Bool_t)lhs | rhs;
159 }
160 
161 inline Bool_t operator^(const TBits::TReference& lhs, const TBits::TReference& rhs)
162 {
163  return (Bool_t)lhs ^ rhs;
164 }
165 
166 inline TBits operator&(const TBits& lhs, const TBits& rhs)
167 {
168  TBits result(lhs);
169  result &= rhs;
170  return result;
171 }
172 
173 inline TBits operator|(const TBits& lhs, const TBits& rhs)
174 {
175  TBits result(lhs);
176  result |= rhs;
177  return result;
178 }
179 
180 inline TBits operator^(const TBits& lhs, const TBits& rhs)
181 {
182  TBits result(lhs);
183  result ^= rhs;
184  return result;
185 }
186 
187 inline std::ostream &operator<<(std::ostream& os, const TBits& rhs)
188 {
189  rhs.Output(os); return os;
190 }
191 
192 // inline functions...
193 
194 inline void TBits::SetBitNumber(UInt_t bitnumber, Bool_t value)
195 {
196  // Set bit number 'bitnumber' to be value
197 
198  if (bitnumber >= fNbits) {
199  UInt_t new_size = (bitnumber/8) + 1;
200  if (new_size > fNbytes) {
201  new_size *= 2;
202  UChar_t *old_location = fAllBits;
203  fAllBits = new UChar_t[new_size];
204  memcpy(fAllBits,old_location,fNbytes);
205  memset(fAllBits+fNbytes ,0, new_size-fNbytes);
206  fNbytes = new_size;
207  delete [] old_location;
208  }
209  fNbits = bitnumber+1;
210  }
211  UInt_t loc = bitnumber/8;
212  UChar_t bit = bitnumber%8;
213  if (value)
214  fAllBits[loc] |= (1<<bit);
215  else
216  fAllBits[loc] &= (0xFF ^ (1<<bit));
217 }
218 
219 inline Bool_t TBits::TestBitNumber(UInt_t bitnumber) const
220 {
221  // Return the current value of the bit
222 
223  if (bitnumber >= fNbits) return kFALSE;
224  UInt_t loc = bitnumber/8;
225  UChar_t value = fAllBits[loc];
226  UChar_t bit = bitnumber%8;
227  Bool_t result = (value & (1<<bit)) != 0;
228  return result;
229  // short: return 0 != (fAllBits[bitnumber/8] & (1<< (bitnumber%8)));
230 }
231 
232 inline void TBits::ResetBitNumber(UInt_t bitnumber)
233 {
234  SetBitNumber(bitnumber,kFALSE);
235 }
236 
237 inline Bool_t TBits::operator[](UInt_t bitnumber) const
238 {
239  return TestBitNumber(bitnumber);
240 }
241 
243 {
244  // For b[i] = val.
245 
246  fBits.SetBitNumber(fPos,val); return *this;
247 }
248 
250 {
251  // For b[i] = b[__j].
252 
253  fBits.SetBitNumber(fPos,rhs.fBits.TestBitNumber(rhs.fPos)); return *this;
254 }
255 
256 #ifndef __CINT__
258 {
259  // Flips the bit.
260 
261  return !fBits.TestBitNumber(fPos);
262 }
263 #endif
264 
265 inline TBits::TReference::operator Bool_t() const
266 {
267  // For val = b[i].
268 
269  return fBits.TestBitNumber(fPos);
270 }
271 
272 #endif
273 
274 
Bool_t operator &(const TBits::TReference &lhs, const TBits::TReference &rhs)
Definition: TBits.h:151
void Output(std::ostream &) const
Print the value to the std::ostream.
Definition: TBits.cxx:432
void Set(UInt_t nbits, const UInt_t *array)
Definition: TBits.h:107
TBits::TReference operator[](UInt_t bitnumber)
Definition: TBits.h:86
UInt_t GetNbits() const
Definition: TBits.h:137
void Print(Option_t *option="") const
Print the list of active bits.
Definition: TBits.cxx:454
void Clear(Option_t *option="")
Clear the value.
Definition: TBits.cxx:84
long long Long64_t
Definition: RtypesCore.h:69
void Set(UInt_t nbits, const Char_t *array)
Set all the bytes.
Definition: TBits.cxx:492
void DoAndEqual(const TBits &rhs)
Execute (*this) &= rhs; Extra bits in rhs are ignored Missing bits in rhs are assumed to be zero...
Definition: TBits.cxx:165
TBits & operator<<=(UInt_t rhs)
Definition: TBits.h:92
const char Option_t
Definition: RtypesCore.h:62
void Get(ULong64_t *array) const
Definition: TBits.h:127
unsigned short UShort_t
Definition: RtypesCore.h:36
Bool_t operator!=(const TBits &other) const
Definition: TBits.h:141
void Get(UShort_t *array) const
Definition: TBits.h:123
TReference(TBits &bit, UInt_t pos)
Definition: TBits.h:60
int Int_t
Definition: RtypesCore.h:41
bool Bool_t
Definition: RtypesCore.h:59
Bool_t operator~() const
Definition: TBits.h:257
void DoRightShift(UInt_t shift)
Execute the left shift operation.
Definition: TBits.cxx:239
void ResetAllBits(Bool_t value=kFALSE)
Reset all bits to 0 (false).
Definition: TBits.cxx:470
TBits operator~()
Definition: TBits.h:96
#define ClassDef(name, id)
Definition: Rtypes.h:320
TBits & operator=(const TBits &)
TBits assignment operator.
Definition: TBits.cxx:56
UChar_t * fAllBits
Definition: TBits.h:35
Bool_t operator==(const TBits &other) const
Definition: TBits.cxx:688
virtual ~TBits()
TBits destructor.
Definition: TBits.cxx:76
friend class TBits
Definition: TBits.h:52
void DoOrEqual(const TBits &rhs)
Execute (*this) &= rhs; Extra bits in rhs are ignored Missing bits in rhs are assumed to be zero...
Definition: TBits.cxx:181
TBits & operator>>=(UInt_t rhs)
Definition: TBits.h:93
Bool_t TestBitNumber(UInt_t bitnumber) const
Definition: TBits.h:219
void Get(Char_t *array) const
Copy all the byes.
Definition: TBits.cxx:505
UInt_t fPos
Definition: TBits.h:55
UInt_t fNbytes
Definition: TBits.h:34
UInt_t LastSetBit(UInt_t startBit=999999999) const
Return position of first non null bit (starting from position 0 and up)
Definition: TBits.cxx:393
UInt_t LastNullBit(UInt_t startBit=999999999) const
Return position of first null bit (starting from position 0 and up)
Definition: TBits.cxx:309
UInt_t FirstSetBit(UInt_t startBit=0) const
Return position of first non null bit (starting from position 0 and up)
Definition: TBits.cxx:348
TBits & fBits
Definition: TBits.h:54
void Get(UInt_t *array) const
Definition: TBits.h:125
void Set(UInt_t nbits, const ULong64_t *array)
Definition: TBits.h:109
void Compact()
Reduce the storage used by the object to a minimun.
Definition: TBits.cxx:95
unsigned int UInt_t
Definition: RtypesCore.h:42
void Get(UChar_t *array) const
Definition: TBits.h:121
short Short_t
Definition: RtypesCore.h:35
TBits & operator|=(const TBits &rhs)
Definition: TBits.h:90
TBits operator>>(UInt_t rhs)
Definition: TBits.h:95
void DoLeftShift(UInt_t shift)
Execute the left shift operation.
Definition: TBits.cxx:216
const Bool_t kFALSE
Definition: RtypesCore.h:88
void DoXorEqual(const TBits &rhs)
Execute (*this) ^= rhs; Extra bits in rhs are ignored Missing bits in rhs are assumed to be zero...
Definition: TBits.cxx:194
void Set(UInt_t nbits, const UShort_t *array)
Definition: TBits.h:105
TBits & operator &=(const TBits &rhs)
Definition: TBits.h:89
unsigned long long ULong64_t
Definition: RtypesCore.h:70
TBits(UInt_t nbits=8)
TBits constructor. All bits set to 0.
Definition: TBits.cxx:33
UInt_t GetNbytes() const
Definition: TBits.h:138
Mother of all ROOT objects.
Definition: TObject.h:37
Container of bits.
Definition: TBits.h:29
char Char_t
Definition: RtypesCore.h:29
void Paint(Option_t *option="")
Once implemented, it will draw the bit field as an histogram.
Definition: TBits.cxx:447
Bool_t operator^(const TBits::TReference &lhs, const TBits::TReference &rhs)
Definition: TBits.h:161
void DoFlip()
Execute ~(*this)
Definition: TBits.cxx:205
void ResetBitNumber(UInt_t bitnumber)
Definition: TBits.h:232
TBits operator<<(UInt_t rhs)
Definition: TBits.h:94
void Set(UInt_t nbits, const UChar_t *array)
Definition: TBits.h:103
unsigned char UChar_t
Definition: RtypesCore.h:34
UInt_t CountBits(UInt_t startBit=0) const
Return number of bits set to 1 starting at bit startBit.
Definition: TBits.cxx:118
Bool_t operator|(const TBits::TReference &lhs, const TBits::TReference &rhs)
Definition: TBits.h:156
UInt_t fNbits
Definition: TBits.h:33
void ReserveBytes(UInt_t nbytes)
Reverse each bytes.
Definition: TBits.cxx:478
const Bool_t kTRUE
Definition: RtypesCore.h:87
void SetBitNumber(UInt_t bitnumber, Bool_t value=kTRUE)
Definition: TBits.h:194
UInt_t FirstNullBit(UInt_t startBit=0) const
Return position of first null bit (starting from position 0 and up)
Definition: TBits.cxx:264
TReference & operator=(Bool_t val)
Definition: TBits.h:242
TBits & operator^=(const TBits &rhs)
Definition: TBits.h:91