OLD | NEW |
1 // Copyright 2009 The Go Authors. All rights reserved. | 1 // Copyright 2009 The Go Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style | 2 // Use of this source code is governed by a BSD-style |
3 // license that can be found in the LICENSE file. | 3 // license that can be found in the LICENSE file. |
4 | 4 |
5 // Package bufio implements buffered I/O. It wraps an io.Reader or io.Writer | 5 // Package bufio implements buffered I/O. It wraps an io.Reader or io.Writer |
6 // object, creating another object (Reader or Writer) that also implements | 6 // object, creating another object (Reader or Writer) that also implements |
7 // the interface but provides buffering and some help for textual I/O. | 7 // the interface but provides buffering and some help for textual I/O. |
8 package bufio | 8 package bufio |
9 | 9 |
10 import ( | 10 import ( |
(...skipping 11 matching lines...) Expand all Loading... |
22 ErrInvalidUnreadByte = errors.New("bufio: invalid use of UnreadByte") | 22 ErrInvalidUnreadByte = errors.New("bufio: invalid use of UnreadByte") |
23 ErrInvalidUnreadRune = errors.New("bufio: invalid use of UnreadRune") | 23 ErrInvalidUnreadRune = errors.New("bufio: invalid use of UnreadRune") |
24 ErrBufferFull = errors.New("bufio: buffer full") | 24 ErrBufferFull = errors.New("bufio: buffer full") |
25 ErrNegativeCount = errors.New("bufio: negative count") | 25 ErrNegativeCount = errors.New("bufio: negative count") |
26 ) | 26 ) |
27 | 27 |
28 // Buffered input. | 28 // Buffered input. |
29 | 29 |
30 // Reader implements buffering for an io.Reader object. | 30 // Reader implements buffering for an io.Reader object. |
31 type Reader struct { | 31 type Reader struct { |
32 » buf []byte // either nil or []byte of length bufSize | 32 » buf []byte |
33 » bufSize int | |
34 rd io.Reader | 33 rd io.Reader |
35 r, w int | 34 r, w int |
36 err error | 35 err error |
37 lastByte int | 36 lastByte int |
38 lastRuneSize int | 37 lastRuneSize int |
39 } | 38 } |
40 | 39 |
41 const minReadBufferSize = 16 | 40 const minReadBufferSize = 16 |
42 | 41 |
43 // NewReaderSize returns a new Reader whose buffer has at least the specified | 42 // NewReaderSize returns a new Reader whose buffer has at least the specified |
44 // size. If the argument io.Reader is already a Reader with large enough | 43 // size. If the argument io.Reader is already a Reader with large enough |
45 // size, it returns the underlying Reader. | 44 // size, it returns the underlying Reader. |
46 func NewReaderSize(rd io.Reader, size int) *Reader { | 45 func NewReaderSize(rd io.Reader, size int) *Reader { |
47 // Is it already a Reader? | 46 // Is it already a Reader? |
48 b, ok := rd.(*Reader) | 47 b, ok := rd.(*Reader) |
49 » if ok && b.bufSize >= size { | 48 » if ok && len(b.buf) >= size { |
50 return b | 49 return b |
51 } | 50 } |
52 if size < minReadBufferSize { | 51 if size < minReadBufferSize { |
53 size = minReadBufferSize | 52 size = minReadBufferSize |
54 } | 53 } |
55 » r := &Reader{ | 54 » r := new(Reader) |
56 » » bufSize: size, | 55 » r.reset(make([]byte, size), rd) |
57 » » rd: rd, | |
58 » » lastByte: -1, | |
59 » » lastRuneSize: -1, | |
60 » } | |
61 » if size > defaultBufSize { | |
62 » » // TODO(bradfitz): make all buffer sizes recycle | |
63 » » r.buf = make([]byte, r.bufSize) | |
64 » } | |
65 return r | 56 return r |
66 } | 57 } |
67 | 58 |
68 // NewReader returns a new Reader whose buffer has the default size. | 59 // NewReader returns a new Reader whose buffer has the default size. |
69 func NewReader(rd io.Reader) *Reader { | 60 func NewReader(rd io.Reader) *Reader { |
70 return NewReaderSize(rd, defaultBufSize) | 61 return NewReaderSize(rd, defaultBufSize) |
71 } | 62 } |
72 | 63 |
| 64 // Reset discards any buffered data, resets all state, and switches |
| 65 // the buffered reader to read from r. |
| 66 func (b *Reader) Reset(r io.Reader) { |
| 67 b.reset(b.buf, r) |
| 68 } |
| 69 |
| 70 func (b *Reader) reset(buf []byte, r io.Reader) { |
| 71 *b = Reader{ |
| 72 buf: buf, |
| 73 rd: r, |
| 74 lastByte: -1, |
| 75 lastRuneSize: -1, |
| 76 } |
| 77 } |
| 78 |
73 var errNegativeRead = errors.New("bufio: reader returned negative count from Rea
d") | 79 var errNegativeRead = errors.New("bufio: reader returned negative count from Rea
d") |
74 | 80 |
75 // TODO: use a sync.Cache instead of this: | |
76 const arbitrarySize = 8 | |
77 | |
78 // bufCache holds only byte slices with capacity defaultBufSize. | |
79 var bufCache = make(chan []byte, arbitrarySize) | |
80 | |
81 // allocBuf makes b.buf non-nil. | |
82 func (b *Reader) allocBuf() { | |
83 if b.buf != nil { | |
84 return | |
85 } | |
86 select { | |
87 case b.buf = <-bufCache: | |
88 b.buf = b.buf[:b.bufSize] | |
89 default: | |
90 b.buf = make([]byte, b.bufSize, defaultBufSize) | |
91 } | |
92 } | |
93 | |
94 // putBuf returns b.buf if it's unused. | |
95 func (b *Reader) putBuf() { | |
96 if b.r == b.w && b.err == io.EOF && cap(b.buf) == defaultBufSize { | |
97 select { | |
98 case bufCache <- b.buf: | |
99 b.buf = nil | |
100 b.r = 0 | |
101 b.w = 0 | |
102 default: | |
103 } | |
104 } | |
105 } | |
106 | |
107 // fill reads a new chunk into the buffer. | 81 // fill reads a new chunk into the buffer. |
108 func (b *Reader) fill() { | 82 func (b *Reader) fill() { |
109 b.allocBuf() | |
110 | |
111 // Slide existing data to beginning. | 83 // Slide existing data to beginning. |
112 if b.r > 0 { | 84 if b.r > 0 { |
113 copy(b.buf, b.buf[b.r:b.w]) | 85 copy(b.buf, b.buf[b.r:b.w]) |
114 b.w -= b.r | 86 b.w -= b.r |
115 b.r = 0 | 87 b.r = 0 |
116 } | 88 } |
117 | 89 |
118 // Read new data. | 90 // Read new data. |
119 n, err := b.rd.Read(b.buf[b.w:]) | 91 n, err := b.rd.Read(b.buf[b.w:]) |
120 if n < 0 { | 92 if n < 0 { |
(...skipping 12 matching lines...) Expand all Loading... |
133 } | 105 } |
134 | 106 |
135 // Peek returns the next n bytes without advancing the reader. The bytes stop | 107 // Peek returns the next n bytes without advancing the reader. The bytes stop |
136 // being valid at the next read call. If Peek returns fewer than n bytes, it | 108 // being valid at the next read call. If Peek returns fewer than n bytes, it |
137 // also returns an error explaining why the read is short. The error is | 109 // also returns an error explaining why the read is short. The error is |
138 // ErrBufferFull if n is larger than b's buffer size. | 110 // ErrBufferFull if n is larger than b's buffer size. |
139 func (b *Reader) Peek(n int) ([]byte, error) { | 111 func (b *Reader) Peek(n int) ([]byte, error) { |
140 if n < 0 { | 112 if n < 0 { |
141 return nil, ErrNegativeCount | 113 return nil, ErrNegativeCount |
142 } | 114 } |
143 » if n > b.bufSize { | 115 » if n > len(b.buf) { |
144 return nil, ErrBufferFull | 116 return nil, ErrBufferFull |
145 } | 117 } |
146 for b.w-b.r < n && b.err == nil { | 118 for b.w-b.r < n && b.err == nil { |
147 b.fill() | 119 b.fill() |
148 } | 120 } |
149 m := b.w - b.r | 121 m := b.w - b.r |
150 if m > n { | 122 if m > n { |
151 m = n | 123 m = n |
152 } | 124 } |
153 var err error | 125 var err error |
(...skipping 13 matching lines...) Expand all Loading... |
167 // At EOF, the count will be zero and err will be io.EOF. | 139 // At EOF, the count will be zero and err will be io.EOF. |
168 func (b *Reader) Read(p []byte) (n int, err error) { | 140 func (b *Reader) Read(p []byte) (n int, err error) { |
169 n = len(p) | 141 n = len(p) |
170 if n == 0 { | 142 if n == 0 { |
171 return 0, b.readErr() | 143 return 0, b.readErr() |
172 } | 144 } |
173 if b.w == b.r { | 145 if b.w == b.r { |
174 if b.err != nil { | 146 if b.err != nil { |
175 return 0, b.readErr() | 147 return 0, b.readErr() |
176 } | 148 } |
177 » » if len(p) >= b.bufSize { | 149 » » if len(p) >= len(b.buf) { |
178 // Large read, empty buffer. | 150 // Large read, empty buffer. |
179 // Read directly into p to avoid copy. | 151 // Read directly into p to avoid copy. |
180 n, b.err = b.rd.Read(p) | 152 n, b.err = b.rd.Read(p) |
181 if n > 0 { | 153 if n > 0 { |
182 b.lastByte = int(p[n-1]) | 154 b.lastByte = int(p[n-1]) |
183 b.lastRuneSize = -1 | 155 b.lastRuneSize = -1 |
184 } | 156 } |
185 return n, b.readErr() | 157 return n, b.readErr() |
186 } | 158 } |
187 b.fill() | 159 b.fill() |
188 if b.w == b.r { | 160 if b.w == b.r { |
189 return 0, b.readErr() | 161 return 0, b.readErr() |
190 } | 162 } |
191 } | 163 } |
192 | 164 |
193 if n > b.w-b.r { | 165 if n > b.w-b.r { |
194 n = b.w - b.r | 166 n = b.w - b.r |
195 } | 167 } |
196 copy(p[0:n], b.buf[b.r:]) | 168 copy(p[0:n], b.buf[b.r:]) |
197 b.r += n | 169 b.r += n |
198 b.lastByte = int(b.buf[b.r-1]) | 170 b.lastByte = int(b.buf[b.r-1]) |
199 b.lastRuneSize = -1 | 171 b.lastRuneSize = -1 |
200 b.putBuf() | |
201 return n, nil | 172 return n, nil |
202 } | 173 } |
203 | 174 |
204 // ReadByte reads and returns a single byte. | 175 // ReadByte reads and returns a single byte. |
205 // If no byte is available, returns an error. | 176 // If no byte is available, returns an error. |
206 func (b *Reader) ReadByte() (c byte, err error) { | 177 func (b *Reader) ReadByte() (c byte, err error) { |
207 b.lastRuneSize = -1 | 178 b.lastRuneSize = -1 |
208 for b.w == b.r { | 179 for b.w == b.r { |
209 if b.err != nil { | 180 if b.err != nil { |
210 return 0, b.readErr() | 181 return 0, b.readErr() |
211 } | 182 } |
212 b.fill() | 183 b.fill() |
213 } | 184 } |
214 c = b.buf[b.r] | 185 c = b.buf[b.r] |
215 b.r++ | 186 b.r++ |
216 b.lastByte = int(c) | 187 b.lastByte = int(c) |
217 if b.err != nil { // avoid putBuf call in the common case | |
218 b.putBuf() | |
219 } | |
220 return c, nil | 188 return c, nil |
221 } | 189 } |
222 | 190 |
223 // UnreadByte unreads the last byte. Only the most recently read byte can be un
read. | 191 // UnreadByte unreads the last byte. Only the most recently read byte can be un
read. |
224 func (b *Reader) UnreadByte() error { | 192 func (b *Reader) UnreadByte() error { |
225 b.lastRuneSize = -1 | 193 b.lastRuneSize = -1 |
226 if b.r == b.w && b.lastByte >= 0 { | 194 if b.r == b.w && b.lastByte >= 0 { |
227 b.allocBuf() | |
228 b.w = 1 | 195 b.w = 1 |
229 b.r = 0 | 196 b.r = 0 |
230 b.buf[0] = byte(b.lastByte) | 197 b.buf[0] = byte(b.lastByte) |
231 b.lastByte = -1 | 198 b.lastByte = -1 |
232 return nil | 199 return nil |
233 } | 200 } |
234 if b.r <= 0 { | 201 if b.r <= 0 { |
235 return ErrInvalidUnreadByte | 202 return ErrInvalidUnreadByte |
236 } | 203 } |
237 b.r-- | 204 b.r-- |
(...skipping 34 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
272 b.lastByte = -1 | 239 b.lastByte = -1 |
273 b.lastRuneSize = -1 | 240 b.lastRuneSize = -1 |
274 return nil | 241 return nil |
275 } | 242 } |
276 | 243 |
277 // Buffered returns the number of bytes that can be read from the current buffer
. | 244 // Buffered returns the number of bytes that can be read from the current buffer
. |
278 func (b *Reader) Buffered() int { return b.w - b.r } | 245 func (b *Reader) Buffered() int { return b.w - b.r } |
279 | 246 |
280 // ReadSlice reads until the first occurrence of delim in the input, | 247 // ReadSlice reads until the first occurrence of delim in the input, |
281 // returning a slice pointing at the bytes in the buffer. | 248 // returning a slice pointing at the bytes in the buffer. |
282 // The bytes stop being valid at the next read call. | 249 // The bytes stop being valid at the next read. |
283 // If ReadSlice encounters an error before finding a delimiter, | 250 // If ReadSlice encounters an error before finding a delimiter, |
284 // it returns all the data in the buffer and the error itself (often io.EOF). | 251 // it returns all the data in the buffer and the error itself (often io.EOF). |
285 // ReadSlice fails with error ErrBufferFull if the buffer fills without a delim. | 252 // ReadSlice fails with error ErrBufferFull if the buffer fills without a delim. |
286 // Because the data returned from ReadSlice will be overwritten | 253 // Because the data returned from ReadSlice will be overwritten |
287 // by the next I/O operation, most clients should use | 254 // by the next I/O operation, most clients should use |
288 // ReadBytes or ReadString instead. | 255 // ReadBytes or ReadString instead. |
289 // ReadSlice returns err != nil if and only if line does not end in delim. | 256 // ReadSlice returns err != nil if and only if line does not end in delim. |
290 func (b *Reader) ReadSlice(delim byte) (line []byte, err error) { | 257 func (b *Reader) ReadSlice(delim byte) (line []byte, err error) { |
291 // Look in buffer. | 258 // Look in buffer. |
292 if i := bytes.IndexByte(b.buf[b.r:b.w], delim); i >= 0 { | 259 if i := bytes.IndexByte(b.buf[b.r:b.w], delim); i >= 0 { |
(...skipping 14 matching lines...) Expand all Loading... |
307 b.fill() | 274 b.fill() |
308 | 275 |
309 // Search new part of buffer | 276 // Search new part of buffer |
310 if i := bytes.IndexByte(b.buf[n:b.w], delim); i >= 0 { | 277 if i := bytes.IndexByte(b.buf[n:b.w], delim); i >= 0 { |
311 line := b.buf[0 : n+i+1] | 278 line := b.buf[0 : n+i+1] |
312 b.r = n + i + 1 | 279 b.r = n + i + 1 |
313 return line, nil | 280 return line, nil |
314 } | 281 } |
315 | 282 |
316 // Buffer is full? | 283 // Buffer is full? |
317 » » if b.Buffered() >= b.bufSize { | 284 » » if b.Buffered() >= len(b.buf) { |
318 b.r = b.w | 285 b.r = b.w |
319 return b.buf, ErrBufferFull | 286 return b.buf, ErrBufferFull |
320 } | 287 } |
321 } | 288 } |
322 } | 289 } |
323 | 290 |
324 // ReadLine is a low-level line-reading primitive. Most callers should use | 291 // ReadLine is a low-level line-reading primitive. Most callers should use |
325 // ReadBytes('\n') or ReadString('\n') instead or use a Scanner. | 292 // ReadBytes('\n') or ReadString('\n') instead or use a Scanner. |
326 // | 293 // |
327 // ReadLine tries to return a single line, not including the end-of-line bytes. | 294 // ReadLine tries to return a single line, not including the end-of-line bytes. |
(...skipping 92 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
420 // ReadString reads until the first occurrence of delim in the input, | 387 // ReadString reads until the first occurrence of delim in the input, |
421 // returning a string containing the data up to and including the delimiter. | 388 // returning a string containing the data up to and including the delimiter. |
422 // If ReadString encounters an error before finding a delimiter, | 389 // If ReadString encounters an error before finding a delimiter, |
423 // it returns the data read before the error and the error itself (often io.EOF)
. | 390 // it returns the data read before the error and the error itself (often io.EOF)
. |
424 // ReadString returns err != nil if and only if the returned data does not end i
n | 391 // ReadString returns err != nil if and only if the returned data does not end i
n |
425 // delim. | 392 // delim. |
426 // For simple uses, a Scanner may be more convenient. | 393 // For simple uses, a Scanner may be more convenient. |
427 func (b *Reader) ReadString(delim byte) (line string, err error) { | 394 func (b *Reader) ReadString(delim byte) (line string, err error) { |
428 bytes, err := b.ReadBytes(delim) | 395 bytes, err := b.ReadBytes(delim) |
429 line = string(bytes) | 396 line = string(bytes) |
430 b.putBuf() | |
431 return line, err | 397 return line, err |
432 } | 398 } |
433 | 399 |
434 // WriteTo implements io.WriterTo. | 400 // WriteTo implements io.WriterTo. |
435 func (b *Reader) WriteTo(w io.Writer) (n int64, err error) { | 401 func (b *Reader) WriteTo(w io.Writer) (n int64, err error) { |
436 n, err = b.writeBuf(w) | 402 n, err = b.writeBuf(w) |
437 if err != nil { | 403 if err != nil { |
438 return | 404 return |
439 } | 405 } |
440 | 406 |
(...skipping 15 matching lines...) Expand all Loading... |
456 b.err = nil | 422 b.err = nil |
457 } | 423 } |
458 | 424 |
459 return n, b.readErr() | 425 return n, b.readErr() |
460 } | 426 } |
461 | 427 |
462 // writeBuf writes the Reader's buffer to the writer. | 428 // writeBuf writes the Reader's buffer to the writer. |
463 func (b *Reader) writeBuf(w io.Writer) (int64, error) { | 429 func (b *Reader) writeBuf(w io.Writer) (int64, error) { |
464 n, err := w.Write(b.buf[b.r:b.w]) | 430 n, err := w.Write(b.buf[b.r:b.w]) |
465 b.r += n | 431 b.r += n |
466 b.putBuf() | |
467 return int64(n), err | 432 return int64(n), err |
468 } | 433 } |
469 | 434 |
470 // buffered output | 435 // buffered output |
471 | 436 |
472 // Writer implements buffering for an io.Writer object. | 437 // Writer implements buffering for an io.Writer object. |
473 // If an error occurs writing to a Writer, no more data will be | 438 // If an error occurs writing to a Writer, no more data will be |
474 // accepted and all subsequent writes will return the error. | 439 // accepted and all subsequent writes will return the error. |
475 type Writer struct { | 440 type Writer struct { |
476 » err error | 441 » err error |
477 » buf []byte // either nil or []byte of length bufSize | 442 » buf []byte |
478 » bufSize int | 443 » n int |
479 » n int | 444 » wr io.Writer |
480 » wr io.Writer | |
481 } | 445 } |
482 | 446 |
483 // NewWriterSize returns a new Writer whose buffer has at least the specified | 447 // NewWriterSize returns a new Writer whose buffer has at least the specified |
484 // size. If the argument io.Writer is already a Writer with large enough | 448 // size. If the argument io.Writer is already a Writer with large enough |
485 // size, it returns the underlying Writer. | 449 // size, it returns the underlying Writer. |
486 func NewWriterSize(wr io.Writer, size int) *Writer { | 450 func NewWriterSize(w io.Writer, size int) *Writer { |
487 // Is it already a Writer? | 451 // Is it already a Writer? |
488 » b, ok := wr.(*Writer) | 452 » b, ok := w.(*Writer) |
489 » if ok && b.bufSize >= size { | 453 » if ok && len(b.buf) >= size { |
490 return b | 454 return b |
491 } | 455 } |
492 if size <= 0 { | 456 if size <= 0 { |
493 size = defaultBufSize | 457 size = defaultBufSize |
494 } | 458 } |
495 » b = &Writer{ | 459 » return &Writer{ |
496 » » wr: wr, | 460 » » buf: make([]byte, size), |
497 » » bufSize: size, | 461 » » wr: w, |
498 } | 462 } |
499 if size > defaultBufSize { | |
500 // TODO(bradfitz): make all buffer sizes recycle | |
501 b.buf = make([]byte, b.bufSize) | |
502 } | |
503 return b | |
504 } | 463 } |
505 | 464 |
506 // NewWriter returns a new Writer whose buffer has the default size. | 465 // NewWriter returns a new Writer whose buffer has the default size. |
507 func NewWriter(wr io.Writer) *Writer { | 466 func NewWriter(w io.Writer) *Writer { |
508 » return NewWriterSize(wr, defaultBufSize) | 467 » return NewWriterSize(w, defaultBufSize) |
509 } | 468 } |
510 | 469 |
511 // allocBuf makes b.buf non-nil. | 470 // Reset discards any unflushed buffered data, clears any error, and |
512 func (b *Writer) allocBuf() { | 471 // resets b to write its output to w. |
513 » if b.buf != nil { | 472 func (b *Writer) Reset(w io.Writer) { |
514 » » return | 473 » b.err = nil |
515 » } | 474 » b.n = 0 |
516 » select { | 475 » b.wr = w |
517 » case b.buf = <-bufCache: | |
518 » » b.buf = b.buf[:b.bufSize] | |
519 » default: | |
520 » » b.buf = make([]byte, b.bufSize, defaultBufSize) | |
521 » } | |
522 } | |
523 | |
524 // putBuf returns b.buf if it's unused. | |
525 func (b *Writer) putBuf() { | |
526 » if b.n == 0 && cap(b.buf) == defaultBufSize { | |
527 » » select { | |
528 » » case bufCache <- b.buf: | |
529 » » » b.buf = nil | |
530 » » default: | |
531 » » } | |
532 » } | |
533 } | 476 } |
534 | 477 |
535 // Flush writes any buffered data to the underlying io.Writer. | 478 // Flush writes any buffered data to the underlying io.Writer. |
536 func (b *Writer) Flush() error { | 479 func (b *Writer) Flush() error { |
537 err := b.flush() | 480 err := b.flush() |
538 b.putBuf() | |
539 return err | 481 return err |
540 } | 482 } |
541 | 483 |
542 func (b *Writer) flush() error { | 484 func (b *Writer) flush() error { |
543 if b.err != nil { | 485 if b.err != nil { |
544 return b.err | 486 return b.err |
545 } | 487 } |
546 if b.n == 0 { | 488 if b.n == 0 { |
547 return nil | 489 return nil |
548 } | 490 } |
549 n, err := b.wr.Write(b.buf[0:b.n]) | 491 n, err := b.wr.Write(b.buf[0:b.n]) |
550 if n < b.n && err == nil { | 492 if n < b.n && err == nil { |
551 err = io.ErrShortWrite | 493 err = io.ErrShortWrite |
552 } | 494 } |
553 if err != nil { | 495 if err != nil { |
554 if n > 0 && n < b.n { | 496 if n > 0 && n < b.n { |
555 copy(b.buf[0:b.n-n], b.buf[n:b.n]) | 497 copy(b.buf[0:b.n-n], b.buf[n:b.n]) |
556 } | 498 } |
557 b.n -= n | 499 b.n -= n |
558 b.err = err | 500 b.err = err |
559 return err | 501 return err |
560 } | 502 } |
561 b.n = 0 | 503 b.n = 0 |
562 return nil | 504 return nil |
563 } | 505 } |
564 | 506 |
565 // Available returns how many bytes are unused in the buffer. | 507 // Available returns how many bytes are unused in the buffer. |
566 func (b *Writer) Available() int { return b.bufSize - b.n } | 508 func (b *Writer) Available() int { return len(b.buf) - b.n } |
567 | 509 |
568 // Buffered returns the number of bytes that have been written into the current
buffer. | 510 // Buffered returns the number of bytes that have been written into the current
buffer. |
569 func (b *Writer) Buffered() int { return b.n } | 511 func (b *Writer) Buffered() int { return b.n } |
570 | 512 |
571 // Write writes the contents of p into the buffer. | 513 // Write writes the contents of p into the buffer. |
572 // It returns the number of bytes written. | 514 // It returns the number of bytes written. |
573 // If nn < len(p), it also returns an error explaining | 515 // If nn < len(p), it also returns an error explaining |
574 // why the write is short. | 516 // why the write is short. |
575 func (b *Writer) Write(p []byte) (nn int, err error) { | 517 func (b *Writer) Write(p []byte) (nn int, err error) { |
576 b.allocBuf() | |
577 for len(p) > b.Available() && b.err == nil { | 518 for len(p) > b.Available() && b.err == nil { |
578 var n int | 519 var n int |
579 if b.Buffered() == 0 { | 520 if b.Buffered() == 0 { |
580 // Large write, empty buffer. | 521 // Large write, empty buffer. |
581 // Write directly from p to avoid copy. | 522 // Write directly from p to avoid copy. |
582 n, b.err = b.wr.Write(p) | 523 n, b.err = b.wr.Write(p) |
583 } else { | 524 } else { |
584 n = copy(b.buf[b.n:], p) | 525 n = copy(b.buf[b.n:], p) |
585 b.n += n | 526 b.n += n |
586 b.flush() | 527 b.flush() |
(...skipping 11 matching lines...) Expand all Loading... |
598 } | 539 } |
599 | 540 |
600 // WriteByte writes a single byte. | 541 // WriteByte writes a single byte. |
601 func (b *Writer) WriteByte(c byte) error { | 542 func (b *Writer) WriteByte(c byte) error { |
602 if b.err != nil { | 543 if b.err != nil { |
603 return b.err | 544 return b.err |
604 } | 545 } |
605 if b.Available() <= 0 && b.flush() != nil { | 546 if b.Available() <= 0 && b.flush() != nil { |
606 return b.err | 547 return b.err |
607 } | 548 } |
608 if b.buf == nil { | |
609 b.allocBuf() | |
610 } | |
611 b.buf[b.n] = c | 549 b.buf[b.n] = c |
612 b.n++ | 550 b.n++ |
613 return nil | 551 return nil |
614 } | 552 } |
615 | 553 |
616 // WriteRune writes a single Unicode code point, returning | 554 // WriteRune writes a single Unicode code point, returning |
617 // the number of bytes written and any error. | 555 // the number of bytes written and any error. |
618 func (b *Writer) WriteRune(r rune) (size int, err error) { | 556 func (b *Writer) WriteRune(r rune) (size int, err error) { |
619 if b.buf == nil { | |
620 b.allocBuf() | |
621 } | |
622 if r < utf8.RuneSelf { | 557 if r < utf8.RuneSelf { |
623 err = b.WriteByte(byte(r)) | 558 err = b.WriteByte(byte(r)) |
624 if err != nil { | 559 if err != nil { |
625 return 0, err | 560 return 0, err |
626 } | 561 } |
627 return 1, nil | 562 return 1, nil |
628 } | 563 } |
629 if b.err != nil { | 564 if b.err != nil { |
630 return 0, b.err | 565 return 0, b.err |
631 } | 566 } |
(...skipping 11 matching lines...) Expand all Loading... |
643 size = utf8.EncodeRune(b.buf[b.n:], r) | 578 size = utf8.EncodeRune(b.buf[b.n:], r) |
644 b.n += size | 579 b.n += size |
645 return size, nil | 580 return size, nil |
646 } | 581 } |
647 | 582 |
648 // WriteString writes a string. | 583 // WriteString writes a string. |
649 // It returns the number of bytes written. | 584 // It returns the number of bytes written. |
650 // If the count is less than len(s), it also returns an error explaining | 585 // If the count is less than len(s), it also returns an error explaining |
651 // why the write is short. | 586 // why the write is short. |
652 func (b *Writer) WriteString(s string) (int, error) { | 587 func (b *Writer) WriteString(s string) (int, error) { |
653 b.allocBuf() | |
654 nn := 0 | 588 nn := 0 |
655 for len(s) > b.Available() && b.err == nil { | 589 for len(s) > b.Available() && b.err == nil { |
656 n := copy(b.buf[b.n:], s) | 590 n := copy(b.buf[b.n:], s) |
657 b.n += n | 591 b.n += n |
658 nn += n | 592 nn += n |
659 s = s[n:] | 593 s = s[n:] |
660 b.flush() | 594 b.flush() |
661 } | 595 } |
662 if b.err != nil { | 596 if b.err != nil { |
663 return nn, b.err | 597 return nn, b.err |
664 } | 598 } |
665 n := copy(b.buf[b.n:], s) | 599 n := copy(b.buf[b.n:], s) |
666 b.n += n | 600 b.n += n |
667 nn += n | 601 nn += n |
668 return nn, nil | 602 return nn, nil |
669 } | 603 } |
670 | 604 |
671 // ReadFrom implements io.ReaderFrom. | 605 // ReadFrom implements io.ReaderFrom. |
672 func (b *Writer) ReadFrom(r io.Reader) (n int64, err error) { | 606 func (b *Writer) ReadFrom(r io.Reader) (n int64, err error) { |
673 b.allocBuf() | |
674 if b.Buffered() == 0 { | 607 if b.Buffered() == 0 { |
675 if w, ok := b.wr.(io.ReaderFrom); ok { | 608 if w, ok := b.wr.(io.ReaderFrom); ok { |
676 return w.ReadFrom(r) | 609 return w.ReadFrom(r) |
677 } | 610 } |
678 } | 611 } |
679 var m int | 612 var m int |
680 for { | 613 for { |
681 if b.Available() == 0 { | 614 if b.Available() == 0 { |
682 if err1 := b.flush(); err1 != nil { | 615 if err1 := b.flush(); err1 != nil { |
683 return n, err1 | 616 return n, err1 |
(...skipping 26 matching lines...) Expand all Loading... |
710 // It implements io.ReadWriter. | 643 // It implements io.ReadWriter. |
711 type ReadWriter struct { | 644 type ReadWriter struct { |
712 *Reader | 645 *Reader |
713 *Writer | 646 *Writer |
714 } | 647 } |
715 | 648 |
716 // NewReadWriter allocates a new ReadWriter that dispatches to r and w. | 649 // NewReadWriter allocates a new ReadWriter that dispatches to r and w. |
717 func NewReadWriter(r *Reader, w *Writer) *ReadWriter { | 650 func NewReadWriter(r *Reader, w *Writer) *ReadWriter { |
718 return &ReadWriter{r, w} | 651 return &ReadWriter{r, w} |
719 } | 652 } |
OLD | NEW |