bufiox

type BytesReader struct {
	DefaultReader
	// contains filtered or unexported fields
}

type BytesWriter struct {
	DefaultWriter
	// contains filtered or unexported fields
}

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

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

type Reader interface {
	// Next reads the next n bytes sequentially and returns a slice `p` of length `n`,
	// otherwise returns an error if it is unable to read a buffer of n bytes.
	// The returned `p` can be a shallow copy of the original buffer.
	// Must ensure that the data in `p` is not modified before calling Release.
	//
	// Callers cannot use the returned data after calling Release.
	Next(n int) (p []byte, err error)

	// ReadBinary reads up to len(p) bytes into p. It returns the number of bytes
	// read (0 <= n <= len(p)) and any error encountered. Even if Read
	// returns n < len(p), it may use all of p as scratch space during the call.
	//
	// The bs is valid even if it is after calling Release, as it's copy read.
	ReadBinary(bs []byte) (n int, err error)

	// Peek behaves the same as Next, except that it doesn't advance the reader.
	//
	// Callers cannot use the returned data after calling Release.
	Peek(n int) (buf []byte, err error)

	// Skip skips the next n bytes sequentially, otherwise returns an error if it's unable to skip a buffer of n bytes.
	Skip(n int) (err error)

	// ReadLen returns the size that has already been read.
	// ReadBinary / Next / Skip will increase the size. When the Release function is called, ReadLen is set to 0.
	ReadLen() (n int)

	// Release will free the buffer. After release, buffer read by Next/Skip/Peek is invalid.
	// Param e is used when the buffer release depend on error.
	// For example, usually the write buffer will be released inside flush,
	// but if flush error happen, write buffer may need to be released explicitly.
	Release(e error) (err error)
}

type Writer interface {
	// Malloc returns a shallow copy of the write buffer with length n,
	// otherwise returns an error if it's unable to get n bytes from the write buffer.
	// Must ensure that the data written by the user to buf can be flushed to the underlying io.Writer.
	//
	// Caller cannot write data to the returned buf after calling Flush.
	Malloc(n int) (buf []byte, err error)

	// WriteBinary writes bs to the buffer, it may be a zero copy write.
	// MUST ensure that bs is not being concurrently written before calling Flush.
	// It returns err if n < len(bs), while n is the number of bytes written.
	WriteBinary(bs []byte) (n int, err error)

	// WrittenLen returns the total length of the buffer written.
	// Malloc / WriteBinary will increase the length. When the Flush function is called, WrittenLen is set to 0.
	WrittenLen() (length int)

	// Flush writes any malloc data to the underlying io.Writer, and reset WrittenLen to zero.
	Flush() (err error)
}