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