reader.go

Documentation: bytes

		 1  // Copyright 2012 The Go Authors. All rights reserved.
		 2  // Use of this source code is governed by a BSD-style
		 3  // license that can be found in the LICENSE file.
		 4  
		 5  package bytes
		 6  
		 7  import (
		 8  	"errors"
		 9  	"io"
		10  	"unicode/utf8"
		11  )
		12  
		13  // A Reader implements the io.Reader, io.ReaderAt, io.WriterTo, io.Seeker,
		14  // io.ByteScanner, and io.RuneScanner interfaces by reading from
		15  // a byte slice.
		16  // Unlike a Buffer, a Reader is read-only and supports seeking.
		17  // The zero value for Reader operates like a Reader of an empty slice.
		18  type Reader struct {
		19  	s				[]byte
		20  	i				int64 // current reading index
		21  	prevRune int	 // index of previous rune; or < 0
		22  }
		23  
		24  // Len returns the number of bytes of the unread portion of the
		25  // slice.
		26  func (r *Reader) Len() int {
		27  	if r.i >= int64(len(r.s)) {
		28  		return 0
		29  	}
		30  	return int(int64(len(r.s)) - r.i)
		31  }
		32  
		33  // Size returns the original length of the underlying byte slice.
		34  // Size is the number of bytes available for reading via ReadAt.
		35  // The returned value is always the same and is not affected by calls
		36  // to any other method.
		37  func (r *Reader) Size() int64 { return int64(len(r.s)) }
		38  
		39  // Read implements the io.Reader interface.
		40  func (r *Reader) Read(b []byte) (n int, err error) {
		41  	if r.i >= int64(len(r.s)) {
		42  		return 0, io.EOF
		43  	}
		44  	r.prevRune = -1
		45  	n = copy(b, r.s[r.i:])
		46  	r.i += int64(n)
		47  	return
		48  }
		49  
		50  // ReadAt implements the io.ReaderAt interface.
		51  func (r *Reader) ReadAt(b []byte, off int64) (n int, err error) {
		52  	// cannot modify state - see io.ReaderAt
		53  	if off < 0 {
		54  		return 0, errors.New("bytes.Reader.ReadAt: negative offset")
		55  	}
		56  	if off >= int64(len(r.s)) {
		57  		return 0, io.EOF
		58  	}
		59  	n = copy(b, r.s[off:])
		60  	if n < len(b) {
		61  		err = io.EOF
		62  	}
		63  	return
		64  }
		65  
		66  // ReadByte implements the io.ByteReader interface.
		67  func (r *Reader) ReadByte() (byte, error) {
		68  	r.prevRune = -1
		69  	if r.i >= int64(len(r.s)) {
		70  		return 0, io.EOF
		71  	}
		72  	b := r.s[r.i]
		73  	r.i++
		74  	return b, nil
		75  }
		76  
		77  // UnreadByte complements ReadByte in implementing the io.ByteScanner interface.
		78  func (r *Reader) UnreadByte() error {
		79  	if r.i <= 0 {
		80  		return errors.New("bytes.Reader.UnreadByte: at beginning of slice")
		81  	}
		82  	r.prevRune = -1
		83  	r.i--
		84  	return nil
		85  }
		86  
		87  // ReadRune implements the io.RuneReader interface.
		88  func (r *Reader) ReadRune() (ch rune, size int, err error) {
		89  	if r.i >= int64(len(r.s)) {
		90  		r.prevRune = -1
		91  		return 0, 0, io.EOF
		92  	}
		93  	r.prevRune = int(r.i)
		94  	if c := r.s[r.i]; c < utf8.RuneSelf {
		95  		r.i++
		96  		return rune(c), 1, nil
		97  	}
		98  	ch, size = utf8.DecodeRune(r.s[r.i:])
		99  	r.i += int64(size)
	 100  	return
	 101  }
	 102  
	 103  // UnreadRune complements ReadRune in implementing the io.RuneScanner interface.
	 104  func (r *Reader) UnreadRune() error {
	 105  	if r.i <= 0 {
	 106  		return errors.New("bytes.Reader.UnreadRune: at beginning of slice")
	 107  	}
	 108  	if r.prevRune < 0 {
	 109  		return errors.New("bytes.Reader.UnreadRune: previous operation was not ReadRune")
	 110  	}
	 111  	r.i = int64(r.prevRune)
	 112  	r.prevRune = -1
	 113  	return nil
	 114  }
	 115  
	 116  // Seek implements the io.Seeker interface.
	 117  func (r *Reader) Seek(offset int64, whence int) (int64, error) {
	 118  	r.prevRune = -1
	 119  	var abs int64
	 120  	switch whence {
	 121  	case io.SeekStart:
	 122  		abs = offset
	 123  	case io.SeekCurrent:
	 124  		abs = r.i + offset
	 125  	case io.SeekEnd:
	 126  		abs = int64(len(r.s)) + offset
	 127  	default:
	 128  		return 0, errors.New("bytes.Reader.Seek: invalid whence")
	 129  	}
	 130  	if abs < 0 {
	 131  		return 0, errors.New("bytes.Reader.Seek: negative position")
	 132  	}
	 133  	r.i = abs
	 134  	return abs, nil
	 135  }
	 136  
	 137  // WriteTo implements the io.WriterTo interface.
	 138  func (r *Reader) WriteTo(w io.Writer) (n int64, err error) {
	 139  	r.prevRune = -1
	 140  	if r.i >= int64(len(r.s)) {
	 141  		return 0, nil
	 142  	}
	 143  	b := r.s[r.i:]
	 144  	m, err := w.Write(b)
	 145  	if m > len(b) {
	 146  		panic("bytes.Reader.WriteTo: invalid Write count")
	 147  	}
	 148  	r.i += int64(m)
	 149  	n = int64(m)
	 150  	if m != len(b) && err == nil {
	 151  		err = io.ErrShortWrite
	 152  	}
	 153  	return
	 154  }
	 155  
	 156  // Reset resets the Reader to be reading from b.
	 157  func (r *Reader) Reset(b []byte) { *r = Reader{b, 0, -1} }
	 158  
	 159  // NewReader returns a new Reader reading from b.
	 160  func NewReader(b []byte) *Reader { return &Reader{b, 0, -1} }
	 161
View as plain text