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.
5 // Package ioutil implements some I/O utility functions.
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.
27 if panicErr
, ok
:= e
.(error
); ok
&& panicErr
== bytes
.ErrTooLarge
{
33 _
, err
= buf
.ReadFrom(r
)
34 return buf
.Bytes(), err
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
)
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
49 func ReadFile(filename
string) ([]byte, error
) {
50 f
, err
:= os
.Open(filename
)
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.
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
{
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
)
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
)
81 n
, err
:= f
.Write(data
)
82 if err
== nil && n
< len(data
) {
83 err
= io
.ErrShortWrite
85 if err1
:= f
.Close(); err
== nil {
91 // byName implements sort.Interface.
92 type byName
[]os
.FileInfo
94 func (f byName
) Len() int { return len(f
) }
95 func (f byName
) Less(i
, j
int) bool { return f
[i
].Name() < f
[j
].Name() }
96 func (f byName
) Swap(i
, j
int) { f
[i
], f
[j
] = f
[j
], f
[i
] }
98 // ReadDir reads the directory named by dirname and returns
99 // a list of sorted directory entries.
100 func ReadDir(dirname
string) ([]os
.FileInfo
, error
) {
101 f
, err
:= os
.Open(dirname
)
105 list
, err
:= f
.Readdir(-1)
110 sort
.Sort(byName(list
))
114 type nopCloser
struct {
118 func (nopCloser
) Close() error
{ return nil }
120 // NopCloser returns a ReadCloser with a no-op Close method wrapping
121 // the provided Reader r.
122 func NopCloser(r io
.Reader
) io
.ReadCloser
{
128 // devNull implements ReaderFrom as an optimization so io.Copy to
129 // ioutil.Discard can avoid doing unnecessary work.
130 var _ io
.ReaderFrom
= devNull(0)
132 func (devNull
) Write(p
[]byte) (int, error
) {
136 func (devNull
) WriteString(s
string) (int, error
) {
140 var blackHolePool
= sync
.Pool
{
141 New
: func() interface{} {
142 b
:= make([]byte, 8192)
147 func (devNull
) ReadFrom(r io
.Reader
) (n
int64, err error
) {
148 bufp
:= blackHolePool
.Get().(*[]byte)
151 readSize
, err
= r
.Read(*bufp
)
154 blackHolePool
.Put(bufp
)
163 // Discard is an io.Writer on which all Write calls succeed
164 // without doing anything.
165 var Discard io
.Writer
= devNull(0)