ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE-3.0/src/utils/BitSet.cpp
(Generate patch)

Comparing trunk/OOPSE-3.0/src/utils/BitSet.cpp (file contents):
Revision 1961 by tim, Tue Feb 1 06:55:00 2005 UTC vs.
Revision 2037 by tim, Wed Feb 16 19:36:30 2005 UTC

# Line 39 | Line 39
39   * such damages.
40   */
41  
42 – #include "utils/BitSet.hpp"
42   #include <algorithm>
43 + #include <cassert>
44 + #include <string>
45 +
46 + #include "utils/BitSet.hpp"
47 + #include "utils/Algorithm.hpp"
48 +
49   namespace oopse {
50   int BitSet::countBits() {
51 <    std::count(bitset_.begin(), bitset_.end(), true);
51 > #ifdef __RWSTD    
52 >    //For the compiler(Sun, MSVC6.0) binding with RougeWave STL Library, we need to use old-style
53 >    // std::count which is error-prone.
54 >    int count = 0;
55 >    std::count(bitset_.begin(), bitset_.end(), true, count);
56 >    return count;
57 > #else
58 >    return std::count(bitset_.begin(), bitset_.end(), true);
59 > #endif
60   }
61  
62   void BitSet::flip(int fromIndex, int toIndex) {
# Line 69 | Line 82 | BitSet BitSet::get(int fromIndex, int toIndex) {
82      return result;
83   }
84  
85 < bool BitSet::isEmpty() {
85 > bool BitSet::none() {
86      std::vector<char>::iterator i = std::find(bitset_.begin(), bitset_.end(), true);
87      return i == bitset_.end() ? true : false;
88   }
89      
90 < int BitSet::nextOffBit(int fromIndex) {
90 > int BitSet::nextOffBit(int fromIndex) const {
91 >    if (fromIndex <= -1) {
92 >        //in case -1 or other negative number is passed to this function
93 >        return -1;
94 >    }
95 >    
96 >    ++fromIndex;
97 >    while (fromIndex < size()) {
98 >        if (!bitset_[fromIndex]) {
99 >            return fromIndex;
100 >        }
101 >        ++fromIndex;
102 >    }
103  
104 +    return -1;
105   }
106  
107 < int BitSet::nextOnBit(int fromIndex);
107 > int BitSet::nextOnBit(int fromIndex) const {
108 >    if (fromIndex <= -1) {
109 >        //in case -1 or other negative number is passed to this function
110 >        return -1;
111 >    }
112  
113 < void BitSet::and(const BitSet& bs) {
114 <    assert(size() == bs.size());
113 >    ++fromIndex;
114 >    while (fromIndex < size()) {
115 >        if (bitset_[fromIndex]) {
116 >            return fromIndex;
117 >        }
118 >        ++fromIndex;
119 >    }
120  
121 <    std::transform(bs.bitset_.begin(), bs.bitset_.end(), bitset_.begin(), bitset_.begin(), std::logical_and<bool>());
121 >    return -1;
122   }
123  
124 < void BitSet::andNot(const BitSet& bs) {
124 > void BitSet::andOperator (const BitSet& bs) {
125      assert(size() == bs.size());
126 <    std::transform(bs.bitset_.begin(), bs.bitset_.end(), bitset_.begin(), bitset_.begin(), oopse::logical_andNot<bool>());        
126 >
127 >    std::transform(bs.bitset_.begin(), bs.bitset_.end(), bitset_.begin(), bitset_.begin(), std::logical_and<bool>());
128   }
129  
130 < void BitSet::or(const BitSet& bs){
130 > void BitSet::orOperator (const BitSet& bs) {
131      assert(size() == bs.size());
132      std::transform(bs.bitset_.begin(), bs.bitset_.end(), bitset_.begin(), bitset_.begin(), std::logical_or<bool>());    
133   }
134  
135 < void BitSet::xor(const BitSet& bs);       {
135 > void BitSet::xorOperator (const BitSet& bs) {
136      assert(size() == bs.size());
137      std::transform(bs.bitset_.begin(), bs.bitset_.end(), bitset_.begin(), bitset_.begin(), oopse::logical_xor<bool>());        
138   }
# Line 110 | Line 146 | void BitSet::setBits(int fromIndex, int toIndex, bool
146      std::fill(first, last, value);
147   }
148  
149 < BitSet operator| (BitSet& bs1, BitSet& bs2) {
149 > void BitSet::resize(int nbits) {
150 >    int oldSize = size();
151 >    bitset_.resize(nbits);
152 >    if (nbits > oldSize) {
153 >        std::fill(bitset_.begin()+oldSize, bitset_.begin()+nbits+1, false);
154 >    }
155 > }
156 >
157 > BitSet operator| (const BitSet& bs1, const BitSet& bs2) {
158      assert(bs1.size() == bs2.size());
159  
160      BitSet result(bs1);
# Line 118 | Line 162 | BitSet operator| (BitSet& bs1, BitSet& bs2) {
162      return result;
163   }
164  
165 < BitSet operator& (BitSet& bs1, BitSet& bs2) {
165 > BitSet operator& (const BitSet& bs1, const BitSet& bs2) {
166      assert(bs1.size() == bs2.size());
167  
168      BitSet result(bs1);
# Line 126 | Line 170 | BitSet operator& (BitSet& bs1, BitSet& bs2) {
170      return result;
171   }
172  
173 < BitSet operator^ (BitSet& bs1, BitSet& bs2) {
173 > BitSet operator^ (const BitSet& bs1, const BitSet& bs2) {
174      assert(bs1.size() == bs2.size());
175  
176      BitSet result(bs1);
# Line 134 | Line 178 | BitSet operator^ (BitSet& bs1, BitSet& bs2) {
178      return result;
179   }
180  
181 + BitSet operator- (const BitSet& bs1, const BitSet& bs2) {
182 +    assert(bs1.size() == bs2.size());
183 +
184 +    BitSet result(bs1);
185 +    result -= bs2;
186 +    return result;
187 + }
188 +
189   bool operator== (const BitSet & bs1, const BitSet &bs2) {
190      assert(bs1.size() == bs2.size());
191      return std::equal(bs1.bitset_.begin(), bs1.bitset_.end(), bs2.bitset_.begin());
192   }
193  
194 < std::istream& operator>> ( std::istream& is, BitSet& bs) {
194 > std::istream& operator>> ( std::istream& is, const BitSet& bs) {
195  
196 +    return is;
197   }
198  
199   std::ostream& operator<< ( std::ostream& os, const BitSet& bs) {
200 <
200 >    for (int i = 0; i < bs.bitset_.size(); ++i) {
201 >        std::string val = bs[i] ? "true" : "false";
202 >        os << "BitSet[" << i <<"] = " << val << std::endl;
203 >    }
204 >    
205 >    return os;
206   }
207  
208   }

Diff Legend

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