| // Copyright 2009 The Go Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file. |
| |
| // Utility functions. |
| |
| package ioutil |
| |
| import ( |
| "bytes" |
| "io" |
| "os" |
| "sort" |
| ) |
| |
| // ReadAll reads from r until an error or EOF and returns the data it read. |
| func ReadAll(r io.Reader) ([]byte, os.Error) { |
| var buf bytes.Buffer |
| _, err := io.Copy(&buf, r) |
| return buf.Bytes(), err |
| } |
| |
| // ReadFile reads the file named by filename and returns the contents. |
| func ReadFile(filename string) ([]byte, os.Error) { |
| f, err := os.Open(filename, os.O_RDONLY, 0) |
| if err != nil { |
| return nil, err |
| } |
| defer f.Close() |
| // It's a good but not certain bet that Stat will tell us exactly how much to |
| // read, so let's try it but be prepared for the answer to be wrong. |
| dir, err := f.Stat() |
| var n uint64 |
| if err != nil && dir.Size < 2e9 { // Don't preallocate a huge buffer, just in case. |
| n = dir.Size |
| } |
| // Add a little extra in case Size is zero, and to avoid another allocation after |
| // Read has filled the buffer. |
| n += bytes.MinRead |
| // Pre-allocate the correct size of buffer, then set its size to zero. The |
| // Buffer will read into the allocated space cheaply. If the size was wrong, |
| // we'll either waste some space off the end or reallocate as needed, but |
| // in the overwhelmingly common case we'll get it just right. |
| buf := bytes.NewBuffer(make([]byte, 0, n)) |
| _, err = buf.ReadFrom(f) |
| return buf.Bytes(), err |
| } |
| |
| // WriteFile writes data to a file named by filename. |
| // If the file does not exist, WriteFile creates it with permissions perm; |
| // otherwise WriteFile truncates it before writing. |
| func WriteFile(filename string, data []byte, perm int) os.Error { |
| f, err := os.Open(filename, os.O_WRONLY|os.O_CREAT|os.O_TRUNC, perm) |
| if err != nil { |
| return err |
| } |
| n, err := f.Write(data) |
| f.Close() |
| if err == nil && n < len(data) { |
| err = io.ErrShortWrite |
| } |
| return err |
| } |
| |
| // A dirList implements sort.Interface. |
| type dirList []*os.Dir |
| |
| func (d dirList) Len() int { return len(d) } |
| func (d dirList) Less(i, j int) bool { return d[i].Name < d[j].Name } |
| func (d dirList) Swap(i, j int) { d[i], d[j] = d[j], d[i] } |
| |
| // ReadDir reads the directory named by dirname and returns |
| // a list of sorted directory entries. |
| func ReadDir(dirname string) ([]*os.Dir, os.Error) { |
| f, err := os.Open(dirname, os.O_RDONLY, 0) |
| if err != nil { |
| return nil, err |
| } |
| list, err := f.Readdir(-1) |
| f.Close() |
| if err != nil { |
| return nil, err |
| } |
| dirs := make(dirList, len(list)) |
| for i := range list { |
| dirs[i] = &list[i] |
| } |
| sort.Sort(dirs) |
| return dirs, nil |
| } |