Source file src/pkg/bytes/reader.go

     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