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
26class TBits : public TObject {
27
28protected:
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
43public:
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
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
149{
150 return (Bool_t)lhs & rhs;
151}
152
154{
155 return (Bool_t)lhs | rhs;
156}
157
159{
160 return (Bool_t)lhs ^ rhs;
161}
162
163inline TBits operator&(const TBits& lhs, const TBits& rhs)
164{
165 TBits result(lhs);
166 result &= rhs;
167 return result;
168}
169
170inline TBits operator|(const TBits& lhs, const TBits& rhs)
171{
172 TBits result(lhs);
173 result |= rhs;
174 return result;
175}
176
177inline TBits operator^(const TBits& lhs, const TBits& rhs)
178{
179 TBits result(lhs);
180 result ^= rhs;
181 return result;
182}
183
184inline std::ostream &operator<<(std::ostream& os, const TBits& rhs)
185{
186 rhs.Output(os); return os;
187}
188
189// inline functions...
190
191inline 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
206inline 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
222inline 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
235inline void TBits::ResetBitNumber(UInt_t bitnumber)
236{
237 SetBitNumber(bitnumber,kFALSE);
238}
239
240inline 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
266inline TBits::TReference::operator Bool_t() const
267{
268 // For val = b[i].
269
270 return fBits.TestBitNumber(fPos);
271}
272
273#endif
274
275
unsigned short UShort_t
Definition: RtypesCore.h:40
int Int_t
Definition: RtypesCore.h:45
unsigned char UChar_t
Definition: RtypesCore.h:38
char Char_t
Definition: RtypesCore.h:33
unsigned int UInt_t
Definition: RtypesCore.h:46
const Bool_t kFALSE
Definition: RtypesCore.h:101
bool Bool_t
Definition: RtypesCore.h:63
short Short_t
Definition: RtypesCore.h:39
long long Long64_t
Definition: RtypesCore.h:80
unsigned long long ULong64_t
Definition: RtypesCore.h:81
const Bool_t kTRUE
Definition: RtypesCore.h:100
const char Option_t
Definition: RtypesCore.h:66
#define ClassDef(name, id)
Definition: Rtypes.h:325
std::ostream & operator<<(std::ostream &os, const TBits &rhs)
Definition: TBits.h:184
Bool_t operator&(const TBits::TReference &lhs, const TBits::TReference &rhs)
Definition: TBits.h:148
Bool_t operator|(const TBits::TReference &lhs, const TBits::TReference &rhs)
Definition: TBits.h:153
Bool_t operator^(const TBits::TReference &lhs, const TBits::TReference &rhs)
Definition: TBits.h:158
TReference(const TReference &rhs)
Definition: TBits.h:59
TBits & fBits
Definition: TBits.h:52
UInt_t fPos
Definition: TBits.h:53
Bool_t operator~() const
Definition: TBits.h:259
TReference & operator=(Bool_t val)
Definition: TBits.h:245
TReference(TBits &bit, UInt_t pos)
Definition: TBits.h:58
Container of bits.
Definition: TBits.h:26
UInt_t fNbytes
Definition: TBits.h:31
TBits operator>>(UInt_t rhs)
Definition: TBits.h:92
void DoRightShift(UInt_t shift)
Execute the left shift operation.
Definition: TBits.cxx:242
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:91
Bool_t operator==(const TBits &other) const
Definition: TBits.cxx:699
void Resize(UInt_t newlen)
Definition: TBits.h:191
void ResetBitNumber(UInt_t bitnumber)
Definition: TBits.h:235
TBits & operator>>=(UInt_t rhs)
Definition: TBits.h:90
void Clear(Option_t *option="")
Clear the value.
Definition: TBits.cxx:84
void Set(UInt_t nbits, const UChar_t *array)
Definition: TBits.h:100
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 Print(Option_t *option="") const
Print the list of active bits.
Definition: TBits.cxx:465
UInt_t LastNullBit(UInt_t startBit=999999999) const
Return position of first null bit (starting from position 0 and up)
Definition: TBits.cxx:320
UInt_t fNbits
Definition: TBits.h:30
TBits operator~() const
Definition: TBits.h:93
void ResetAllBits(Bool_t value=kFALSE)
Reset all bits to 0 (false).
Definition: TBits.cxx:481
void Set(UInt_t nbits, const ULong64_t *array)
Definition: TBits.h:106
void Get(UInt_t *array) const
Definition: TBits.h:122
TBits & operator^=(const TBits &rhs)
Definition: TBits.h:88
void ReserveBytes(UInt_t nbytes)
Reverse each bytes.
Definition: TBits.cxx:489
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
void Set(UInt_t nbits, const UInt_t *array)
Definition: TBits.h:104
TBits & operator|=(const TBits &rhs)
Definition: TBits.h:87
UInt_t GetNbits() const
Definition: TBits.h:134
void Paint(Option_t *option="")
Once implemented, it will draw the bit field as an histogram.
Definition: TBits.cxx:458
void Output(std::ostream &) const
Print the value to the std::ostream.
Definition: TBits.cxx:443
void Get(ULong64_t *array) const
Definition: TBits.h:124
void Set(UInt_t nbits, const UShort_t *array)
Definition: TBits.h:102
void Get(Char_t *array) const
Copy all the byes.
Definition: TBits.cxx:516
void Get(UShort_t *array) const
Definition: TBits.h:120
UInt_t FirstNullBit(UInt_t startBit=0) const
Return position of first null bit (starting from position 0 and up)
Definition: TBits.cxx:275
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 CountBits(UInt_t startBit=0) const
Return number of bits set to 1 starting at bit startBit.
Definition: TBits.cxx:118
void Get(UChar_t *array) const
Definition: TBits.h:118
UInt_t GetNbytes() const
Definition: TBits.h:135
void Compact()
Reduce the storage used by the object to a minimun.
Definition: TBits.cxx:95
TBits::TReference operator[](UInt_t bitnumber)
Definition: TBits.h:83
void DoLeftShift(UInt_t shift)
Execute the left shift operation.
Definition: TBits.cxx:217
virtual ~TBits()
TBits destructor.
Definition: TBits.cxx:76
TBits & operator&=(const TBits &rhs)
Definition: TBits.h:86
UChar_t * fAllBits
Definition: TBits.h:32
TBits & operator=(const TBits &)
TBits assignment operator.
Definition: TBits.cxx:56
Bool_t TestBitNumber(UInt_t bitnumber) const
Definition: TBits.h:222
TBits & operator<<=(UInt_t rhs)
Definition: TBits.h:89
TBits(UInt_t nbits=8)
TBits constructor. All bits set to 0.
Definition: TBits.cxx:33
Bool_t operator!=(const TBits &other) const
Definition: TBits.h:138
void DoFlip()
Execute ~(*this)
Definition: TBits.cxx:205
void Set(UInt_t nbits, const Char_t *array)
Set all the bytes.
Definition: TBits.cxx:503
void SetBitNumber(UInt_t bitnumber, Bool_t value=kTRUE)
Definition: TBits.h:206
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
Mother of all ROOT objects.
Definition: TObject.h:37
UInt_t fBits
bit field status word
Definition: TObject.h:41