@@ -98,6 +98,14 @@ type Blocks<'a> = Cloned<Items<'a, u32>>;
98
98
type MutBlocks < ' a > = MutItems < ' a , u32 > ;
99
99
type MatchWords < ' a > = Chain < Enumerate < Blocks < ' a > > , Skip < Take < Enumerate < Repeat < u32 > > > > > ;
100
100
101
+ fn reverse_bits ( byte : u8 ) -> u8 {
102
+ let mut result = 0 ;
103
+ for i in range ( 0 , u8:: BITS ) {
104
+ result |= ( ( byte >> i) & 1 ) << ( u8:: BITS - 1 - i) ;
105
+ }
106
+ result
107
+ }
108
+
101
109
// Take two BitV's, and return iterators of their words, where the shorter one
102
110
// has been padded with 0's
103
111
fn match_words < ' a , ' b > ( a : & ' a Bitv , b : & ' b Bitv ) -> ( MatchWords < ' a > , MatchWords < ' b > ) {
@@ -303,19 +311,21 @@ impl Bitv {
303
311
let complete_words = bytes. len ( ) / 4 ;
304
312
let extra_bytes = bytes. len ( ) % 4 ;
305
313
314
+ bitv. nbits = len;
315
+
306
316
for i in range ( 0 , complete_words) {
307
317
bitv. storage . push (
308
- ( bytes[ i * 4 + 0 ] as u32 << 0 ) |
309
- ( bytes[ i * 4 + 1 ] as u32 << 8 ) |
310
- ( bytes[ i * 4 + 2 ] as u32 << 16 ) |
311
- ( bytes[ i * 4 + 3 ] as u32 << 24 )
318
+ ( reverse_bits ( bytes[ i * 4 + 0 ] ) as u32 << 0 ) |
319
+ ( reverse_bits ( bytes[ i * 4 + 1 ] ) as u32 << 8 ) |
320
+ ( reverse_bits ( bytes[ i * 4 + 2 ] ) as u32 << 16 ) |
321
+ ( reverse_bits ( bytes[ i * 4 + 3 ] ) as u32 << 24 )
312
322
) ;
313
323
}
314
324
315
325
if extra_bytes > 0 {
316
326
let mut last_word = 0u32 ;
317
327
for ( i, & byte) in bytes[ complete_words* 4 ..] . iter ( ) . enumerate ( ) {
318
- last_word |= byte as u32 << ( i * 8 ) ;
328
+ last_word |= reverse_bits ( byte) as u32 << ( i * 8 ) ;
319
329
}
320
330
bitv. storage . push ( last_word) ;
321
331
}
@@ -1102,18 +1112,20 @@ impl Default for BitvSet {
1102
1112
fn default ( ) -> BitvSet { BitvSet :: new ( ) }
1103
1113
}
1104
1114
1105
- impl FromIterator < bool > for BitvSet {
1106
- fn from_iter < I : Iterator < bool > > ( iterator : I ) -> BitvSet {
1115
+ impl FromIterator < uint > for BitvSet {
1116
+ fn from_iter < I : Iterator < uint > > ( iterator : I ) -> BitvSet {
1107
1117
let mut ret = BitvSet :: new ( ) ;
1108
1118
ret. extend ( iterator) ;
1109
1119
ret
1110
1120
}
1111
1121
}
1112
1122
1113
- impl Extend < bool > for BitvSet {
1123
+ impl Extend < uint > for BitvSet {
1114
1124
#[ inline]
1115
- fn extend < I : Iterator < bool > > ( & mut self , iterator : I ) {
1116
- self . bitv . extend ( iterator) ;
1125
+ fn extend < I : Iterator < uint > > ( & mut self , mut iterator : I ) {
1126
+ for i in iterator {
1127
+ self . insert ( i) ;
1128
+ }
1117
1129
}
1118
1130
}
1119
1131
@@ -2592,9 +2604,9 @@ mod bitv_set_test {
2592
2604
}
2593
2605
2594
2606
#[ test]
2595
- fn test_bitv_set_from_bools ( ) {
2596
- let bools = vec ! [ true , false , true , true ] ;
2597
- let a: BitvSet = bools . iter ( ) . map ( |n| * n ) . collect ( ) ;
2607
+ fn test_bitv_set_from_uints ( ) {
2608
+ let uints = vec ! [ 0 , 2 , 2 , 3 ] ;
2609
+ let a: BitvSet = uints . into_iter ( ) . collect ( ) ;
2598
2610
let mut b = BitvSet :: new ( ) ;
2599
2611
b. insert ( 0 ) ;
2600
2612
b. insert ( 2 ) ;
@@ -2604,13 +2616,13 @@ mod bitv_set_test {
2604
2616
2605
2617
#[ test]
2606
2618
fn test_bitv_set_iterator ( ) {
2607
- let bools = [ true , false , true , true ] ;
2608
- let bitv: BitvSet = bools . iter ( ) . map ( |n| * n ) . collect ( ) ;
2619
+ let uints = vec ! [ 0 , 2 , 2 , 3 ] ;
2620
+ let bitv: BitvSet = uints . into_iter ( ) . collect ( ) ;
2609
2621
2610
2622
let idxs: Vec < uint > = bitv. iter ( ) . collect ( ) ;
2611
- assert_eq ! ( idxs, vec!( 0 , 2 , 3 ) ) ;
2623
+ assert_eq ! ( idxs, vec![ 0 , 2 , 3 ] ) ;
2612
2624
2613
- let long: BitvSet = range ( 0 u, 10000 ) . map ( | n| n % 2 == 0 ) . collect ( ) ;
2625
+ let long: BitvSet = range ( 0 u, 10000 ) . filter ( | & n| n % 2 == 0 ) . collect ( ) ;
2614
2626
let real = range_step ( 0 , 10000 , 2 ) . collect :: < Vec < uint > > ( ) ;
2615
2627
2616
2628
let idxs: Vec < uint > = long. iter ( ) . collect ( ) ;
0 commit comments