...
Run Format

Source file src/io/ioutil/ioutil.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 ioutil implements some I/O utility functions.
     6	package ioutil
     7	
     8	import (
     9		"bytes"
    10		"io"
    11		"os"
    12		"sort"
    13		"sync"
    14	)
    15	
    16	// readAll reads from r until an error or EOF and returns the data it read
    17	// from the internal buffer allocated with a specified capacity.
    18	func readAll(r io.Reader, capacity int64) (b []byte, err error) {
    19		buf := bytes.NewBuffer(make([]byte, 0, capacity))
    20		// If the buffer overflows, we will get bytes.ErrTooLarge.
    21		// Return that as an error. Any other panic remains.
    22		defer func() {
    23			e := recover()
    24			if e == nil {
    25				return
    26			}
    27			if panicErr, ok := e.(error); ok && panicErr == bytes.ErrTooLarge {
    28				err = panicErr
    29			} else {
    30				panic(e)
    31			}
    32		}()
    33		_, err = buf.ReadFrom(r)
    34		return buf.Bytes(), err
    35	}
    36	
    37	// ReadAll reads from r until an error or EOF and returns the data it read.
    38	// A successful call returns err == nil, not err == EOF. Because ReadAll is
    39	// defined to read from src until EOF, it does not treat an EOF from Read
    40	// as an error to be reported.
    41	func ReadAll(r io.Reader) ([]byte, error) {
    42		return readAll(r, bytes.MinRead)
    43	}
    44	
    45	// ReadFile reads the file named by filename and returns the contents.
    46	// A successful call returns err == nil, not err == EOF. Because ReadFile
    47	// reads the whole file, it does not treat an EOF from Read as an error
    48	// to be reported.
    49	func ReadFile(filename string) ([]byte, error) {
    50		f, err := os.Open(filename)
    51		if err != nil {
    52			return nil, err
    53		}
    54		defer f.Close()
    55		// It's a good but not certain bet that FileInfo will tell us exactly how much to
    56		// read, so let's try it but be prepared for the answer to be wrong.
    57		var n int64
    58	
    59		if fi, err := f.Stat(); err == nil {
    60			// Don't preallocate a huge buffer, just in case.
    61			if size := fi.Size(); size < 1e9 {
    62				n = size
    63			}
    64		}
    65		// As initial capacity for readAll, use n + a little extra in case Size is zero,
    66		// and to avoid another allocation after Read has filled the buffer. The readAll
    67		// call will read into its allocated internal buffer cheaply. If the size was
    68		// wrong, we'll either waste some space off the end or reallocate as needed, but
    69		// in the overwhelmingly common case we'll get it just right.
    70		return readAll(f, n+bytes.MinRead)
    71	}
    72	
    73	// WriteFile writes data to a file named by filename.
    74	// If the file does not exist, WriteFile creates it with permissions perm;
    75	// otherwise WriteFile truncates it before writing.
    76	func WriteFile(filename string, data []byte, perm os.FileMode) error {
    77		f, err := os.OpenFile(filename, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, perm)
    78		if err != nil {
    79			return err
    80		}
    81		n, err := f.Write(data)
    82		if err == nil && n < len(data) {
    83			err = io.ErrShortWrite
    84		}
    85		if err1 := f.Close(); err == nil {
    86			err = err1
    87		}
    88		return err
    89	}
    90	
    91	// ReadDir reads the directory named by dirname and returns
    92	// a list of directory entries sorted by filename.
    93	func ReadDir(dirname string) ([]os.FileInfo, error) {
    94		f, err := os.Open(dirname)
    95		if err != nil {
    96			return nil, err
    97		}
    98		list, err := f.Readdir(-1)
    99		f.Close()
   100		if err != nil {
   101			return nil, err
   102		}
   103		sort.Slice(list, func(i, j int) bool { return list[i].Name() < list[j].Name() })
   104		return list, nil
   105	}
   106	
   107	type nopCloser struct {
   108		io.Reader
   109	}
   110	
   111	func (nopCloser) Close() error { return nil }
   112	
   113	// NopCloser returns a ReadCloser with a no-op Close method wrapping
   114	// the provided Reader r.
   115	func NopCloser(r io.Reader) io.ReadCloser {
   116		return nopCloser{r}
   117	}
   118	
   119	type devNull int
   120	
   121	// devNull implements ReaderFrom as an optimization so io.Copy to
   122	// ioutil.Discard can avoid doing unnecessary work.
   123	var _ io.ReaderFrom = devNull(0)
   124	
   125	func (devNull) Write(p []byte) (int, error) {
   126		return len(p), nil
   127	}
   128	
   129	func (devNull) WriteString(s string) (int, error) {
   130		return len(s), nil
   131	}
   132	
   133	var blackHolePool = sync.Pool{
   134		New: func() interface{} {
   135			b := make([]byte, 8192)
   136			return &b
   137		},
   138	}
   139	
   140	func (devNull) ReadFrom(r io.Reader) (n int64, err error) {
   141		bufp := blackHolePool.Get().(*[]byte)
   142		readSize := 0
   143		for {
   144			readSize, err = r.Read(*bufp)
   145			n += int64(readSize)
   146			if err != nil {
   147				blackHolePool.Put(bufp)
   148				if err == io.EOF {
   149					return n, nil
   150				}
   151				return
   152			}
   153		}
   154	}
   155	
   156	// Discard is an io.Writer on which all Write calls succeed
   157	// without doing anything.
   158	var Discard io.Writer = devNull(0)
   159	

View as plain text