brotli

func (*Reader) Read ¶

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

func (*Reader) Reset ¶

func (r *Reader) Reset(src io.Reader) error

Reset discards the Reader's state and makes it equivalent to the result of its original state from NewReader, but reading from src instead. This permits reusing a Reader rather than allocating a new one. Error is always nil

func (*Writer) Close ¶

func (w *Writer) Close() error

Close flushes remaining data to the decorated writer.

func (*Writer) Flush ¶

func (w *Writer) Flush() error

Flush outputs encoded data for all input provided to Write. The resulting output can be decoded to match all input before Flush, but the stream is not yet complete until after Close. Flush has a negative impact on compression.

func (*Writer) Reset ¶

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

Reset discards the Writer's state and makes it equivalent to the result of its original state from NewWriter or NewWriterLevel, but writing to dst instead. This permits reusing a Writer rather than allocating a new one.

proverbs := []string{
	"Don't communicate by sharing memory, share memory by communicating.\n",
	"Concurrency is not parallelism.\n",
	"The bigger the interface, the weaker the abstraction.\n",
	"Documentation is for users.\n",
}

var b bytes.Buffer

bw := NewWriter(nil)
br := NewReader(nil)

for _, s := range proverbs {
	b.Reset()

	// Reset the compressor and encode from some input stream.
	bw.Reset(&b)
	if _, err := io.WriteString(bw, s); err != nil {
		log.Fatal(err)
	}
	if err := bw.Close(); err != nil {
		log.Fatal(err)
	}

	// Reset the decompressor and decode to some output stream.
	if err := br.Reset(&b); err != nil {
		log.Fatal(err)
	}
	if _, err := io.Copy(os.Stdout, br); err != nil {
		log.Fatal(err)
	}
}

Output:

Don't communicate by sharing memory, share memory by communicating.
Concurrency is not parallelism.
The bigger the interface, the weaker the abstraction.
Documentation is for users.

func (*Writer) Write ¶

func (w *Writer) Write(p []byte) (n int, err error)

Write implements io.Writer. Flush or Close must be called to ensure that the encoded bytes are actually flushed to the underlying Writer.