2008-09-12 17:42:53 -06:00
|
|
|
// 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.
|
|
|
|
|
|
|
|
package io
|
2008-11-11 18:28:36 -07:00
|
|
|
|
|
|
|
import (
|
|
|
|
"os";
|
|
|
|
"syscall";
|
|
|
|
)
|
|
|
|
|
2009-01-20 15:40:40 -07:00
|
|
|
var ErrEOF = os.NewError("EOF")
|
2008-09-12 17:42:53 -06:00
|
|
|
|
2009-01-20 15:40:40 -07:00
|
|
|
type Read interface {
|
2008-12-18 23:37:22 -07:00
|
|
|
Read(p []byte) (n int, err *os.Error);
|
2008-09-12 17:42:53 -06:00
|
|
|
}
|
|
|
|
|
2009-01-20 15:40:40 -07:00
|
|
|
type Write interface {
|
2008-12-18 23:37:22 -07:00
|
|
|
Write(p []byte) (n int, err *os.Error);
|
2008-09-12 17:42:53 -06:00
|
|
|
}
|
|
|
|
|
2009-01-20 15:40:40 -07:00
|
|
|
type ReadWrite interface {
|
2008-12-18 23:37:22 -07:00
|
|
|
Read(p []byte) (n int, err *os.Error);
|
|
|
|
Write(p []byte) (n int, err *os.Error);
|
2008-09-17 14:49:23 -06:00
|
|
|
}
|
|
|
|
|
2009-01-20 15:40:40 -07:00
|
|
|
type ReadWriteClose interface {
|
2008-12-18 23:37:22 -07:00
|
|
|
Read(p []byte) (n int, err *os.Error);
|
|
|
|
Write(p []byte) (n int, err *os.Error);
|
2008-10-20 13:37:07 -06:00
|
|
|
Close() *os.Error;
|
|
|
|
}
|
|
|
|
|
2009-02-03 15:16:22 -07:00
|
|
|
type Close interface {
|
|
|
|
Close() *os.Error;
|
|
|
|
}
|
|
|
|
|
2009-02-06 18:54:26 -07:00
|
|
|
// Convert a string to an array of bytes for easy marshaling.
|
|
|
|
// Could fill with syscall.StringToBytes but it adds an unnecessary \000
|
|
|
|
// so the length would be wrong.
|
|
|
|
func StringBytes(s string) []byte {
|
|
|
|
b := make([]byte, len(s));
|
|
|
|
for i := 0; i < len(s); i++ {
|
|
|
|
b[i] = s[i];
|
2008-09-12 17:42:53 -06:00
|
|
|
}
|
2009-02-06 18:54:26 -07:00
|
|
|
return b;
|
|
|
|
}
|
|
|
|
|
|
|
|
func WriteString(w Write, s string) (n int, err *os.Error) {
|
|
|
|
return w.Write(StringBytes(s))
|
2008-09-12 17:42:53 -06:00
|
|
|
}
|
2008-11-11 18:28:36 -07:00
|
|
|
|
2008-11-18 19:45:51 -07:00
|
|
|
// Read until buffer is full, EOF, or error
|
2009-01-20 15:40:40 -07:00
|
|
|
func Readn(fd Read, buf []byte) (n int, err *os.Error) {
|
2008-11-11 18:28:36 -07:00
|
|
|
n = 0;
|
|
|
|
for n < len(buf) {
|
|
|
|
nn, e := fd.Read(buf[n:len(buf)]);
|
|
|
|
if nn > 0 {
|
|
|
|
n += nn
|
|
|
|
}
|
|
|
|
if e != nil {
|
|
|
|
return n, e
|
|
|
|
}
|
|
|
|
if nn <= 0 {
|
|
|
|
return n, ErrEOF // no error but insufficient data
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return n, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// Convert something that implements Read into something
|
|
|
|
// whose Reads are always Readn
|
2009-01-16 13:47:24 -07:00
|
|
|
type _FullRead struct {
|
2008-11-11 18:28:36 -07:00
|
|
|
fd Read;
|
|
|
|
}
|
|
|
|
|
2009-01-16 13:47:24 -07:00
|
|
|
func (fd *_FullRead) Read(p []byte) (n int, err *os.Error) {
|
2008-11-12 20:04:56 -07:00
|
|
|
n, err = Readn(fd.fd, p);
|
2008-11-11 18:28:36 -07:00
|
|
|
return n, err
|
|
|
|
}
|
|
|
|
|
2009-01-20 15:40:40 -07:00
|
|
|
func Make_FullReader(fd Read) Read {
|
2009-01-16 13:47:24 -07:00
|
|
|
if fr, ok := fd.(*_FullRead); ok {
|
|
|
|
// already a _FullRead
|
2008-11-11 18:28:36 -07:00
|
|
|
return fd
|
|
|
|
}
|
2009-02-13 15:48:32 -07:00
|
|
|
return &_FullRead(fd)
|
2008-11-11 18:28:36 -07:00
|
|
|
}
|
2008-11-18 19:08:05 -07:00
|
|
|
|
|
|
|
// Copies n bytes (or until EOF is reached) from src to dst.
|
|
|
|
// Returns the number of bytes copied and the error, if any.
|
2009-01-20 15:40:40 -07:00
|
|
|
func Copyn(src Read, dst Write, n int64) (written int64, err *os.Error) {
|
2009-01-06 16:19:02 -07:00
|
|
|
buf := make([]byte, 32*1024);
|
2008-11-18 19:45:51 -07:00
|
|
|
for written < n {
|
2008-11-19 11:20:52 -07:00
|
|
|
l := len(buf);
|
|
|
|
if d := n - written; d < int64(l) {
|
|
|
|
l = int(d);
|
2008-11-18 19:08:05 -07:00
|
|
|
}
|
|
|
|
nr, er := src.Read(buf[0 : l]);
|
|
|
|
if nr > 0 {
|
|
|
|
nw, ew := dst.Write(buf[0 : nr]);
|
2008-11-18 19:45:51 -07:00
|
|
|
if nw > 0 {
|
|
|
|
written += int64(nw);
|
|
|
|
}
|
|
|
|
if ew != nil {
|
2008-11-18 19:08:05 -07:00
|
|
|
err = ew;
|
|
|
|
break;
|
|
|
|
}
|
2008-11-18 19:45:51 -07:00
|
|
|
if nr != nw {
|
|
|
|
err = os.EIO;
|
|
|
|
break;
|
|
|
|
}
|
2008-11-18 19:08:05 -07:00
|
|
|
}
|
|
|
|
if er != nil {
|
|
|
|
err = er;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if nr == 0 {
|
2008-11-18 19:45:51 -07:00
|
|
|
err = ErrEOF;
|
2008-11-18 19:08:05 -07:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2008-11-18 19:45:51 -07:00
|
|
|
return written, err
|
2008-11-18 19:08:05 -07:00
|
|
|
}
|
2008-11-18 19:45:51 -07:00
|
|
|
|
|
|
|
// Copies from src to dst until EOF is reached.
|
|
|
|
// Returns the number of bytes copied and the error, if any.
|
2009-01-20 15:40:40 -07:00
|
|
|
func Copy(src Read, dst Write) (written int64, err *os.Error) {
|
2009-01-06 16:19:02 -07:00
|
|
|
buf := make([]byte, 32*1024);
|
2008-11-18 19:45:51 -07:00
|
|
|
for {
|
|
|
|
nr, er := src.Read(buf);
|
|
|
|
if nr > 0 {
|
|
|
|
nw, ew := dst.Write(buf[0:nr]);
|
|
|
|
if nw > 0 {
|
|
|
|
written += int64(nw);
|
|
|
|
}
|
|
|
|
if ew != nil {
|
|
|
|
err = ew;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if nr != nw {
|
|
|
|
err = os.EIO;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if er != nil {
|
|
|
|
err = er;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if nr == 0 {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return written, err
|
|
|
|
}
|