mirror of
https://github.com/golang/go
synced 2024-10-05 09:21:22 -06:00
351c15f1ce
Named returned values should only be used on public funcs and methods when it contributes to the documentation. Named return values should not be used if they're only saving the programmer a few lines of code inside the body of the function, especially if that means there's stutter in the documentation or it was only there so the programmer could use a naked return statement. (Naked returns should not be used except in very small functions) This change is a manual audit & cleanup of public func signatures. Signatures were not changed if: * the func was private (wouldn't be in public godoc) * the documentation referenced it * the named return value was an interesting name. (i.e. it wasn't simply stutter, repeating the name of the type) There should be no changes in behavior. (At least: none intended) Change-Id: I3472ef49619678fe786e5e0994bdf2d9de76d109 Reviewed-on: https://go-review.googlesource.com/20024 Run-TryBot: Brad Fitzpatrick <bradfitz@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Andrew Gerrand <adg@golang.org>
151 lines
3.2 KiB
Go
151 lines
3.2 KiB
Go
// Copyright 2012 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 bytes
|
|
|
|
import (
|
|
"errors"
|
|
"io"
|
|
"unicode/utf8"
|
|
)
|
|
|
|
// A Reader implements the io.Reader, io.ReaderAt, io.WriterTo, io.Seeker,
|
|
// io.ByteScanner, and io.RuneScanner interfaces by reading from
|
|
// a byte slice.
|
|
// Unlike a Buffer, a Reader is read-only and supports seeking.
|
|
type Reader struct {
|
|
s []byte
|
|
i int64 // current reading index
|
|
prevRune int // index of previous rune; or < 0
|
|
}
|
|
|
|
// Len returns the number of bytes of the unread portion of the
|
|
// slice.
|
|
func (r *Reader) Len() int {
|
|
if r.i >= int64(len(r.s)) {
|
|
return 0
|
|
}
|
|
return int(int64(len(r.s)) - r.i)
|
|
}
|
|
|
|
// Size returns the original length of the underlying byte slice.
|
|
// Size is the number of bytes available for reading via ReadAt.
|
|
// The returned value is always the same and is not affected by calls
|
|
// to any other method.
|
|
func (r *Reader) Size() int64 { return int64(len(r.s)) }
|
|
|
|
func (r *Reader) Read(b []byte) (n int, err error) {
|
|
if len(b) == 0 {
|
|
return 0, nil
|
|
}
|
|
if r.i >= int64(len(r.s)) {
|
|
return 0, io.EOF
|
|
}
|
|
r.prevRune = -1
|
|
n = copy(b, r.s[r.i:])
|
|
r.i += int64(n)
|
|
return
|
|
}
|
|
|
|
func (r *Reader) ReadAt(b []byte, off int64) (n int, err error) {
|
|
// cannot modify state - see io.ReaderAt
|
|
if off < 0 {
|
|
return 0, errors.New("bytes.Reader.ReadAt: negative offset")
|
|
}
|
|
if off >= int64(len(r.s)) {
|
|
return 0, io.EOF
|
|
}
|
|
n = copy(b, r.s[off:])
|
|
if n < len(b) {
|
|
err = io.EOF
|
|
}
|
|
return
|
|
}
|
|
|
|
func (r *Reader) ReadByte() (byte, error) {
|
|
r.prevRune = -1
|
|
if r.i >= int64(len(r.s)) {
|
|
return 0, io.EOF
|
|
}
|
|
b := r.s[r.i]
|
|
r.i++
|
|
return b, nil
|
|
}
|
|
|
|
func (r *Reader) UnreadByte() error {
|
|
r.prevRune = -1
|
|
if r.i <= 0 {
|
|
return errors.New("bytes.Reader.UnreadByte: at beginning of slice")
|
|
}
|
|
r.i--
|
|
return nil
|
|
}
|
|
|
|
func (r *Reader) ReadRune() (ch rune, size int, err error) {
|
|
if r.i >= int64(len(r.s)) {
|
|
r.prevRune = -1
|
|
return 0, 0, io.EOF
|
|
}
|
|
r.prevRune = int(r.i)
|
|
if c := r.s[r.i]; c < utf8.RuneSelf {
|
|
r.i++
|
|
return rune(c), 1, nil
|
|
}
|
|
ch, size = utf8.DecodeRune(r.s[r.i:])
|
|
r.i += int64(size)
|
|
return
|
|
}
|
|
|
|
func (r *Reader) UnreadRune() error {
|
|
if r.prevRune < 0 {
|
|
return errors.New("bytes.Reader.UnreadRune: previous operation was not ReadRune")
|
|
}
|
|
r.i = int64(r.prevRune)
|
|
r.prevRune = -1
|
|
return nil
|
|
}
|
|
|
|
// Seek implements the io.Seeker interface.
|
|
func (r *Reader) Seek(offset int64, whence int) (int64, error) {
|
|
r.prevRune = -1
|
|
var abs int64
|
|
switch whence {
|
|
case 0:
|
|
abs = offset
|
|
case 1:
|
|
abs = int64(r.i) + offset
|
|
case 2:
|
|
abs = int64(len(r.s)) + offset
|
|
default:
|
|
return 0, errors.New("bytes.Reader.Seek: invalid whence")
|
|
}
|
|
if abs < 0 {
|
|
return 0, errors.New("bytes.Reader.Seek: negative position")
|
|
}
|
|
r.i = abs
|
|
return abs, nil
|
|
}
|
|
|
|
// WriteTo implements the io.WriterTo interface.
|
|
func (r *Reader) WriteTo(w io.Writer) (n int64, err error) {
|
|
r.prevRune = -1
|
|
if r.i >= int64(len(r.s)) {
|
|
return 0, nil
|
|
}
|
|
b := r.s[r.i:]
|
|
m, err := w.Write(b)
|
|
if m > len(b) {
|
|
panic("bytes.Reader.WriteTo: invalid Write count")
|
|
}
|
|
r.i += int64(m)
|
|
n = int64(m)
|
|
if m != len(b) && err == nil {
|
|
err = io.ErrShortWrite
|
|
}
|
|
return
|
|
}
|
|
|
|
// NewReader returns a new Reader reading from b.
|
|
func NewReader(b []byte) *Reader { return &Reader{b, 0, -1} }
|