casacore
Loading...
Searching...
No Matches
BitVector.h
Go to the documentation of this file.
1//# BitVector.h: Bit vectors of any size
2//# Copyright (C) 1993,1994,1995,1999,2000,2001
3//# Associated Universities, Inc. Washington DC, USA.
4//#
5//# This library is free software; you can redistribute it and/or modify it
6//# under the terms of the GNU Library General Public License as published by
7//# the Free Software Foundation; either version 2 of the License, or (at your
8//# option) any later version.
9//#
10//# This library is distributed in the hope that it will be useful, but WITHOUT
11//# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12//# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public
13//# License for more details.
14//#
15//# You should have received a copy of the GNU Library General Public License
16//# along with this library; if not, write to the Free Software Foundation,
17//# Inc., 675 Massachusetts Ave, Cambridge, MA 02139, USA.
18//#
19//# Correspondence concerning AIPS++ should be addressed as follows:
20//# Internet email: aips2-request@nrao.edu.
21//# Postal address: AIPS++ Project Office
22//# National Radio Astronomy Observatory
23//# 520 Edgemont Road
24//# Charlottesville, VA 22903-2475 USA
25//#
26//# $Id$
27
28#ifndef CASA_BITVECTOR_H
29#define CASA_BITVECTOR_H
30
31//# Includes
32#include <casacore/casa/aips.h>
33#include <casacore/casa/Containers/Block.h>
34#include <casacore/casa/Utilities/Assert.h>
35#include <casacore/casa/iosfwd.h>
36
37namespace casacore { //# NAMESPACE CASACORE - BEGIN
38
39//# Forward Declarations
40class BitVectorHelper;
41
42// The size of a unsigned Integer ( assumes 8-bit char )
43const uInt WORDSIZE = sizeof(uInt)*8;
44
45// <summary>
46// Bit vectors of any size
47// </summary>
48
49// <use visibility=export>
50
51// <reviewed reviewer="Friso Olnon" date="1995/03/13" tests="tBitVector" demos="">
52
53// <etymology>
54// A variable utilized as a discrete collection of bits is referred
55// to as a bit vector.
56// </etymology>
57
58// <synopsis>
59// Bit vectors are an efficent method of keeping <em>True/False</em>
60// information on a set of items or conditions. Class BitVector
61// provides functions to manipulate individual bits in the vector and
62// to perform logical operations on whole bit vectors.
63// </synopsis>
64
65// <example>
66// <srcblock>
67// // Create a bit vector with 20 bits (and set them all to False).
68// BitVector bv (20, False);
69//
70// // Change some individual bits:
71// // Turn On (make True) bit 19.
72// bv.setBit (19);
73// // Turn Off (make False) bit 12 (superfluous here).
74// bv.clearBit (12);
75// // Toggle bit 5 (here: change value from 0 (False) to 1 (True)).
76// bv.toggleBit (5)
77// // Another way of setting a bit using the index operator.
78// bv[0] = True;
79// // Assign the value of bit 0 to bit 1 (in three ways).
80// bv[1] = bv.getBit(0);
81// bv[1] = bv[0];
82// bv.putBit (1, bv.getBit(0));
83//
84// // Show the bit vector size and its value on standard output.
85// cout << "Size of bit vector: "<< b.nbits() <<"\n";
86// cout << "Value of bit vector: "<< bv <<"\n";
87//
88// // Perform logical operations on bit vectors.
89// // Create two more bit vectors.
90// BitVector bv2 (40, False);
91// BitVector bv3 (40, True);
92// // bitwise OR
93// bv = bv2 | bv3;
94// // bitwise AND
95// bv = bv2 & bv3;
96// // bitwise XOR
97// bv = bv2 ^ bv3;
98// // bitwise NOT
99// bv = ~bv2;
100//
101// // Reset all bits to False, and then to True
102// bv = False;
103// bv.set (True);
104// // Change the vector's size to 10 (and copy the old values).
105// bv.resize (10);
106// // Change back to original size and set all bits to True.
107// void bv.resize (size, True, False);
108// </srcblock>
109// </example>
110
111
113{
114public:
115 // BitVectorHelper is a helper class.
116 friend class BitVectorHelper;
117
118 // Create a bit vector of length 0.
120
121 // Create a bit vector with <src>length</src> bits
122 // and set all bits to to the specified state.
124
125 // Copy constructor (copy semantics).
126 BitVector (const BitVector& that);
127
128 // Delete the bit vector.
130
131 // Assignment (copy semantics).
133
134 // Set all bits to the given state.
136
137 // Return the number of bits in the bitvector.
138 uInt nbits() const;
139
140 // Set a bit at the given position (0-relative).
141 // In debug-mode an exception is thrown when the position is invalid.
142 void setBit (uInt pos);
143
144 // Clear a bit at the given position (0-relative).
145 // In debug-mode an exception is thrown when the position is invalid.
146 void clearBit (uInt pos);
147
148 // Toggle a bit at the given position (0-relative).
149 // It returns the original state.
150 // In debug-mode an exception is thrown when the position is invalid.
152
153 // Get a bit at the given position (0-relative).
154 // In debug-mode an exception is thrown when the position is invalid.
155 Bool getBit (uInt pos) const;
156
157 // Set a bit at the given position (0-relative) to the given state.
158 // In debug-mode an exception is thrown when the position is invalid.
159 void putBit (uInt pos, Bool state);
160
161 // Index operator to access the specified bit.
162 // In debug-mode an exception is thrown when the position is invalid.
163 // <group>
164 Bool operator[] (uInt pos) const;
166 // </group>
167
168 // Logical operations on whole bit vectors.
169 // The binary operators <src>&</src> (bitwise
170 // AND), <src>|</src> (bitwise OR) and <src>^</src> (bitwise XOR),
171 // and the unary operator <src>~</src> (bitwise NOT) are provided.
172 // An exception is thrown if the lengths of the vectors differ.
173 // <group>
174 BitVector operator& (const BitVector& that) const;
175 BitVector operator| (const BitVector& that) const;
176 BitVector operator^ (const BitVector& that) const;
178 // </group>
179
180 // Logical in-place operations on whole bit vectors.
181 // The binary operators <src>&</src> (bitwise
182 // AND), <src>|</src> (bitwise OR) and <src>^</src> (bitwise XOR),
183 // and the unary operator <src>reverse</src> (bitwise NOT) are provided.
184 // An exception is thrown if the lengths of the vectors differ.
185 // <group>
186 void operator&= (const BitVector& that);
187 void operator|= (const BitVector& that);
188 void operator^= (const BitVector& that);
189 void reverse ();
190 // </group>
191
192 // Returns True if all bits are equal.
193 // An exception is thrown if the lengths of the vectors differ.
194 Bool operator== (const BitVector& that) const;
195
196 // Returns True if a bit differs.
197 // An exception is thrown if the lengths of the vectors differ.
198 Bool operator!= (const BitVector& that) const;
199
200 // Resize the bit vector to the new length.
201 // By default the original bits are copied.
202 // The remaining bits (or all bits in case of no copy) are
203 // set the the given state.
205
206 // Set all bits of the bit vector to the specified state.
207 void set (Bool state);
208
209 // Set <src>length</src> bits starting at the start position
210 // (0-relative) to the given state.
211 // An exception is thrown if start+length exceeds the length
212 // of the vector.
213 void set (uInt start, uInt length, Bool state);
214
215 // Copy <src>length</src> bits starting at thatStart in the
216 // other BitVector to this BitVector starting at thisStart.
217 void copy (uInt thisStart, uInt length, const BitVector& that,
218 uInt thatStart);
219
220 // Write a representation of the bit vector (a list of
221 // <em>zeros</em> and <em>ones</em> enclosed in square
222 // parentheses) to ostream.
223 friend ostream& operator<< (ostream&, const BitVector& vector);
224
225private:
226 // Number of bits in the BitVector object.
228
229 // Pointer to the actual bit vector, stored as a contiguous
230 // sequence of one or more unsigned integers.
232};
233
234
235
236// <summary> Helper class for BitVector </summary>
237// <use visibility=local>
238// <reviewed reviewer="Friso Olnon" date="1995/03/13" tests="tBitVector" demos="">
239
240// <prerequisite>
241// <li> class <linkto class=BitVector>BitVector</linkto>
242// </prerequisite>
243
244// <synopsis>
245// Helper class for class <linkto class=BitVector>BitVector</linkto>.
246// For all practical purposes a BitVectorHelper object is the individual bit in
247// a bit vector. It is the object returned by the index operator of
248// BitVector.
249// </synopsis>
250
252{
253friend class BitVector;
254
255public:
256 // Copy constructor has to be public.
257 BitVectorHelper (const BitVectorHelper& that);
258
259 // Set the bit to the state of the bit in the other BitVector.
260 // Thus assignment has not the usual copy semantics, but affects
261 // the underlying BitVector bit.
262 const BitVectorHelper& operator= (const BitVectorHelper& that) const;
263
264 // Set to a state.
265 const BitVectorHelper& operator= (Bool state) const;
266
267 // Defines the conversion from <src>BitVectorHelper</src> to
268 // <src>Bool</src>.
269 operator Bool() const;
270
271private:
273
274 // Pointer back to the original vector.
276
277 // The constructor we actually use.
278 BitVectorHelper (uInt bitNumber, BitVector* vector);
279};
280
281
282
283inline void BitVector::setBit (uInt pos)
284{
286 uInt index = pos/WORDSIZE;
287 bits_p[index] |= (1 << (pos - index*WORDSIZE));
288}
289
290inline void BitVector::clearBit (uInt pos)
291{
293 uInt index = pos/WORDSIZE;
294 bits_p[index] &= (~ (1 << (pos - index*WORDSIZE)));
295}
296
298{
299 return getBit (pos);
300}
301
302inline uInt BitVector::nbits() const
303{
304 return size_p;
305}
306
307
309: bitNumber_p (bitNumber),
310 vecPtr_p (vector)
311{}
312
314{
315 return BitVectorHelper (pos, this);
316}
317
319: bitNumber_p (that.bitNumber_p),
320 vecPtr_p (that.vecPtr_p)
321{}
322
324{
325 vecPtr_p->putBit (bitNumber_p, state);
326 return *this;
327}
328
329inline BitVectorHelper::operator Bool() const
330{
331 return vecPtr_p->getBit (bitNumber_p);
332}
333
334inline const BitVectorHelper& BitVectorHelper::operator=
335 (const BitVectorHelper& that) const
336{
337 vecPtr_p->putBit (bitNumber_p, that.vecPtr_p->getBit (that.bitNumber_p));
338 return *this;
339}
340
341
342
343
344} //# NAMESPACE CASACORE - END
345
346#endif
347
#define DebugAssert(expr, exception)
Definition Assert.h:185
Helper class for BitVector.
Definition BitVector.h:252
BitVector * vecPtr_p
Pointer back to the original vector.
Definition BitVector.h:275
BitVectorHelper(const BitVectorHelper &that)
Copy constructor has to be public.
Definition BitVector.h:318
const BitVectorHelper & operator=(const BitVectorHelper &that) const
Set the bit to the state of the bit in the other BitVector.
Definition BitVector.h:335
void operator^=(const BitVector &that)
BitVector operator~() const
Bool operator!=(const BitVector &that) const
Returns True if a bit differs.
Bool toggleBit(uInt pos)
Toggle a bit at the given position (0-relative).
void set(Bool state)
Set all bits of the bit vector to the specified state.
BitVector(uInt length, Bool state)
Create a bit vector with length bits and set all bits to to the specified state.
BitVector & operator=(const BitVector &that)
Assignment (copy semantics).
void setBit(uInt pos)
Set a bit at the given position (0-relative).
Definition BitVector.h:283
uInt nbits() const
Return the number of bits in the bitvector.
Definition BitVector.h:302
uInt size_p
Number of bits in the BitVector object.
Definition BitVector.h:227
void clearBit(uInt pos)
Clear a bit at the given position (0-relative).
Definition BitVector.h:290
BitVector(const BitVector &that)
Copy constructor (copy semantics).
void putBit(uInt pos, Bool state)
Set a bit at the given position (0-relative) to the given state.
void operator|=(const BitVector &that)
BitVector operator&(const BitVector &that) const
Logical operations on whole bit vectors.
void resize(uInt length, Bool state=False, Bool copy=True)
Resize the bit vector to the new length.
friend ostream & operator<<(ostream &, const BitVector &vector)
Write a representation of the bit vector (a list of zeros and ones enclosed in square parentheses) to...
BitVector operator^(const BitVector &that) const
Bool getBit(uInt pos) const
Get a bit at the given position (0-relative).
void copy(uInt thisStart, uInt length, const BitVector &that, uInt thatStart)
Copy length bits starting at thatStart in the other BitVector to this BitVector starting at thisStart...
BitVector operator|(const BitVector &that) const
void operator&=(const BitVector &that)
Logical in-place operations on whole bit vectors.
Bool operator[](uInt pos) const
Index operator to access the specified bit.
Definition BitVector.h:297
Block< uInt > bits_p
Pointer to the actual bit vector, stored as a contiguous sequence of one or more unsigned integers.
Definition BitVector.h:231
void set(uInt start, uInt length, Bool state)
Set length bits starting at the start position (0-relative) to the given state.
Bool operator==(const BitVector &that) const
Returns True if all bits are equal.
~BitVector()
Delete the bit vector.
friend class BitVectorHelper
BitVectorHelper is a helper class.
Definition BitVector.h:116
BitVector()
Create a bit vector of length 0.
simple 1-D array
Definition Block.h:200
this file contains all the compiler specific defines
Definition mainpage.dox:28
const Bool False
Definition aipstype.h:44
unsigned int uInt
Definition aipstype.h:51
LatticeExprNode length(const LatticeExprNode &expr, const LatticeExprNode &axis)
2-argument function to get the length of an axis.
const uInt WORDSIZE
The size of a unsigned Integer (assumes 8-bit char)
Definition BitVector.h:43
bool Bool
Define the standard types used by Casacore.
Definition aipstype.h:42
const Bool True
Definition aipstype.h:43