Rietveld Code Review Tool
Help | Bug tracker | Discussion group | Source code | Sign in
(2149)

Side by Side Diff: src/pkg/bufio/bufio.go

Issue 12603049: code review 12603049: bufio: drop Writer and Reset buffer recycling, add Rese... (Closed)
Patch Set: diff -r 4f468b088d66 https://go.googlecode.com/hg/ Created 10 years, 7 months ago
Left:
Right:
Use n/p to move between diff chunks; N/P to move between comments. Please Sign in to add in-line comments.
Jump to:
View unified diff | Download patch
« no previous file with comments | « no previous file | src/pkg/bufio/bufio_test.go » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
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
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
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
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
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
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
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
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
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
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
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 }
OLDNEW
« no previous file with comments | « no previous file | src/pkg/bufio/bufio_test.go » ('j') | no next file with comments »

Powered by Google App Engine
RSS Feeds Recent Issues | This issue
This is Rietveld f62528b