diff options
Diffstat (limited to 'libgo/go/io/io.go')
| -rw-r--r-- | libgo/go/io/io.go | 48 |
1 files changed, 29 insertions, 19 deletions
diff --git a/libgo/go/io/io.go b/libgo/go/io/io.go index 8e7855c..19d0ae5 100644 --- a/libgo/go/io/io.go +++ b/libgo/go/io/io.go @@ -16,6 +16,13 @@ import ( "errors" ) +// Seek whence values. +const ( + SeekStart = 0 // seek relative to the origin of the file + SeekCurrent = 1 // seek relative to the current offset + SeekEnd = 2 // seek relative to the end +) + // ErrShortWrite means that a write accepted fewer bytes than requested // but failed to return an explicit error. var ErrShortWrite = errors.New("short write") @@ -41,23 +48,23 @@ var ErrNoProgress = errors.New("multiple Read calls return no data or error") // Reader is the interface that wraps the basic Read method. // -// Read reads up to len(p) bytes into p. It returns the number of bytes -// read (0 <= n <= len(p)) and any error encountered. Even if Read +// Read reads up to len(p) bytes into p. It returns the number of bytes +// read (0 <= n <= len(p)) and any error encountered. Even if Read // returns n < len(p), it may use all of p as scratch space during the call. // If some data is available but not len(p) bytes, Read conventionally // returns what is available instead of waiting for more. // // When Read encounters an error or end-of-file condition after // successfully reading n > 0 bytes, it returns the number of -// bytes read. It may return the (non-nil) error from the same call +// bytes read. It may return the (non-nil) error from the same call // or return the error (and n == 0) from a subsequent call. // An instance of this general case is that a Reader returning // a non-zero number of bytes at the end of the input stream may -// return either err == EOF or err == nil. The next Read should +// return either err == EOF or err == nil. The next Read should // return 0, EOF. // // Callers should always process the n > 0 bytes returned before -// considering the error err. Doing so correctly handles I/O errors +// considering the error err. Doing so correctly handles I/O errors // that happen after reading some bytes and also both of the // allowed EOF behaviors. // @@ -95,10 +102,12 @@ type Closer interface { // Seeker is the interface that wraps the basic Seek method. // // Seek sets the offset for the next Read or Write to offset, -// interpreted according to whence: 0 means relative to the start of -// the file, 1 means relative to the current offset, and 2 means -// relative to the end. Seek returns the new offset relative to the -// start of the file and an error, if any. +// interpreted according to whence: +// SeekStart means relative to the start of the file, +// SeekCurrent means relative to the current offset, and +// SeekEnd means relative to the end. +// Seek returns the new offset relative to the start of the +// file and an error, if any. // // Seeking to an offset before the start of the file is an error. // Seeking to any positive offset is legal, but the behavior of subsequent @@ -176,15 +185,15 @@ type WriterTo interface { // ReaderAt is the interface that wraps the basic ReadAt method. // // ReadAt reads len(p) bytes into p starting at offset off in the -// underlying input source. It returns the number of bytes +// underlying input source. It returns the number of bytes // read (0 <= n <= len(p)) and any error encountered. // // When ReadAt returns n < len(p), it returns a non-nil error -// explaining why more bytes were not returned. In this respect, +// explaining why more bytes were not returned. In this respect, // ReadAt is stricter than Read. // // Even if ReadAt returns n < len(p), it may use all of p as scratch -// space during the call. If some data is available but not len(p) bytes, +// space during the call. If some data is available but not len(p) bytes, // ReadAt blocks until either all the data is available or an error occurs. // In this respect ReadAt is different from Read. // @@ -206,7 +215,7 @@ type ReaderAt interface { // WriterAt is the interface that wraps the basic WriteAt method. // // WriteAt writes len(p) bytes from p to the underlying data stream -// at offset off. It returns the number of bytes written from p (0 <= n <= len(p)) +// at offset off. It returns the number of bytes written from p (0 <= n <= len(p)) // and any error encountered that caused the write to stop early. // WriteAt must return a non-nil error if it returns n < len(p). // @@ -226,7 +235,7 @@ type WriterAt interface { // // ReadByte reads and returns the next byte from the input. type ByteReader interface { - ReadByte() (c byte, err error) + ReadByte() (byte, error) } // ByteScanner is the interface that adds the UnreadByte method to the @@ -274,6 +283,7 @@ type stringWriter interface { // WriteString writes the contents of the string s to w, which accepts a slice of bytes. // If w implements a WriteString method, it is invoked directly. +// Otherwise, w.Write is called exactly once. func WriteString(w Writer, s string) (n int, err error) { if sw, ok := w.(stringWriter); ok { return sw.WriteString(s) @@ -335,7 +345,7 @@ func CopyN(dst Writer, src Reader, n int64) (written int64, err error) { } // Copy copies from src to dst until either EOF is reached -// on src or an error occurs. It returns the number of bytes +// on src or an error occurs. It returns the number of bytes // copied and the first error encountered while copying, if any. // // A successful Copy returns err == nil, not err == EOF. @@ -462,11 +472,11 @@ func (s *SectionReader) Seek(offset int64, whence int) (int64, error) { switch whence { default: return 0, errWhence - case 0: + case SeekStart: offset += s.base - case 1: + case SeekCurrent: offset += s.off - case 2: + case SeekEnd: offset += s.limit } if offset < s.base { @@ -497,7 +507,7 @@ func (s *SectionReader) Size() int64 { return s.limit - s.base } // TeeReader returns a Reader that writes to w what it reads from r. // All reads from r performed through it are matched with -// corresponding writes to w. There is no internal buffering - +// corresponding writes to w. There is no internal buffering - // the write must complete before the read completes. // Any error encountered while writing is reported as a read error. func TeeReader(r Reader, w Writer) Reader { |