...
Run Format

Source file src/io/io.go

     1	// Copyright 2009 The Go Authors. All rights reserved.
     2	// Use of this source code is governed by a BSD-style
     3	// license that can be found in the LICENSE file.
     4	
     5	// Package io provides basic interfaces to I/O primitives.
     6	// Its primary job is to wrap existing implementations of such primitives,
     7	// such as those in package os, into shared public interfaces that
     8	// abstract the functionality, plus some other related primitives.
     9	//
    10	// Because these interfaces and primitives wrap lower-level operations with
    11	// various implementations, unless otherwise informed clients should not
    12	// assume they are safe for parallel execution.
    13	package io
    14	
    15	import (
    16		"errors"
    17	)
    18	
    19	// Seek whence values.
    20	const (
    21		SeekStart   = 0 // seek relative to the origin of the file
    22		SeekCurrent = 1 // seek relative to the current offset
    23		SeekEnd     = 2 // seek relative to the end
    24	)
    25	
    26	// ErrShortWrite means that a write accepted fewer bytes than requested
    27	// but failed to return an explicit error.
    28	var ErrShortWrite = errors.New("short write")
    29	
    30	// ErrShortBuffer means that a read required a longer buffer than was provided.
    31	var ErrShortBuffer = errors.New("short buffer")
    32	
    33	// EOF is the error returned by Read when no more input is available.
    34	// Functions should return EOF only to signal a graceful end of input.
    35	// If the EOF occurs unexpectedly in a structured data stream,
    36	// the appropriate error is either ErrUnexpectedEOF or some other error
    37	// giving more detail.
    38	var EOF = errors.New("EOF")
    39	
    40	// ErrUnexpectedEOF means that EOF was encountered in the
    41	// middle of reading a fixed-size block or data structure.
    42	var ErrUnexpectedEOF = errors.New("unexpected EOF")
    43	
    44	// ErrNoProgress is returned by some clients of an io.Reader when
    45	// many calls to Read have failed to return any data or error,
    46	// usually the sign of a broken io.Reader implementation.
    47	var ErrNoProgress = errors.New("multiple Read calls return no data or error")
    48	
    49	// Reader is the interface that wraps the basic Read method.
    50	//
    51	// Read reads up to len(p) bytes into p. It returns the number of bytes
    52	// read (0 <= n <= len(p)) and any error encountered. Even if Read
    53	// returns n < len(p), it may use all of p as scratch space during the call.
    54	// If some data is available but not len(p) bytes, Read conventionally
    55	// returns what is available instead of waiting for more.
    56	//
    57	// When Read encounters an error or end-of-file condition after
    58	// successfully reading n > 0 bytes, it returns the number of
    59	// bytes read. It may return the (non-nil) error from the same call
    60	// or return the error (and n == 0) from a subsequent call.
    61	// An instance of this general case is that a Reader returning
    62	// a non-zero number of bytes at the end of the input stream may
    63	// return either err == EOF or err == nil. The next Read should
    64	// return 0, EOF.
    65	//
    66	// Callers should always process the n > 0 bytes returned before
    67	// considering the error err. Doing so correctly handles I/O errors
    68	// that happen after reading some bytes and also both of the
    69	// allowed EOF behaviors.
    70	//
    71	// Implementations of Read are discouraged from returning a
    72	// zero byte count with a nil error, except when len(p) == 0.
    73	// Callers should treat a return of 0 and nil as indicating that
    74	// nothing happened; in particular it does not indicate EOF.
    75	//
    76	// Implementations must not retain p.
    77	type Reader interface {
    78		Read(p []byte) (n int, err error)
    79	}
    80	
    81	// Writer is the interface that wraps the basic Write method.
    82	//
    83	// Write writes len(p) bytes from p to the underlying data stream.
    84	// It returns the number of bytes written from p (0 <= n <= len(p))
    85	// and any error encountered that caused the write to stop early.
    86	// Write must return a non-nil error if it returns n < len(p).
    87	// Write must not modify the slice data, even temporarily.
    88	//
    89	// Implementations must not retain p.
    90	type Writer interface {
    91		Write(p []byte) (n int, err error)
    92	}
    93	
    94	// Closer is the interface that wraps the basic Close method.
    95	//
    96	// The behavior of Close after the first call is undefined.
    97	// Specific implementations may document their own behavior.
    98	type Closer interface {
    99		Close() error
   100	}
   101	
   102	// Seeker is the interface that wraps the basic Seek method.
   103	//
   104	// Seek sets the offset for the next Read or Write to offset,
   105	// interpreted according to whence:
   106	// SeekStart means relative to the start of the file,
   107	// SeekCurrent means relative to the current offset, and
   108	// SeekEnd means relative to the end.
   109	// Seek returns the new offset relative to the start of the
   110	// file and an error, if any.
   111	//
   112	// Seeking to an offset before the start of the file is an error.
   113	// Seeking to any positive offset is legal, but the behavior of subsequent
   114	// I/O operations on the underlying object is implementation-dependent.
   115	type Seeker interface {
   116		Seek(offset int64, whence int) (int64, error)
   117	}
   118	
   119	// ReadWriter is the interface that groups the basic Read and Write methods.
   120	type ReadWriter interface {
   121		Reader
   122		Writer
   123	}
   124	
   125	// ReadCloser is the interface that groups the basic Read and Close methods.
   126	type ReadCloser interface {
   127		Reader
   128		Closer
   129	}
   130	
   131	// WriteCloser is the interface that groups the basic Write and Close methods.
   132	type WriteCloser interface {
   133		Writer
   134		Closer
   135	}
   136	
   137	// ReadWriteCloser is the interface that groups the basic Read, Write and Close methods.
   138	type ReadWriteCloser interface {
   139		Reader
   140		Writer
   141		Closer
   142	}
   143	
   144	// ReadSeeker is the interface that groups the basic Read and Seek methods.
   145	type ReadSeeker interface {
   146		Reader
   147		Seeker
   148	}
   149	
   150	// WriteSeeker is the interface that groups the basic Write and Seek methods.
   151	type WriteSeeker interface {
   152		Writer
   153		Seeker
   154	}
   155	
   156	// ReadWriteSeeker is the interface that groups the basic Read, Write and Seek methods.
   157	type ReadWriteSeeker interface {
   158		Reader
   159		Writer
   160		Seeker
   161	}
   162	
   163	// ReaderFrom is the interface that wraps the ReadFrom method.
   164	//
   165	// ReadFrom reads data from r until EOF or error.
   166	// The return value n is the number of bytes read.
   167	// Any error except io.EOF encountered during the read is also returned.
   168	//
   169	// The Copy function uses ReaderFrom if available.
   170	type ReaderFrom interface {
   171		ReadFrom(r Reader) (n int64, err error)
   172	}
   173	
   174	// WriterTo is the interface that wraps the WriteTo method.
   175	//
   176	// WriteTo writes data to w until there's no more data to write or
   177	// when an error occurs. The return value n is the number of bytes
   178	// written. Any error encountered during the write is also returned.
   179	//
   180	// The Copy function uses WriterTo if available.
   181	type WriterTo interface {
   182		WriteTo(w Writer) (n int64, err error)
   183	}
   184	
   185	// ReaderAt is the interface that wraps the basic ReadAt method.
   186	//
   187	// ReadAt reads len(p) bytes into p starting at offset off in the
   188	// underlying input source. It returns the number of bytes
   189	// read (0 <= n <= len(p)) and any error encountered.
   190	//
   191	// When ReadAt returns n < len(p), it returns a non-nil error
   192	// explaining why more bytes were not returned. In this respect,
   193	// ReadAt is stricter than Read.
   194	//
   195	// Even if ReadAt returns n < len(p), it may use all of p as scratch
   196	// space during the call. If some data is available but not len(p) bytes,
   197	// ReadAt blocks until either all the data is available or an error occurs.
   198	// In this respect ReadAt is different from Read.
   199	//
   200	// If the n = len(p) bytes returned by ReadAt are at the end of the
   201	// input source, ReadAt may return either err == EOF or err == nil.
   202	//
   203	// If ReadAt is reading from an input source with a seek offset,
   204	// ReadAt should not affect nor be affected by the underlying
   205	// seek offset.
   206	//
   207	// Clients of ReadAt can execute parallel ReadAt calls on the
   208	// same input source.
   209	//
   210	// Implementations must not retain p.
   211	type ReaderAt interface {
   212		ReadAt(p []byte, off int64) (n int, err error)
   213	}
   214	
   215	// WriterAt is the interface that wraps the basic WriteAt method.
   216	//
   217	// WriteAt writes len(p) bytes from p to the underlying data stream
   218	// at offset off. It returns the number of bytes written from p (0 <= n <= len(p))
   219	// and any error encountered that caused the write to stop early.
   220	// WriteAt must return a non-nil error if it returns n < len(p).
   221	//
   222	// If WriteAt is writing to a destination with a seek offset,
   223	// WriteAt should not affect nor be affected by the underlying
   224	// seek offset.
   225	//
   226	// Clients of WriteAt can execute parallel WriteAt calls on the same
   227	// destination if the ranges do not overlap.
   228	//
   229	// Implementations must not retain p.
   230	type WriterAt interface {
   231		WriteAt(p []byte, off int64) (n int, err error)
   232	}
   233	
   234	// ByteReader is the interface that wraps the ReadByte method.
   235	//
   236	// ReadByte reads and returns the next byte from the input.
   237	type ByteReader interface {
   238		ReadByte() (byte, error)
   239	}
   240	
   241	// ByteScanner is the interface that adds the UnreadByte method to the
   242	// basic ReadByte method.
   243	//
   244	// UnreadByte causes the next call to ReadByte to return the same byte
   245	// as the previous call to ReadByte.
   246	// It may be an error to call UnreadByte twice without an intervening
   247	// call to ReadByte.
   248	type ByteScanner interface {
   249		ByteReader
   250		UnreadByte() error
   251	}
   252	
   253	// ByteWriter is the interface that wraps the WriteByte method.
   254	type ByteWriter interface {
   255		WriteByte(c byte) error
   256	}
   257	
   258	// RuneReader is the interface that wraps the ReadRune method.
   259	//
   260	// ReadRune reads a single UTF-8 encoded Unicode character
   261	// and returns the rune and its size in bytes. If no character is
   262	// available, err will be set.
   263	type RuneReader interface {
   264		ReadRune() (r rune, size int, err error)
   265	}
   266	
   267	// RuneScanner is the interface that adds the UnreadRune method to the
   268	// basic ReadRune method.
   269	//
   270	// UnreadRune causes the next call to ReadRune to return the same rune
   271	// as the previous call to ReadRune.
   272	// It may be an error to call UnreadRune twice without an intervening
   273	// call to ReadRune.
   274	type RuneScanner interface {
   275		RuneReader
   276		UnreadRune() error
   277	}
   278	
   279	// stringWriter is the interface that wraps the WriteString method.
   280	type stringWriter interface {
   281		WriteString(s string) (n int, err error)
   282	}
   283	
   284	// WriteString writes the contents of the string s to w, which accepts a slice of bytes.
   285	// If w implements a WriteString method, it is invoked directly.
   286	// Otherwise, w.Write is called exactly once.
   287	func WriteString(w Writer, s string) (n int, err error) {
   288		if sw, ok := w.(stringWriter); ok {
   289			return sw.WriteString(s)
   290		}
   291		return w.Write([]byte(s))
   292	}
   293	
   294	// ReadAtLeast reads from r into buf until it has read at least min bytes.
   295	// It returns the number of bytes copied and an error if fewer bytes were read.
   296	// The error is EOF only if no bytes were read.
   297	// If an EOF happens after reading fewer than min bytes,
   298	// ReadAtLeast returns ErrUnexpectedEOF.
   299	// If min is greater than the length of buf, ReadAtLeast returns ErrShortBuffer.
   300	// On return, n >= min if and only if err == nil.
   301	func ReadAtLeast(r Reader, buf []byte, min int) (n int, err error) {
   302		if len(buf) < min {
   303			return 0, ErrShortBuffer
   304		}
   305		for n < min && err == nil {
   306			var nn int
   307			nn, err = r.Read(buf[n:])
   308			n += nn
   309		}
   310		if n >= min {
   311			err = nil
   312		} else if n > 0 && err == EOF {
   313			err = ErrUnexpectedEOF
   314		}
   315		return
   316	}
   317	
   318	// ReadFull reads exactly len(buf) bytes from r into buf.
   319	// It returns the number of bytes copied and an error if fewer bytes were read.
   320	// The error is EOF only if no bytes were read.
   321	// If an EOF happens after reading some but not all the bytes,
   322	// ReadFull returns ErrUnexpectedEOF.
   323	// On return, n == len(buf) if and only if err == nil.
   324	func ReadFull(r Reader, buf []byte) (n int, err error) {
   325		return ReadAtLeast(r, buf, len(buf))
   326	}
   327	
   328	// CopyN copies n bytes (or until an error) from src to dst.
   329	// It returns the number of bytes copied and the earliest
   330	// error encountered while copying.
   331	// On return, written == n if and only if err == nil.
   332	//
   333	// If dst implements the ReaderFrom interface,
   334	// the copy is implemented using it.
   335	func CopyN(dst Writer, src Reader, n int64) (written int64, err error) {
   336		written, err = Copy(dst, LimitReader(src, n))
   337		if written == n {
   338			return n, nil
   339		}
   340		if written < n && err == nil {
   341			// src stopped early; must have been EOF.
   342			err = EOF
   343		}
   344		return
   345	}
   346	
   347	// Copy copies from src to dst until either EOF is reached
   348	// on src or an error occurs. It returns the number of bytes
   349	// copied and the first error encountered while copying, if any.
   350	//
   351	// A successful Copy returns err == nil, not err == EOF.
   352	// Because Copy is defined to read from src until EOF, it does
   353	// not treat an EOF from Read as an error to be reported.
   354	//
   355	// If src implements the WriterTo interface,
   356	// the copy is implemented by calling src.WriteTo(dst).
   357	// Otherwise, if dst implements the ReaderFrom interface,
   358	// the copy is implemented by calling dst.ReadFrom(src).
   359	func Copy(dst Writer, src Reader) (written int64, err error) {
   360		return copyBuffer(dst, src, nil)
   361	}
   362	
   363	// CopyBuffer is identical to Copy except that it stages through the
   364	// provided buffer (if one is required) rather than allocating a
   365	// temporary one. If buf is nil, one is allocated; otherwise if it has
   366	// zero length, CopyBuffer panics.
   367	func CopyBuffer(dst Writer, src Reader, buf []byte) (written int64, err error) {
   368		if buf != nil && len(buf) == 0 {
   369			panic("empty buffer in io.CopyBuffer")
   370		}
   371		return copyBuffer(dst, src, buf)
   372	}
   373	
   374	// copyBuffer is the actual implementation of Copy and CopyBuffer.
   375	// if buf is nil, one is allocated.
   376	func copyBuffer(dst Writer, src Reader, buf []byte) (written int64, err error) {
   377		// If the reader has a WriteTo method, use it to do the copy.
   378		// Avoids an allocation and a copy.
   379		if wt, ok := src.(WriterTo); ok {
   380			return wt.WriteTo(dst)
   381		}
   382		// Similarly, if the writer has a ReadFrom method, use it to do the copy.
   383		if rt, ok := dst.(ReaderFrom); ok {
   384			return rt.ReadFrom(src)
   385		}
   386		if buf == nil {
   387			buf = make([]byte, 32*1024)
   388		}
   389		for {
   390			nr, er := src.Read(buf)
   391			if nr > 0 {
   392				nw, ew := dst.Write(buf[0:nr])
   393				if nw > 0 {
   394					written += int64(nw)
   395				}
   396				if ew != nil {
   397					err = ew
   398					break
   399				}
   400				if nr != nw {
   401					err = ErrShortWrite
   402					break
   403				}
   404			}
   405			if er == EOF {
   406				break
   407			}
   408			if er != nil {
   409				err = er
   410				break
   411			}
   412		}
   413		return written, err
   414	}
   415	
   416	// LimitReader returns a Reader that reads from r
   417	// but stops with EOF after n bytes.
   418	// The underlying implementation is a *LimitedReader.
   419	func LimitReader(r Reader, n int64) Reader { return &LimitedReader{r, n} }
   420	
   421	// A LimitedReader reads from R but limits the amount of
   422	// data returned to just N bytes. Each call to Read
   423	// updates N to reflect the new amount remaining.
   424	type LimitedReader struct {
   425		R Reader // underlying reader
   426		N int64  // max bytes remaining
   427	}
   428	
   429	func (l *LimitedReader) Read(p []byte) (n int, err error) {
   430		if l.N <= 0 {
   431			return 0, EOF
   432		}
   433		if int64(len(p)) > l.N {
   434			p = p[0:l.N]
   435		}
   436		n, err = l.R.Read(p)
   437		l.N -= int64(n)
   438		return
   439	}
   440	
   441	// NewSectionReader returns a SectionReader that reads from r
   442	// starting at offset off and stops with EOF after n bytes.
   443	func NewSectionReader(r ReaderAt, off int64, n int64) *SectionReader {
   444		return &SectionReader{r, off, off, off + n}
   445	}
   446	
   447	// SectionReader implements Read, Seek, and ReadAt on a section
   448	// of an underlying ReaderAt.
   449	type SectionReader struct {
   450		r     ReaderAt
   451		base  int64
   452		off   int64
   453		limit int64
   454	}
   455	
   456	func (s *SectionReader) Read(p []byte) (n int, err error) {
   457		if s.off >= s.limit {
   458			return 0, EOF
   459		}
   460		if max := s.limit - s.off; int64(len(p)) > max {
   461			p = p[0:max]
   462		}
   463		n, err = s.r.ReadAt(p, s.off)
   464		s.off += int64(n)
   465		return
   466	}
   467	
   468	var errWhence = errors.New("Seek: invalid whence")
   469	var errOffset = errors.New("Seek: invalid offset")
   470	
   471	func (s *SectionReader) Seek(offset int64, whence int) (int64, error) {
   472		switch whence {
   473		default:
   474			return 0, errWhence
   475		case SeekStart:
   476			offset += s.base
   477		case SeekCurrent:
   478			offset += s.off
   479		case SeekEnd:
   480			offset += s.limit
   481		}
   482		if offset < s.base {
   483			return 0, errOffset
   484		}
   485		s.off = offset
   486		return offset - s.base, nil
   487	}
   488	
   489	func (s *SectionReader) ReadAt(p []byte, off int64) (n int, err error) {
   490		if off < 0 || off >= s.limit-s.base {
   491			return 0, EOF
   492		}
   493		off += s.base
   494		if max := s.limit - off; int64(len(p)) > max {
   495			p = p[0:max]
   496			n, err = s.r.ReadAt(p, off)
   497			if err == nil {
   498				err = EOF
   499			}
   500			return n, err
   501		}
   502		return s.r.ReadAt(p, off)
   503	}
   504	
   505	// Size returns the size of the section in bytes.
   506	func (s *SectionReader) Size() int64 { return s.limit - s.base }
   507	
   508	// TeeReader returns a Reader that writes to w what it reads from r.
   509	// All reads from r performed through it are matched with
   510	// corresponding writes to w. There is no internal buffering -
   511	// the write must complete before the read completes.
   512	// Any error encountered while writing is reported as a read error.
   513	func TeeReader(r Reader, w Writer) Reader {
   514		return &teeReader{r, w}
   515	}
   516	
   517	type teeReader struct {
   518		r Reader
   519		w Writer
   520	}
   521	
   522	func (t *teeReader) Read(p []byte) (n int, err error) {
   523		n, err = t.r.Read(p)
   524		if n > 0 {
   525			if n, err := t.w.Write(p[:n]); err != nil {
   526				return n, err
   527			}
   528		}
   529		return
   530	}
   531	

View as plain text