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 5package bytes 6 7import ( 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. 18type 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. 26func (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. 37func (r *Reader) Size() int64 { return int64(len(r.s)) } 38 39// Read implements the io.Reader interface. 40func (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. 51func (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. 67func (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. 78func (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. 88func (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. 104func (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. 117func (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. 138func (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. 157func (r *Reader) Reset(b []byte) { *r = Reader{b, 0, -1} } 158 159// NewReader returns a new Reader reading from b. 160func NewReader(b []byte) *Reader { return &Reader{b, 0, -1} } 161