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";
|
|
|
|
)
|
|
|
|
|
|
|
|
export var ErrEOF = os.NewError("EOF")
|
2008-09-12 17:42:53 -06:00
|
|
|
|
|
|
|
export type Read interface {
|
|
|
|
Read(p *[]byte) (n int, err *os.Error);
|
|
|
|
}
|
|
|
|
|
|
|
|
export type Write interface {
|
|
|
|
Write(p *[]byte) (n int, err *os.Error);
|
|
|
|
}
|
|
|
|
|
2008-09-17 14:49:23 -06:00
|
|
|
export type ReadWrite interface {
|
|
|
|
Read(p *[]byte) (n int, err *os.Error);
|
|
|
|
Write(p *[]byte) (n int, err *os.Error);
|
|
|
|
}
|
|
|
|
|
2008-10-20 13:37:07 -06:00
|
|
|
export type ReadWriteClose interface {
|
|
|
|
Read(p *[]byte) (n int, err *os.Error);
|
|
|
|
Write(p *[]byte) (n int, err *os.Error);
|
|
|
|
Close() *os.Error;
|
|
|
|
}
|
|
|
|
|
2008-09-12 17:42:53 -06:00
|
|
|
export func WriteString(w Write, s string) (n int, err *os.Error) {
|
2008-10-07 13:31:31 -06:00
|
|
|
b := new([]byte, len(s)+1);
|
2008-09-17 14:49:23 -06:00
|
|
|
if !syscall.StringToBytes(b, s) {
|
2008-09-12 17:42:53 -06:00
|
|
|
return -1, os.EINVAL
|
|
|
|
}
|
|
|
|
// BUG return w.Write(b[0:len(s)])
|
2008-10-07 13:31:31 -06:00
|
|
|
r, e := w.Write(b[0:len(s)]);
|
2008-09-12 17:42:53 -06:00
|
|
|
return r, e
|
|
|
|
}
|
2008-11-11 18:28:36 -07:00
|
|
|
|
2008-11-18 19:45:51 -07:00
|
|
|
// Read until buffer is full, EOF, or error
|
2008-11-11 18:28:36 -07:00
|
|
|
export func Readn(fd Read, buf *[]byte) (n int, err *os.Error) {
|
|
|
|
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
|
|
|
|
type FullRead struct {
|
|
|
|
fd Read;
|
|
|
|
}
|
|
|
|
|
|
|
|
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
|
|
|
|
}
|
|
|
|
|
|
|
|
export func MakeFullReader(fd Read) Read {
|
|
|
|
if fr, ok := fd.(*FullRead); ok {
|
|
|
|
// already a FullRead
|
|
|
|
return fd
|
|
|
|
}
|
|
|
|
return &FullRead{fd}
|
|
|
|
}
|
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.
|
2008-11-18 19:45:51 -07:00
|
|
|
export func Copyn(src Read, dst Write, n int64) (written int64, err *os.Error) {
|
|
|
|
buf := new([]byte, 32*1024);
|
|
|
|
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.
|
|
|
|
export func Copy(src Read, dst Write) (written int64, err *os.Error) {
|
|
|
|
buf := new([]byte, 32*1024);
|
|
|
|
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
|
|
|
|
}
|
|
|
|
|