LEFT | RIGHT |
(no file at all) | |
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 551 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
562 return nn, b.err | 562 return nn, b.err |
563 } | 563 } |
564 n := copy(b.buf[b.n:], s) | 564 n := copy(b.buf[b.n:], s) |
565 b.n += n | 565 b.n += n |
566 nn += n | 566 nn += n |
567 return nn, nil | 567 return nn, nil |
568 } | 568 } |
569 | 569 |
570 // ReadFrom implements io.ReaderFrom. | 570 // ReadFrom implements io.ReaderFrom. |
571 func (b *Writer) ReadFrom(r io.Reader) (n int64, err error) { | 571 func (b *Writer) ReadFrom(r io.Reader) (n int64, err error) { |
572 » if b.Buffered() == 0 { | 572 » fillFlush := func() error { |
573 » » if w, ok := b.wr.(io.ReaderFrom); ok { | 573 » » m, err := io.ReadFull(r, b.buf[b.n:]) |
574 » » » return w.ReadFrom(r) | |
575 » » } | |
576 » } | |
577 » var m int | |
578 » for { | |
579 » » m, err = r.Read(b.buf[b.n:]) | |
580 » » if m == 0 { | |
581 » » » break | |
582 » » } | |
583 b.n += m | 574 b.n += m |
584 n += int64(m) | 575 n += int64(m) |
585 if b.Available() == 0 { | 576 if b.Available() == 0 { |
586 if err1 := b.Flush(); err1 != nil { | 577 if err1 := b.Flush(); err1 != nil { |
587 » » » » return n, err1 | 578 » » » » return err1 |
588 } | 579 } |
589 } | 580 } |
590 » » if err != nil { | 581 » » return err |
591 » » » break | 582 » } |
592 » » } | 583 » if w, ok := b.wr.(io.ReaderFrom); ok { |
593 » } | 584 » » // Want to call Write with a full buffer, so |
594 » if err == io.EOF { | 585 » » // if the buffer has data in it, fill it then use ReadFrom inste
ad |
| 586 » » // of flushing immediately |
| 587 » » if b.Buffered() != 0 { |
| 588 » » » err = fillFlush() |
| 589 » » } |
| 590 » » if err == nil { |
| 591 » » » var m int64 |
| 592 » » » m, err = w.ReadFrom(r) |
| 593 » » » return n + m, err |
| 594 » » } |
| 595 » } else { |
| 596 » » for { |
| 597 » » » if err = fillFlush(); err != nil { |
| 598 » » » » break |
| 599 » » » } |
| 600 » » } |
| 601 » } |
| 602 » // Don't care that we didn't read the entire buf, so |
| 603 » // unexpected EOF should be treated the same as EOF |
| 604 » if err == io.EOF || err == io.ErrUnexpectedEOF { |
595 err = nil | 605 err = nil |
596 } | 606 } |
597 » return n, err | 607 » return |
598 } | 608 } |
599 | 609 |
600 // buffered input and output | 610 // buffered input and output |
601 | 611 |
602 // ReadWriter stores pointers to a Reader and a Writer. | 612 // ReadWriter stores pointers to a Reader and a Writer. |
603 // It implements io.ReadWriter. | 613 // It implements io.ReadWriter. |
604 type ReadWriter struct { | 614 type ReadWriter struct { |
605 *Reader | 615 *Reader |
606 *Writer | 616 *Writer |
607 } | 617 } |
608 | 618 |
609 // NewReadWriter allocates a new ReadWriter that dispatches to r and w. | 619 // NewReadWriter allocates a new ReadWriter that dispatches to r and w. |
610 func NewReadWriter(r *Reader, w *Writer) *ReadWriter { | 620 func NewReadWriter(r *Reader, w *Writer) *ReadWriter { |
611 return &ReadWriter{r, w} | 621 return &ReadWriter{r, w} |
612 } | 622 } |
LEFT | RIGHT |