example_test.go

Documentation: compress/flate

     1  // Copyright 2016 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 flate_test
     6  
     7  import (
     8  	"bytes"
     9  	"compress/flate"
    10  	"fmt"
    11  	"io"
    12  	"log"
    13  	"os"
    14  	"strings"
    15  	"sync"
    16  )
    17  
    18  // In performance critical applications, Reset can be used to discard the
    19  // current compressor or decompressor state and reinitialize them quickly
    20  // by taking advantage of previously allocated memory.
    21  func Example_reset() {
    22  	proverbs := []string{
    23  		"Don't communicate by sharing memory, share memory by communicating.\n",
    24  		"Concurrency is not parallelism.\n",
    25  		"The bigger the interface, the weaker the abstraction.\n",
    26  		"Documentation is for users.\n",
    27  	}
    28  
    29  	var r strings.Reader
    30  	var b bytes.Buffer
    31  	buf := make([]byte, 32<<10)
    32  
    33  	zw, err := flate.NewWriter(nil, flate.DefaultCompression)
    34  	if err != nil {
    35  		log.Fatal(err)
    36  	}
    37  	zr := flate.NewReader(nil)
    38  
    39  	for _, s := range proverbs {
    40  		r.Reset(s)
    41  		b.Reset()
    42  
    43  		// Reset the compressor and encode from some input stream.
    44  		zw.Reset(&b)
    45  		if _, err := io.CopyBuffer(zw, &r, buf); err != nil {
    46  			log.Fatal(err)
    47  		}
    48  		if err := zw.Close(); err != nil {
    49  			log.Fatal(err)
    50  		}
    51  
    52  		// Reset the decompressor and decode to some output stream.
    53  		if err := zr.(flate.Resetter).Reset(&b, nil); err != nil {
    54  			log.Fatal(err)
    55  		}
    56  		if _, err := io.CopyBuffer(os.Stdout, zr, buf); err != nil {
    57  			log.Fatal(err)
    58  		}
    59  		if err := zr.Close(); err != nil {
    60  			log.Fatal(err)
    61  		}
    62  	}
    63  
    64  	// Output:
    65  	// Don't communicate by sharing memory, share memory by communicating.
    66  	// Concurrency is not parallelism.
    67  	// The bigger the interface, the weaker the abstraction.
    68  	// Documentation is for users.
    69  }
    70  
    71  // A preset dictionary can be used to improve the compression ratio.
    72  // The downside to using a dictionary is that the compressor and decompressor
    73  // must agree in advance what dictionary to use.
    74  func Example_dictionary() {
    75  	// The dictionary is a string of bytes. When compressing some input data,
    76  	// the compressor will attempt to substitute substrings with matches found
    77  	// in the dictionary. As such, the dictionary should only contain substrings
    78  	// that are expected to be found in the actual data stream.
    79  	const dict = `<?xml version="1.0"?>` + `<book>` + `<data>` + `<meta name="` + `" content="`
    80  
    81  	// The data to compress should (but is not required to) contain frequent
    82  	// substrings that match those in the dictionary.
    83  	const data = `<?xml version="1.0"?>
    84  <book>
    85  	<meta name="title" content="The Go Programming Language"/>
    86  	<meta name="authors" content="Alan Donovan and Brian Kernighan"/>
    87  	<meta name="published" content="2015-10-26"/>
    88  	<meta name="isbn" content="978-0134190440"/>
    89  	<data>...</data>
    90  </book>
    91  `
    92  
    93  	var b bytes.Buffer
    94  
    95  	// Compress the data using the specially crafted dictionary.
    96  	zw, err := flate.NewWriterDict(&b, flate.DefaultCompression, []byte(dict))
    97  	if err != nil {
    98  		log.Fatal(err)
    99  	}
   100  	if _, err := io.Copy(zw, strings.NewReader(data)); err != nil {
   101  		log.Fatal(err)
   102  	}
   103  	if err := zw.Close(); err != nil {
   104  		log.Fatal(err)
   105  	}
   106  
   107  	// The decompressor must use the same dictionary as the compressor.
   108  	// Otherwise, the input may appear as corrupted.
   109  	fmt.Println("Decompressed output using the dictionary:")
   110  	zr := flate.NewReaderDict(bytes.NewReader(b.Bytes()), []byte(dict))
   111  	if _, err := io.Copy(os.Stdout, zr); err != nil {
   112  		log.Fatal(err)
   113  	}
   114  	if err := zr.Close(); err != nil {
   115  		log.Fatal(err)
   116  	}
   117  
   118  	fmt.Println()
   119  
   120  	// Substitute all of the bytes in the dictionary with a '#' to visually
   121  	// demonstrate the approximate effectiveness of using a preset dictionary.
   122  	fmt.Println("Substrings matched by the dictionary are marked with #:")
   123  	hashDict := []byte(dict)
   124  	for i := range hashDict {
   125  		hashDict[i] = '#'
   126  	}
   127  	zr = flate.NewReaderDict(&b, hashDict)
   128  	if _, err := io.Copy(os.Stdout, zr); err != nil {
   129  		log.Fatal(err)
   130  	}
   131  	if err := zr.Close(); err != nil {
   132  		log.Fatal(err)
   133  	}
   134  
   135  	// Output:
   136  	// Decompressed output using the dictionary:
   137  	// <?xml version="1.0"?>
   138  	// <book>
   139  	// 	<meta name="title" content="The Go Programming Language"/>
   140  	// 	<meta name="authors" content="Alan Donovan and Brian Kernighan"/>
   141  	// 	<meta name="published" content="2015-10-26"/>
   142  	// 	<meta name="isbn" content="978-0134190440"/>
   143  	// 	<data>...</data>
   144  	// </book>
   145  	//
   146  	// Substrings matched by the dictionary are marked with #:
   147  	// #####################
   148  	// ######
   149  	// 	############title###########The Go Programming Language"/#
   150  	// 	############authors###########Alan Donovan and Brian Kernighan"/#
   151  	// 	############published###########2015-10-26"/#
   152  	// 	############isbn###########978-0134190440"/#
   153  	// 	######...</#####
   154  	// </#####
   155  }
   156  
   157  // DEFLATE is suitable for transmitting compressed data across the network.
   158  func Example_synchronization() {
   159  	var wg sync.WaitGroup
   160  	defer wg.Wait()
   161  
   162  	// Use io.Pipe to simulate a network connection.
   163  	// A real network application should take care to properly close the
   164  	// underlying connection.
   165  	rp, wp := io.Pipe()
   166  
   167  	// Start a goroutine to act as the transmitter.
   168  	wg.Add(1)
   169  	go func() {
   170  		defer wg.Done()
   171  
   172  		zw, err := flate.NewWriter(wp, flate.BestSpeed)
   173  		if err != nil {
   174  			log.Fatal(err)
   175  		}
   176  
   177  		b := make([]byte, 256)
   178  		for _, m := range strings.Fields("A long time ago in a galaxy far, far away...") {
   179  			// We use a simple framing format where the first byte is the
   180  			// message length, followed the message itself.
   181  			b[0] = uint8(copy(b[1:], m))
   182  
   183  			if _, err := zw.Write(b[:1+len(m)]); err != nil {
   184  				log.Fatal(err)
   185  			}
   186  
   187  			// Flush ensures that the receiver can read all data sent so far.
   188  			if err := zw.Flush(); err != nil {
   189  				log.Fatal(err)
   190  			}
   191  		}
   192  
   193  		if err := zw.Close(); err != nil {
   194  			log.Fatal(err)
   195  		}
   196  	}()
   197  
   198  	// Start a goroutine to act as the receiver.
   199  	wg.Add(1)
   200  	go func() {
   201  		defer wg.Done()
   202  
   203  		zr := flate.NewReader(rp)
   204  
   205  		b := make([]byte, 256)
   206  		for {
   207  			// Read the message length.
   208  			// This is guaranteed to return for every corresponding
   209  			// Flush and Close on the transmitter side.
   210  			if _, err := io.ReadFull(zr, b[:1]); err != nil {
   211  				if err == io.EOF {
   212  					break // The transmitter closed the stream
   213  				}
   214  				log.Fatal(err)
   215  			}
   216  
   217  			// Read the message content.
   218  			n := int(b[0])
   219  			if _, err := io.ReadFull(zr, b[:n]); err != nil {
   220  				log.Fatal(err)
   221  			}
   222  
   223  			fmt.Printf("Received %d bytes: %s\n", n, b[:n])
   224  		}
   225  		fmt.Println()
   226  
   227  		if err := zr.Close(); err != nil {
   228  			log.Fatal(err)
   229  		}
   230  	}()
   231  
   232  	// Output:
   233  	// Received 1 bytes: A
   234  	// Received 4 bytes: long
   235  	// Received 4 bytes: time
   236  	// Received 3 bytes: ago
   237  	// Received 2 bytes: in
   238  	// Received 1 bytes: a
   239  	// Received 6 bytes: galaxy
   240  	// Received 4 bytes: far,
   241  	// Received 3 bytes: far
   242  	// Received 7 bytes: away...
   243  }
   244
View as plain text