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