README

bufio

This is a fork of the http://golang.org/pkg/bufio/ package. It adds ReadN method that allows reading next n bytes from the internal buffer without allocating intermediate buffer. This method works just like the Buffer.Next method, but has slightly different signature.

Documentation

Overview

    Package bufio 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.

    Index

    Constants

    View Source
    const MinRead = 512

      MinRead is the minimum slice size passed to a Read call by Buffer.ReadFrom. As long as the Buffer has at least MinRead bytes beyond what is required to hold the contents of r, ReadFrom will not grow the underlying buffer.

      Variables

      View Source
      var (
      	ErrInvalidUnreadByte = errors.New("bufio: invalid use of UnreadByte")
      	ErrInvalidUnreadRune = errors.New("bufio: invalid use of UnreadRune")
      	ErrBufferFull        = errors.New("bufio: buffer full")
      	ErrNegativeCount     = errors.New("bufio: negative count")
      )
      View Source
      var ErrTooLarge = errors.New("bytes.Buffer: too large")

        ErrTooLarge is passed to panic if memory cannot be allocated to store data in a buffer.

        Functions

        This section is empty.

        Types

        type Buffer

        type Buffer struct {
        	// contains filtered or unexported fields
        }

          A Buffer is a variable-sized buffer of bytes with Read and Write methods. The zero value for Buffer is an empty buffer ready to use.

          func NewBuffer

          func NewBuffer(buf []byte) *Buffer

            NewBuffer creates and initializes a new Buffer using buf as its initial contents. It is intended to prepare a Buffer to read existing data. It can also be used to size the internal buffer for writing. To do that, buf should have the desired capacity but a length of zero.

            In most cases, new(Buffer) (or just declaring a Buffer variable) is sufficient to initialize a Buffer.

            func NewBufferString

            func NewBufferString(s string) *Buffer

              NewBufferString creates and initializes a new Buffer using string s as its initial contents. It is intended to prepare a buffer to read an existing string.

              In most cases, new(Buffer) (or just declaring a Buffer variable) is sufficient to initialize a Buffer.

              func (*Buffer) Bytes

              func (b *Buffer) Bytes() []byte

                Bytes returns a slice of the contents of the unread portion of the buffer; len(b.Bytes()) == b.Len(). If the caller changes the contents of the returned slice, the contents of the buffer will change provided there are no intervening method calls on the Buffer.

                func (*Buffer) Grow

                func (b *Buffer) Grow(n int)

                  Grow grows the buffer's capacity, if necessary, to guarantee space for another n bytes. After Grow(n), at least n bytes can be written to the buffer without another allocation. If n is negative, Grow will panic. If the buffer can't grow it will panic with ErrTooLarge.

                  func (*Buffer) Len

                  func (b *Buffer) Len() int

                    Len returns the number of bytes of the unread portion of the buffer; b.Len() == len(b.Bytes()).

                    func (*Buffer) Next

                    func (b *Buffer) Next(n int) []byte

                      Next returns a slice containing the next n bytes from the buffer, advancing the buffer as if the bytes had been returned by Read. If there are fewer than n bytes in the buffer, Next returns the entire buffer. The slice is only valid until the next call to a read or write method.

                      func (*Buffer) Read

                      func (b *Buffer) Read(p []byte) (n int, err error)

                        Read reads the next len(p) bytes from the buffer or until the buffer is drained. The return value n is the number of bytes read. If the buffer has no data to return, err is io.EOF (unless len(p) is zero); otherwise it is nil.

                        func (*Buffer) ReadByte

                        func (b *Buffer) ReadByte() (c byte, err error)

                          ReadByte reads and returns the next byte from the buffer. If no byte is available, it returns error io.EOF.

                          func (*Buffer) ReadBytes

                          func (b *Buffer) ReadBytes(delim byte) (line []byte, err error)

                            ReadBytes reads until the first occurrence of delim in the input, returning a slice containing the data up to and including the delimiter. If ReadBytes encounters an error before finding a delimiter, it returns the data read before the error and the error itself (often io.EOF). ReadBytes returns err != nil if and only if the returned data does not end in delim.

                            func (*Buffer) ReadFrom

                            func (b *Buffer) ReadFrom(r io.Reader) (n int64, err error)

                              ReadFrom reads data from r until EOF and appends it to the buffer, growing the buffer as needed. The return value n is the number of bytes read. Any error except io.EOF encountered during the read is also returned. If the buffer becomes too large, ReadFrom will panic with ErrTooLarge.

                              func (*Buffer) ReadRune

                              func (b *Buffer) ReadRune() (r rune, size int, err error)

                                ReadRune reads and returns the next UTF-8-encoded Unicode code point from the buffer. If no bytes are available, the error returned is io.EOF. If the bytes are an erroneous UTF-8 encoding, it consumes one byte and returns U+FFFD, 1.

                                func (*Buffer) ReadString

                                func (b *Buffer) ReadString(delim byte) (line string, err error)

                                  ReadString reads until the first occurrence of delim in the input, returning a string containing the data up to and including the delimiter. If ReadString encounters an error before finding a delimiter, it returns the data read before the error and the error itself (often io.EOF). ReadString returns err != nil if and only if the returned data does not end in delim.

                                  func (*Buffer) Reset

                                  func (b *Buffer) Reset()

                                    Reset resets the buffer so it has no content. b.Reset() is the same as b.Truncate(0).

                                    func (*Buffer) String

                                    func (b *Buffer) String() string

                                      String returns the contents of the unread portion of the buffer as a string. If the Buffer is a nil pointer, it returns "<nil>".

                                      func (*Buffer) Truncate

                                      func (b *Buffer) Truncate(n int)

                                        Truncate discards all but the first n unread bytes from the buffer. It panics if n is negative or greater than the length of the buffer.

                                        func (*Buffer) UnreadByte

                                        func (b *Buffer) UnreadByte() error

                                          UnreadByte unreads the last byte returned by the most recent read operation. If write has happened since the last read, UnreadByte returns an error.

                                          func (*Buffer) UnreadRune

                                          func (b *Buffer) UnreadRune() error

                                            UnreadRune unreads the last rune returned by ReadRune. If the most recent read or write operation on the buffer was not a ReadRune, UnreadRune returns an error. (In this regard it is stricter than UnreadByte, which will unread the last byte from any read operation.)

                                            func (*Buffer) Write

                                            func (b *Buffer) Write(p []byte) (n int, err error)

                                              Write appends the contents of p to the buffer, growing the buffer as needed. The return value n is the length of p; err is always nil. If the buffer becomes too large, Write will panic with ErrTooLarge.

                                              func (*Buffer) WriteByte

                                              func (b *Buffer) WriteByte(c byte) error

                                                WriteByte appends the byte c to the buffer, growing the buffer as needed. The returned error is always nil, but is included to match bufio.Writer's WriteByte. If the buffer becomes too large, WriteByte will panic with ErrTooLarge.

                                                func (*Buffer) WriteRune

                                                func (b *Buffer) WriteRune(r rune) (n int, err error)

                                                  WriteRune appends the UTF-8 encoding of Unicode code point r to the buffer, returning its length and an error, which is always nil but is included to match bufio.Writer's WriteRune. The buffer is grown as needed; if it becomes too large, WriteRune will panic with ErrTooLarge.

                                                  func (*Buffer) WriteString

                                                  func (b *Buffer) WriteString(s string) (n int, err error)

                                                    WriteString appends the contents of s to the buffer, growing the buffer as needed. The return value n is the length of s; err is always nil. If the buffer becomes too large, WriteString will panic with ErrTooLarge.

                                                    func (*Buffer) WriteTo

                                                    func (b *Buffer) WriteTo(w io.Writer) (n int64, err error)

                                                      WriteTo writes data to w until the buffer is drained or an error occurs. The return value n is the number of bytes written; it always fits into an int, but it is int64 to match the io.WriterTo interface. Any error encountered during the write is also returned.

                                                      type ReadWriter

                                                      type ReadWriter struct {
                                                      	*Reader
                                                      	*Writer
                                                      }

                                                        ReadWriter stores pointers to a Reader and a Writer. It implements io.ReadWriter.

                                                        func NewReadWriter

                                                        func NewReadWriter(r *Reader, w *Writer) *ReadWriter

                                                          NewReadWriter allocates a new ReadWriter that dispatches to r and w.

                                                          type Reader

                                                          type Reader struct {
                                                          	// contains filtered or unexported fields
                                                          }

                                                            Reader implements buffering for an io.Reader object.

                                                            func NewReader

                                                            func NewReader(rd io.Reader) *Reader

                                                              NewReader returns a new Reader whose buffer has the default size.

                                                              func NewReaderSize

                                                              func NewReaderSize(rd io.Reader, size int) *Reader

                                                                NewReaderSize returns a new Reader whose buffer has at least the specified size. If the argument io.Reader is already a Reader with large enough size, it returns the underlying Reader.

                                                                func (*Reader) Buffered

                                                                func (b *Reader) Buffered() int

                                                                  Buffered returns the number of bytes that can be read from the current buffer.

                                                                  func (*Reader) Peek

                                                                  func (b *Reader) Peek(n int) ([]byte, error)

                                                                    Peek returns the next n bytes without advancing the reader. The bytes stop being valid at the next read call. If Peek returns fewer than n bytes, it also returns an error explaining why the read is short. The error is ErrBufferFull if n is larger than b's buffer size.

                                                                    func (*Reader) Read

                                                                    func (b *Reader) Read(p []byte) (n int, err error)

                                                                      Read reads data into p. It returns the number of bytes read into p. It calls Read at most once on the underlying Reader, hence n may be less than len(p). At EOF, the count will be zero and err will be io.EOF.

                                                                      func (*Reader) ReadByte

                                                                      func (b *Reader) ReadByte() (c byte, err error)

                                                                        ReadByte reads and returns a single byte. If no byte is available, returns an error.

                                                                        func (*Reader) ReadBytes

                                                                        func (b *Reader) ReadBytes(delim byte) (line []byte, err error)

                                                                          ReadBytes reads until the first occurrence of delim in the input, returning a slice containing the data up to and including the delimiter. If ReadBytes encounters an error before finding a delimiter, it returns the data read before the error and the error itself (often io.EOF). ReadBytes returns err != nil if and only if the returned data does not end in delim. For simple uses, a Scanner may be more convenient.

                                                                          func (*Reader) ReadLine

                                                                          func (b *Reader) ReadLine() (line []byte, isPrefix bool, err error)

                                                                            ReadLine is a low-level line-reading primitive. Most callers should use ReadBytes('\n') or ReadString('\n') instead or use a Scanner.

                                                                            ReadLine tries to return a single line, not including the end-of-line bytes. If the line was too long for the buffer then isPrefix is set and the beginning of the line is returned. The rest of the line will be returned from future calls. isPrefix will be false when returning the last fragment of the line. The returned buffer is only valid until the next call to ReadLine. ReadLine either returns a non-nil line or it returns an error, never both.

                                                                            The text returned from ReadLine does not include the line end ("\r\n" or "\n"). No indication or error is given if the input ends without a final line end. Calling UnreadByte after ReadLine will always unread the last byte read (possibly a character belonging to the line end) even if that byte is not part of the line returned by ReadLine.

                                                                            func (*Reader) ReadN

                                                                            func (b *Reader) ReadN(n int) ([]byte, error)

                                                                              ReadN tries to read exactly n bytes. The bytes stop being valid at the next read call. If ReadN encounters an error before reading n bytes, it returns all the data in the buffer and the error itself (often io.EOF). ReadN fails with error ErrBufferFull if the buffer fills without reading N bytes. Because the data returned from ReadN will be overwritten by the next I/O operation, most clients should use ReadBytes or ReadString instead.

                                                                              func (*Reader) ReadRune

                                                                              func (b *Reader) ReadRune() (r rune, size int, err error)

                                                                                ReadRune reads a single UTF-8 encoded Unicode character and returns the rune and its size in bytes. If the encoded rune is invalid, it consumes one byte and returns unicode.ReplacementChar (U+FFFD) with a size of 1.

                                                                                func (*Reader) ReadSlice

                                                                                func (b *Reader) ReadSlice(delim byte) (line []byte, err error)

                                                                                  ReadSlice reads until the first occurrence of delim in the input, returning a slice pointing at the bytes in the buffer. The bytes stop being valid at the next read. If ReadSlice encounters an error before finding a delimiter, it returns all the data in the buffer and the error itself (often io.EOF). ReadSlice fails with error ErrBufferFull if the buffer fills without a delim. Because the data returned from ReadSlice will be overwritten by the next I/O operation, most clients should use ReadBytes or ReadString instead. ReadSlice returns err != nil if and only if line does not end in delim.

                                                                                  func (*Reader) ReadString

                                                                                  func (b *Reader) ReadString(delim byte) (line string, err error)

                                                                                    ReadString reads until the first occurrence of delim in the input, returning a string containing the data up to and including the delimiter. If ReadString encounters an error before finding a delimiter, it returns the data read before the error and the error itself (often io.EOF). ReadString returns err != nil if and only if the returned data does not end in delim. For simple uses, a Scanner may be more convenient.

                                                                                    func (*Reader) Reset

                                                                                    func (b *Reader) Reset(r io.Reader)

                                                                                      Reset discards any buffered data, resets all state, and switches the buffered reader to read from r.

                                                                                      func (*Reader) UnreadByte

                                                                                      func (b *Reader) UnreadByte() error

                                                                                        UnreadByte unreads the last byte. Only the most recently read byte can be unread.

                                                                                        func (*Reader) UnreadRune

                                                                                        func (b *Reader) UnreadRune() error

                                                                                          UnreadRune unreads the last rune. If the most recent read operation on the buffer was not a ReadRune, UnreadRune returns an error. (In this regard it is stricter than UnreadByte, which will unread the last byte from any read operation.)

                                                                                          func (*Reader) WriteTo

                                                                                          func (b *Reader) WriteTo(w io.Writer) (n int64, err error)

                                                                                            WriteTo implements io.WriterTo.

                                                                                            type Writer

                                                                                            type Writer struct {
                                                                                            	// contains filtered or unexported fields
                                                                                            }

                                                                                              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 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.

                                                                                              func NewWriter

                                                                                              func NewWriter(w io.Writer) *Writer

                                                                                                NewWriter returns a new Writer whose buffer has the default size.

                                                                                                func NewWriterSize

                                                                                                func NewWriterSize(w io.Writer, size int) *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 (*Writer) Available

                                                                                                  func (b *Writer) Available() int

                                                                                                    Available returns how many bytes are unused in the buffer.

                                                                                                    func (*Writer) Buffered

                                                                                                    func (b *Writer) Buffered() int

                                                                                                      Buffered returns the number of bytes that have been written into the current buffer.

                                                                                                      func (*Writer) Flush

                                                                                                      func (b *Writer) Flush() error

                                                                                                        Flush writes any buffered data to the underlying io.Writer.

                                                                                                        func (*Writer) ReadFrom

                                                                                                        func (b *Writer) ReadFrom(r io.Reader) (n int64, err error)

                                                                                                          ReadFrom implements io.ReaderFrom.

                                                                                                          func (*Writer) Reset

                                                                                                          func (b *Writer) Reset(w io.Writer)

                                                                                                            Reset discards any unflushed buffered data, clears any error, and resets b to write its output to w.

                                                                                                            func (*Writer) Write

                                                                                                            func (b *Writer) Write(p []byte) (nn int, err error)

                                                                                                              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 (*Writer) WriteByte

                                                                                                              func (b *Writer) WriteByte(c byte) error

                                                                                                                WriteByte writes a single byte.

                                                                                                                func (*Writer) WriteRune

                                                                                                                func (b *Writer) WriteRune(r rune) (size int, err error)

                                                                                                                  WriteRune writes a single Unicode code point, returning the number of bytes written and any error.

                                                                                                                  func (*Writer) WriteString

                                                                                                                  func (b *Writer) WriteString(s string) (int, error)

                                                                                                                    WriteString writes a string. It returns the number of bytes written. If the count is less than len(s), it also returns an error explaining why the write is short.

                                                                                                                    Source Files