99 lines
2.3 KiB
Go
99 lines
2.3 KiB
Go
// Copyright 2009 The Go Authors. All rights reserved.
|
|
// Modified 2018 by Jan Speckamp. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
// This implements buffered I/O. It wraps an io.Reader or io.Writer
|
|
// object, creating another object (Reader or Writer) that also implements
|
|
// the interface but provides buffering and some help for textual I/O.
|
|
package main
|
|
|
|
import (
|
|
"io"
|
|
)
|
|
|
|
const (
|
|
defaultBufSize = 4096
|
|
)
|
|
|
|
// Writer implements buffering for an io.Writer object.
|
|
// If an error occurs writing to a Writer, no more data will be
|
|
// accepted and all subsequent writes, and Flush, will return the error.
|
|
// After all data has been written, the client should call the
|
|
// Flush method to guarantee all data has been forwarded to
|
|
// the underlying io.Writer.
|
|
type Writer struct {
|
|
err error
|
|
buf []byte
|
|
n int
|
|
wr io.Writer
|
|
}
|
|
|
|
// NewWriterSize returns a new Writer whose buffer has at least the specified
|
|
// size. If the argument io.Writer is already a Writer with large enough
|
|
// size, it returns the underlying Writer.
|
|
func NewWriterSize(w io.Writer, size int) *Writer {
|
|
// Is it already a Writer?
|
|
b, ok := w.(*Writer)
|
|
if ok && len(b.buf) >= size {
|
|
return b
|
|
}
|
|
if size <= 0 {
|
|
size = defaultBufSize
|
|
}
|
|
return &Writer{
|
|
buf: make([]byte, size),
|
|
wr: w,
|
|
}
|
|
}
|
|
|
|
// Flush writes any buffered data to the underlying io.Writer.
|
|
func (b *Writer) Flush() error {
|
|
if b.err != nil {
|
|
return b.err
|
|
}
|
|
if b.n == 0 {
|
|
return nil
|
|
}
|
|
n, err := b.wr.Write(b.buf[0:b.n])
|
|
if n < b.n && err == nil {
|
|
err = io.ErrShortWrite
|
|
}
|
|
if err != nil {
|
|
if n > 0 && n < b.n {
|
|
copy(b.buf[0:b.n-n], b.buf[n:b.n])
|
|
}
|
|
b.n -= n
|
|
b.err = err
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Write writes the contents of p into the buffer.
|
|
// It returns the number of bytes written.
|
|
// If nn < len(p), it also returns an error explaining
|
|
// why the write is short.
|
|
func (b *Writer) Write(p []byte) (nn int, err error) {
|
|
for len(p) > (len(b.buf)-b.n) && b.err == nil {
|
|
var n int
|
|
if b.n == 0 {
|
|
// Large write, empty buffer.
|
|
// Write directly from p to avoid copy.
|
|
n, b.err = b.wr.Write(p)
|
|
} else {
|
|
n = copy(b.buf[b.n:], p)
|
|
b.n += n
|
|
}
|
|
nn += n
|
|
p = p[n:]
|
|
}
|
|
if b.err != nil {
|
|
return nn, b.err
|
|
}
|
|
n := copy(b.buf[b.n:], p)
|
|
b.n += n
|
|
nn += n
|
|
return nn, nil
|
|
}
|