@@ -18,8 +18,9 @@ use io::prelude::*;
18
18
use cmp;
19
19
use error:: { self , FromError } ;
20
20
use fmt;
21
- use io:: { self , Cursor , DEFAULT_BUF_SIZE , Error , ErrorKind } ;
21
+ use io:: { self , DEFAULT_BUF_SIZE , Error , ErrorKind } ;
22
22
use ptr;
23
+ use iter;
23
24
24
25
/// Wraps a `Read` and buffers input from it
25
26
///
@@ -30,7 +31,9 @@ use ptr;
30
31
#[ stable( feature = "rust1" , since = "1.0.0" ) ]
31
32
pub struct BufReader < R > {
32
33
inner : R ,
33
- buf : Cursor < Vec < u8 > > ,
34
+ buf : Vec < u8 > ,
35
+ pos : usize ,
36
+ cap : usize ,
34
37
}
35
38
36
39
impl < R : Read > BufReader < R > {
@@ -43,9 +46,13 @@ impl<R: Read> BufReader<R> {
43
46
/// Creates a new `BufReader` with the specified buffer capacity
44
47
#[ stable( feature = "rust1" , since = "1.0.0" ) ]
45
48
pub fn with_capacity ( cap : usize , inner : R ) -> BufReader < R > {
49
+ let mut buf = Vec :: with_capacity ( cap) ;
50
+ buf. extend ( iter:: repeat ( 0 ) . take ( cap) ) ;
46
51
BufReader {
47
52
inner : inner,
48
- buf : Cursor :: new ( Vec :: with_capacity ( cap) ) ,
53
+ buf : buf,
54
+ pos : 0 ,
55
+ cap : 0 ,
49
56
}
50
57
}
51
58
@@ -74,12 +81,15 @@ impl<R: Read> Read for BufReader<R> {
74
81
// If we don't have any buffered data and we're doing a massive read
75
82
// (larger than our internal buffer), bypass our internal buffer
76
83
// entirely.
77
- if self . buf . get_ref ( ) . len ( ) == self . buf . position ( ) as usize &&
78
- buf. len ( ) >= self . buf . get_ref ( ) . capacity ( ) {
84
+ if self . pos == self . cap && buf. len ( ) >= self . buf . len ( ) {
79
85
return self . inner . read ( buf) ;
80
86
}
81
- try!( self . fill_buf ( ) ) ;
82
- self . buf . read ( buf)
87
+ let nread = {
88
+ let mut rem = try!( self . fill_buf ( ) ) ;
89
+ try!( rem. read ( buf) )
90
+ } ;
91
+ self . consume ( nread) ;
92
+ Ok ( nread)
83
93
}
84
94
}
85
95
@@ -88,26 +98,25 @@ impl<R: Read> BufRead for BufReader<R> {
88
98
fn fill_buf ( & mut self ) -> io:: Result < & [ u8 ] > {
89
99
// If we've reached the end of our internal buffer then we need to fetch
90
100
// some more data from the underlying reader.
91
- if self . buf . position ( ) as usize == self . buf . get_ref ( ) . len ( ) {
92
- self . buf . set_position ( 0 ) ;
93
- let v = self . buf . get_mut ( ) ;
94
- v. truncate ( 0 ) ;
95
- let inner = & mut self . inner ;
96
- try!( super :: with_end_to_cap ( v, |b| inner. read ( b) ) ) ;
101
+ if self . pos == self . cap {
102
+ self . cap = try!( self . inner . read ( & mut self . buf ) ) ;
103
+ self . pos = 0 ;
97
104
}
98
- self . buf . fill_buf ( )
105
+ Ok ( & self . buf [ self . pos .. self . cap ] )
99
106
}
100
107
101
108
fn consume ( & mut self , amt : usize ) {
102
- self . buf . consume ( amt)
109
+ self . pos = cmp :: min ( self . pos + amt, self . cap ) ;
103
110
}
104
111
}
105
112
106
113
#[ stable( feature = "rust1" , since = "1.0.0" ) ]
107
114
impl < R > fmt:: Debug for BufReader < R > where R : fmt:: Debug {
108
115
fn fmt ( & self , fmt : & mut fmt:: Formatter ) -> fmt:: Result {
109
- write ! ( fmt, "BufReader {{ reader: {:?}, buffer: {}/{} }}" ,
110
- self . inner, self . buf. position( ) , self . buf. get_ref( ) . len( ) )
116
+ fmt. debug_struct ( "BufReader" )
117
+ . field ( "reader" , & self . inner )
118
+ . field ( "buffer" , & format_args ! ( "{}/{}" , self . cap - self . pos, self . buf. len( ) ) )
119
+ . finish ( )
111
120
}
112
121
}
113
122
@@ -222,8 +231,10 @@ impl<W: Write> Write for BufWriter<W> {
222
231
#[ stable( feature = "rust1" , since = "1.0.0" ) ]
223
232
impl < W : Write > fmt:: Debug for BufWriter < W > where W : fmt:: Debug {
224
233
fn fmt ( & self , fmt : & mut fmt:: Formatter ) -> fmt:: Result {
225
- write ! ( fmt, "BufWriter {{ writer: {:?}, buffer: {}/{} }}" ,
226
- self . inner. as_ref( ) . unwrap( ) , self . buf. len( ) , self . buf. capacity( ) )
234
+ fmt. debug_struct ( "BufWriter" )
235
+ . field ( "writer" , & self . inner . as_ref ( ) . unwrap ( ) )
236
+ . field ( "buffer" , & format_args ! ( "{}/{}" , self . buf. len( ) , self . buf. capacity( ) ) )
237
+ . finish ( )
227
238
}
228
239
}
229
240
@@ -337,9 +348,11 @@ impl<W: Write> Write for LineWriter<W> {
337
348
#[ stable( feature = "rust1" , since = "1.0.0" ) ]
338
349
impl < W : Write > fmt:: Debug for LineWriter < W > where W : fmt:: Debug {
339
350
fn fmt ( & self , fmt : & mut fmt:: Formatter ) -> fmt:: Result {
340
- write ! ( fmt, "LineWriter {{ writer: {:?}, buffer: {}/{} }}" ,
341
- self . inner. inner, self . inner. buf. len( ) ,
342
- self . inner. buf. capacity( ) )
351
+ fmt. debug_struct ( "LineWriter" )
352
+ . field ( "writer" , & self . inner . inner )
353
+ . field ( "buffer" ,
354
+ & format_args ! ( "{}/{}" , self . inner. buf. len( ) , self . inner. buf. capacity( ) ) )
355
+ . finish ( )
343
356
}
344
357
}
345
358
@@ -415,10 +428,10 @@ impl<S: Read + Write> BufStream<S> {
415
428
/// Any leftover data in the read buffer is lost.
416
429
#[ stable( feature = "rust1" , since = "1.0.0" ) ]
417
430
pub fn into_inner ( self ) -> Result < S , IntoInnerError < BufStream < S > > > {
418
- let BufReader { inner : InternalBufWriter ( w) , buf } = self . inner ;
431
+ let BufReader { inner : InternalBufWriter ( w) , buf, pos , cap } = self . inner ;
419
432
w. into_inner ( ) . map_err ( |IntoInnerError ( w, e) | {
420
433
IntoInnerError ( BufStream {
421
- inner : BufReader { inner : InternalBufWriter ( w) , buf : buf } ,
434
+ inner : BufReader { inner : InternalBufWriter ( w) , buf : buf, pos : pos , cap : cap } ,
422
435
} , e)
423
436
} )
424
437
}
@@ -452,10 +465,12 @@ impl<S: Write> fmt::Debug for BufStream<S> where S: fmt::Debug {
452
465
fn fmt ( & self , fmt : & mut fmt:: Formatter ) -> fmt:: Result {
453
466
let reader = & self . inner ;
454
467
let writer = & self . inner . inner . 0 ;
455
- write ! ( fmt, "BufStream {{ stream: {:?}, write_buffer: {}/{}, read_buffer: {}/{} }}" ,
456
- writer. inner,
457
- writer. buf. len( ) , writer. buf. capacity( ) ,
458
- reader. buf. position( ) , reader. buf. get_ref( ) . len( ) )
468
+ fmt. debug_struct ( "BufStream" )
469
+ . field ( "stream" , & writer. inner )
470
+ . field ( "write_buffer" , & format_args ! ( "{}/{}" , writer. buf. len( ) , writer. buf. capacity( ) ) )
471
+ . field ( "read_buffer" ,
472
+ & format_args ! ( "{}/{}" , reader. cap - reader. pos, reader. buf. len( ) ) )
473
+ . finish ( )
459
474
}
460
475
}
461
476
0 commit comments