ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/OpenMD/trunk/src/utils/BitSet.hpp
(Generate patch)

Comparing trunk/src/utils/BitSet.hpp (file contents):
Revision 277 by tim, Tue Feb 1 06:55:00 2005 UTC vs.
Revision 312 by tim, Fri Feb 11 22:35:05 2005 UTC

# Line 42 | Line 42
42   #ifndef UTILS_BITSET_HPP
43   #define UTILS_BITSET_HPP
44  
45 + #include <iostream>
46 + #include <functional>
47   #include <vector>
48   namespace oopse {
49  
50   /**
51   * @class BitSet BitSet.hpp "BitSet.hpp"
52 < * @brief BitSet is a wrapper class of std::vector<char>
52 > * @brief BitSet is a wrapper class of std::vector<char> to act as a growable std::bitset
53   */
54   class BitSet {
55      public:
56          /** */
57          BitSet() {}
58          /** */
59 <        BitSet(int nbits) {  bitset_.resize(nbits);  }
59 >        BitSet(int nbits) : bitset_(nbits) {clearAll(); }
60  
61          /** Returns the number of bits set to true in this BitSet.  */
62          int countBits();
# Line 74 | Line 76 | class BitSet {
76          /** Returns a new BitSet composed of bits from this BitSet from fromIndex(inclusive) to toIndex(exclusive). */
77          BitSet get(int fromIndex, int toIndex);
78          
79 <        /** Returns true if this BitSet contains no bits that are set to true. */
80 <        bool isEmpty();
81 <                
79 >        /** Returns true if any bits are set to true */
80 >        bool any() {return !none(); }
81 >
82 >        /** Returns true if no bits are set to true */
83 >        bool none();
84 >
85 >        int firstOffBit() { return !bitset_[0] ? 0 : nextOffBit(0); }
86 >        
87          /** Returns the index of the first bit that is set to false that occurs on or after the specified starting index.*/
88 <        int nextOffBit(int fromIndex);
89 <        
88 >        int nextOffBit(int fromIndex) const;
89 >
90 >        int firstOnBit() { return bitset_[0] ? 0 : nextOnBit(0); }
91 >        
92          /** Returns the index of the first bit that is set to true that occurs on or after the specified starting index. */
93 <        int nextOnBit(int fromIndex);
93 >        int nextOnBit(int fromIndex) const;
94          
95          /** Performs a logical AND of this target bit set with the argument bit set. */
96 <        void and(const BitSet& bs);
97 <
89 <        /** Clears all of the bits in this BitSet whose corresponding bit is set in the specified BitSet. */
90 <        void andNot(const BitSet& bs);
91 <        
96 >        void andOperator (const BitSet& bs);
97 >      
98          /** Performs a logical OR of this bit set with the bit set argument. */
99 <        void or(const BitSet& bs);
99 >        void orOperator (const BitSet& bs);
100          
101          /** Performs a logical XOR of this bit set with the bit set argument. */
102 <        void xor(const BitSet& bs);        
102 >        void xorOperator (const BitSet& bs);        
103                
104          void setBitOn(int bitIndex) {  setBit(bitIndex, true);  }
105  
# Line 104 | Line 110 | class BitSet {
110          void setRangeOff(int fromIndex, int toIndex) {  setBits(fromIndex, toIndex, false);  }        
111  
112          /** Sets all of the bits in this BitSet to false. */
113 <        void clear() {  setRangeOff(0, size());  }        
113 >        void clearAll() {  setRangeOff(0, size());  }        
114 >
115 >        void setAll() {  setRangeOn(0, size());  }        
116          
117          /** Returns the number of bits of space actually in use by this BitSet to represent bit values. */
118 <        int size() {  return bitset_.size();  }
118 >        int size() const {  return bitset_.size();  }
119  
120          /** Changes the size of BitSet*/
121 <        bool resize(int nbits) {  bitset_.resize();  }
121 >        void resize(int nbits);
122          
123 <        BitSet& operator&= (const BitSet &bs) {  and(bs); return *this; }
124 <        BitSet& operator|= (const BitSet &bs) { or(bs); return *this; }
125 <        BitSet& operator^= (const BitSet &bs) { xor(bs); return *this; }
126 <        bool operator[] (int bitIndex) {  return bitset_[bitIndex];  }
127 <
128 <        friend BitSet operator| (BitSet& bs1, BitSet& bs2);
129 <        friend BitSet operator& (BitSet& bs1, BitSet& bs2);
122 <        friend BitSet operator^ (BitSet& bs1, BitSet& bs2);
123 >        BitSet& operator&= (const BitSet &bs) {  andOperator (bs); return *this; }
124 >        BitSet& operator|= (const BitSet &bs) { orOperator (bs); return *this; }
125 >        BitSet& operator^= (const BitSet &bs) { xorOperator (bs); return *this; }
126 >        bool operator[] (int bitIndex)  const {  return bitset_[bitIndex];  }
127 >        friend BitSet operator| (const BitSet& bs1, const BitSet& bs2);
128 >        friend BitSet operator& (const BitSet& bs1, const BitSet& bs2);
129 >        friend BitSet operator^ (const BitSet& bs1, const BitSet& bs2);
130          friend bool operator== (const BitSet & bs1, const BitSet &bs2);
131  
132 <        friend std::istream& operator>> ( std::istream&, BitSet& bs);
132 >        friend std::istream& operator>> ( std::istream&, const BitSet& bs);
133          friend std::ostream& operator<< ( std::ostream&, const BitSet& bs) ;
134  
135      private:
# Line 131 | Line 138 | class BitSet {
138          void setBit(int bitIndex, bool value) { bitset_[bitIndex] = value; }
139          
140          /** Sets the bits from the specified fromIndex(inclusive) to the specified toIndex(exclusive) to the specified value. */
141 <        void setBits(int fromIndex, int toIndex, bool value) {}
141 >        void setBits(int fromIndex, int toIndex, bool value);
142          
143          std::vector<char> bitset_;
144   };
145  
146 + template<typename T>
147 + struct logical_xor :public std::binary_function<T, T, bool> {
148 +    double operator()(T x, T y) { return x ^ y; }
149 + };
150 +
151   }
152   #endif

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines