123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243 |
- // Copyright 2016 The Go Authors. All rights reserved.
- // Use of this source code is governed by a BSD-style
- // license that can be found in the LICENSE file.
- package flate_test
- import (
- "bytes"
- "compress/flate"
- "fmt"
- "io"
- "log"
- "os"
- "strings"
- "sync"
- )
- // In performance critical applications, Reset can be used to discard the
- // current compressor or decompressor state and reinitialize them quickly
- // by taking advantage of previously allocated memory.
- func Example_reset() {
- 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 r strings.Reader
- var b bytes.Buffer
- buf := make([]byte, 32<<10)
- zw, err := flate.NewWriter(nil, flate.DefaultCompression)
- if err != nil {
- log.Fatal(err)
- }
- zr := flate.NewReader(nil)
- for _, s := range proverbs {
- r.Reset(s)
- b.Reset()
- // Reset the compressor and encode from some input stream.
- zw.Reset(&b)
- if _, err := io.CopyBuffer(zw, &r, buf); err != nil {
- log.Fatal(err)
- }
- if err := zw.Close(); err != nil {
- log.Fatal(err)
- }
- // Reset the decompressor and decode to some output stream.
- if err := zr.(flate.Resetter).Reset(&b, nil); err != nil {
- log.Fatal(err)
- }
- if _, err := io.CopyBuffer(os.Stdout, zr, buf); err != nil {
- log.Fatal(err)
- }
- if err := zr.Close(); 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.
- }
- // A preset dictionary can be used to improve the compression ratio.
- // The downside to using a dictionary is that the compressor and decompressor
- // must agree in advance what dictionary to use.
- func Example_dictionary() {
- // The dictionary is a string of bytes. When compressing some input data,
- // the compressor will attempt to substitute substrings with matches found
- // in the dictionary. As such, the dictionary should only contain substrings
- // that are expected to be found in the actual data stream.
- const dict = `<?xml version="1.0"?>` + `<book>` + `<data>` + `<meta name="` + `" content="`
- // The data to compress should (but is not required to) contain frequent
- // substrings that match those in the dictionary.
- const data = `<?xml version="1.0"?>
- <book>
- <meta name="title" content="The Go Programming Language"/>
- <meta name="authors" content="Alan Donovan and Brian Kernighan"/>
- <meta name="published" content="2015-10-26"/>
- <meta name="isbn" content="978-0134190440"/>
- <data>...</data>
- </book>
- `
- var b bytes.Buffer
- // Compress the data using the specially crafted dictionary.
- zw, err := flate.NewWriterDict(&b, flate.DefaultCompression, []byte(dict))
- if err != nil {
- log.Fatal(err)
- }
- if _, err := io.Copy(zw, strings.NewReader(data)); err != nil {
- log.Fatal(err)
- }
- if err := zw.Close(); err != nil {
- log.Fatal(err)
- }
- // The decompressor must use the same dictionary as the compressor.
- // Otherwise, the input may appear as corrupted.
- fmt.Println("Decompressed output using the dictionary:")
- zr := flate.NewReaderDict(bytes.NewReader(b.Bytes()), []byte(dict))
- if _, err := io.Copy(os.Stdout, zr); err != nil {
- log.Fatal(err)
- }
- if err := zr.Close(); err != nil {
- log.Fatal(err)
- }
- fmt.Println()
- // Substitute all of the bytes in the dictionary with a '#' to visually
- // demonstrate the approximate effectiveness of using a preset dictionary.
- fmt.Println("Substrings matched by the dictionary are marked with #:")
- hashDict := []byte(dict)
- for i := range hashDict {
- hashDict[i] = '#'
- }
- zr = flate.NewReaderDict(&b, hashDict)
- if _, err := io.Copy(os.Stdout, zr); err != nil {
- log.Fatal(err)
- }
- if err := zr.Close(); err != nil {
- log.Fatal(err)
- }
- // Output:
- // Decompressed output using the dictionary:
- // <?xml version="1.0"?>
- // <book>
- // <meta name="title" content="The Go Programming Language"/>
- // <meta name="authors" content="Alan Donovan and Brian Kernighan"/>
- // <meta name="published" content="2015-10-26"/>
- // <meta name="isbn" content="978-0134190440"/>
- // <data>...</data>
- // </book>
- //
- // Substrings matched by the dictionary are marked with #:
- // #####################
- // ######
- // ############title###########The Go Programming Language"/#
- // ############authors###########Alan Donovan and Brian Kernighan"/#
- // ############published###########2015-10-26"/#
- // ############isbn###########978-0134190440"/#
- // ######...</#####
- // </#####
- }
- // DEFLATE is suitable for transmitting compressed data across the network.
- func Example_synchronization() {
- var wg sync.WaitGroup
- defer wg.Wait()
- // Use io.Pipe to simulate a network connection.
- // A real network application should take care to properly close the
- // underlying connection.
- rp, wp := io.Pipe()
- // Start a goroutine to act as the transmitter.
- wg.Add(1)
- go func() {
- defer wg.Done()
- zw, err := flate.NewWriter(wp, flate.BestSpeed)
- if err != nil {
- log.Fatal(err)
- }
- b := make([]byte, 256)
- for _, m := range strings.Fields("A long time ago in a galaxy far, far away...") {
- // We use a simple framing format where the first byte is the
- // message length, followed the message itself.
- b[0] = uint8(copy(b[1:], m))
- if _, err := zw.Write(b[:1+len(m)]); err != nil {
- log.Fatal(err)
- }
- // Flush ensures that the receiver can read all data sent so far.
- if err := zw.Flush(); err != nil {
- log.Fatal(err)
- }
- }
- if err := zw.Close(); err != nil {
- log.Fatal(err)
- }
- }()
- // Start a goroutine to act as the receiver.
- wg.Add(1)
- go func() {
- defer wg.Done()
- zr := flate.NewReader(rp)
- b := make([]byte, 256)
- for {
- // Read the message length.
- // This is guaranteed to return for every corresponding
- // Flush and Close on the transmitter side.
- if _, err := io.ReadFull(zr, b[:1]); err != nil {
- if err == io.EOF {
- break // The transmitter closed the stream
- }
- log.Fatal(err)
- }
- // Read the message content.
- n := int(b[0])
- if _, err := io.ReadFull(zr, b[:n]); err != nil {
- log.Fatal(err)
- }
- fmt.Printf("Received %d bytes: %s\n", n, b[:n])
- }
- fmt.Println()
- if err := zr.Close(); err != nil {
- log.Fatal(err)
- }
- }()
- // Output:
- // Received 1 bytes: A
- // Received 4 bytes: long
- // Received 4 bytes: time
- // Received 3 bytes: ago
- // Received 2 bytes: in
- // Received 1 bytes: a
- // Received 6 bytes: galaxy
- // Received 4 bytes: far,
- // Received 3 bytes: far
- // Received 7 bytes: away...
- }
|