38
38
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
39
39
// OF THE POSSIBILITY OF SUCH DAMAGE.
40
40
41
- #![ feature( core, old_io, io, core) ]
42
-
43
41
use std:: cmp:: min;
44
- use std:: old_io:: * ;
45
- use std:: iter:: repeat;
46
42
use std:: env;
47
- use std:: slice:: bytes:: copy_memory;
43
+ use std:: io;
44
+ use std:: io:: prelude:: * ;
45
+ use std:: iter:: repeat;
48
46
49
47
const LINE_LEN : usize = 60 ;
50
48
const LOOKUP_SIZE : usize = 4 * 1024 ;
@@ -116,27 +114,31 @@ struct RepeatFasta<'a, W:'a> {
116
114
out : & ' a mut W
117
115
}
118
116
119
- impl < ' a , W : Writer > RepeatFasta < ' a , W > {
117
+ impl < ' a , W : Write > RepeatFasta < ' a , W > {
120
118
fn new ( alu : & ' static str , w : & ' a mut W ) -> RepeatFasta < ' a , W > {
121
119
RepeatFasta { alu : alu, out : w }
122
120
}
123
121
124
- fn make ( & mut self , n : usize ) -> IoResult < ( ) > {
122
+ fn make ( & mut self , n : usize ) -> io :: Result < ( ) > {
125
123
let alu_len = self . alu . len ( ) ;
126
124
let mut buf = repeat ( 0 ) . take ( alu_len + LINE_LEN ) . collect :: < Vec < _ > > ( ) ;
127
125
let alu: & [ u8 ] = self . alu . as_bytes ( ) ;
128
126
129
- copy_memory ( alu, & mut buf) ;
127
+ for ( slot, val) in buf. iter_mut ( ) . zip ( alu. iter ( ) ) {
128
+ * slot = * val;
129
+ }
130
130
let buf_len = buf. len ( ) ;
131
- copy_memory ( & alu[ ..LINE_LEN ] , & mut buf[ alu_len..buf_len] ) ;
131
+ for ( slot, val) in buf[ alu_len..buf_len] . iter_mut ( ) . zip ( alu[ ..LINE_LEN ] . iter ( ) ) {
132
+ * slot = * val;
133
+ }
132
134
133
135
let mut pos = 0 ;
134
136
let mut bytes;
135
137
let mut n = n;
136
138
while n > 0 {
137
139
bytes = min ( LINE_LEN , n) ;
138
- try!( self . out . write ( & buf[ pos..pos + bytes] ) ) ;
139
- try!( self . out . write_u8 ( '\n' as u8 ) ) ;
140
+ try!( self . out . write_all ( & buf[ pos..pos + bytes] ) ) ;
141
+ try!( self . out . write_all ( & [ b '\n'] ) ) ;
140
142
pos += bytes;
141
143
if pos > alu_len {
142
144
pos -= alu_len;
@@ -165,7 +167,7 @@ struct RandomFasta<'a, W:'a> {
165
167
out : & ' a mut W ,
166
168
}
167
169
168
- impl < ' a , W : Writer > RandomFasta < ' a , W > {
170
+ impl < ' a , W : Write > RandomFasta < ' a , W > {
169
171
fn new ( w : & ' a mut W , a : & [ AminoAcid ] ) -> RandomFasta < ' a , W > {
170
172
RandomFasta {
171
173
seed : 42 ,
@@ -189,7 +191,7 @@ impl<'a, W: Writer> RandomFasta<'a, W> {
189
191
0
190
192
}
191
193
192
- fn make ( & mut self , n : usize ) -> IoResult < ( ) > {
194
+ fn make ( & mut self , n : usize ) -> io :: Result < ( ) > {
193
195
let lines = n / LINE_LEN ;
194
196
let chars_left = n % LINE_LEN ;
195
197
let mut buf = [ 0 ; LINE_LEN + 1 ] ;
@@ -204,7 +206,7 @@ impl<'a, W: Writer> RandomFasta<'a, W> {
204
206
for i in 0 ..chars_left {
205
207
buf[ i] = self . nextc ( ) ;
206
208
}
207
- self . out . write ( & buf[ ..chars_left] )
209
+ self . out . write_all ( & buf[ ..chars_left] )
208
210
}
209
211
}
210
212
@@ -216,23 +218,23 @@ fn main() {
216
218
5
217
219
} ;
218
220
219
- let mut out = stdout ( ) ;
221
+ let mut out = io :: stdout ( ) ;
220
222
221
- out. write_line ( ">ONE Homo sapiens alu" ) . unwrap ( ) ;
223
+ out. write_all ( b ">ONE Homo sapiens alu\n ") . unwrap ( ) ;
222
224
{
223
225
let mut repeat = RepeatFasta :: new ( ALU , & mut out) ;
224
226
repeat. make ( n * 2 ) . unwrap ( ) ;
225
227
}
226
228
227
- out. write_line ( ">TWO IUB ambiguity codes" ) . unwrap ( ) ;
229
+ out. write_all ( b ">TWO IUB ambiguity codes\n ") . unwrap ( ) ;
228
230
let iub = sum_and_scale ( & IUB ) ;
229
231
let mut random = RandomFasta :: new ( & mut out, & iub) ;
230
232
random. make ( n * 3 ) . unwrap ( ) ;
231
233
232
- random. out . write_line ( ">THREE Homo sapiens frequency" ) . unwrap ( ) ;
234
+ random. out . write_all ( b ">THREE Homo sapiens frequency\n ") . unwrap ( ) ;
233
235
let homo_sapiens = sum_and_scale ( & HOMO_SAPIENS ) ;
234
236
random. lookup = make_lookup ( & homo_sapiens) ;
235
237
random. make ( n * 5 ) . unwrap ( ) ;
236
238
237
- random. out . write_str ( "\n " ) . unwrap ( ) ;
239
+ random. out . write_all ( b "\n ") . unwrap ( ) ;
238
240
}
0 commit comments