1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
|
<h1> Package zlib </h1> <ul id="short-nav">
<li><code>import "compress/zlib"</code></li>
<li><a href="#pkg-overview" class="overviewLink">Overview</a></li>
<li><a href="#pkg-index" class="indexLink">Index</a></li>
<li><a href="#pkg-examples" class="examplesLink">Examples</a></li>
</ul> <h2 id="pkg-overview">Overview </h2> <p>Package zlib implements reading and writing of zlib format compressed data, as specified in RFC 1950. </p>
<p>The implementation provides filters that uncompress during reading and compress during writing. For example, to write compressed data to a buffer: </p>
<pre data-language="go">var b bytes.Buffer
w := zlib.NewWriter(&b)
w.Write([]byte("hello, world\n"))
w.Close()
</pre> <p>and to read that data back: </p>
<pre data-language="go">r, err := zlib.NewReader(&b)
io.Copy(os.Stdout, r)
r.Close()
</pre> <h2 id="pkg-index">Index </h2> <ul id="manual-nav">
<li><a href="#pkg-constants">Constants</a></li>
<li><a href="#pkg-variables">Variables</a></li>
<li><a href="#NewReader">func NewReader(r io.Reader) (io.ReadCloser, error)</a></li>
<li><a href="#NewReaderDict">func NewReaderDict(r io.Reader, dict []byte) (io.ReadCloser, error)</a></li>
<li><a href="#Resetter">type Resetter</a></li>
<li><a href="#Writer">type Writer</a></li>
<li> <a href="#NewWriter">func NewWriter(w io.Writer) *Writer</a>
</li>
<li> <a href="#NewWriterLevel">func NewWriterLevel(w io.Writer, level int) (*Writer, error)</a>
</li>
<li> <a href="#NewWriterLevelDict">func NewWriterLevelDict(w io.Writer, level int, dict []byte) (*Writer, error)</a>
</li>
<li> <a href="#Writer.Close">func (z *Writer) Close() error</a>
</li>
<li> <a href="#Writer.Flush">func (z *Writer) Flush() error</a>
</li>
<li> <a href="#Writer.Reset">func (z *Writer) Reset(w io.Writer)</a>
</li>
<li> <a href="#Writer.Write">func (z *Writer) Write(p []byte) (n int, err error)</a>
</li>
</ul> <div id="pkg-examples"> <h3>Examples</h3> <dl> <dd><a class="exampleLink" href="#example_NewReader">NewReader</a></dd> <dd><a class="exampleLink" href="#example_NewWriter">NewWriter</a></dd> </dl> </div> <h3>Package files</h3> <p> <span>reader.go</span> <span>writer.go</span> </p> <h2 id="pkg-constants">Constants</h2> <p>These constants are copied from the flate package, so that code that imports "compress/zlib" does not also have to import "compress/flate". </p>
<pre data-language="go">const (
NoCompression = flate.NoCompression
BestSpeed = flate.BestSpeed
BestCompression = flate.BestCompression
DefaultCompression = flate.DefaultCompression
HuffmanOnly = flate.HuffmanOnly
)</pre> <h2 id="pkg-variables">Variables</h2> <pre data-language="go">var (
// ErrChecksum is returned when reading ZLIB data that has an invalid checksum.
ErrChecksum = errors.New("zlib: invalid checksum")
// ErrDictionary is returned when reading ZLIB data that has an invalid dictionary.
ErrDictionary = errors.New("zlib: invalid dictionary")
// ErrHeader is returned when reading ZLIB data that has an invalid header.
ErrHeader = errors.New("zlib: invalid header")
)</pre> <h2 id="NewReader">func <span>NewReader</span> </h2> <pre data-language="go">func NewReader(r io.Reader) (io.ReadCloser, error)</pre> <p>NewReader creates a new ReadCloser. Reads from the returned ReadCloser read and decompress data from r. If r does not implement <span>io.ByteReader</span>, the decompressor may read more data than necessary from r. It is the caller's responsibility to call Close on the ReadCloser when done. </p>
<p>The <span>io.ReadCloser</span> returned by NewReader also implements <a href="#Resetter">Resetter</a>. </p> <h4 id="example_NewReader"> <span class="text">Example</span>
</h4> <p>Code:</p> <pre class="code" data-language="go">buff := []byte{120, 156, 202, 72, 205, 201, 201, 215, 81, 40, 207,
47, 202, 73, 225, 2, 4, 0, 0, 255, 255, 33, 231, 4, 147}
b := bytes.NewReader(buff)
r, err := zlib.NewReader(b)
if err != nil {
panic(err)
}
io.Copy(os.Stdout, r)
</pre> <p>Output:</p> <pre class="output" data-language="go">hello, world
</pre> <h2 id="NewReaderDict">func <span>NewReaderDict</span> </h2> <pre data-language="go">func NewReaderDict(r io.Reader, dict []byte) (io.ReadCloser, error)</pre> <p>NewReaderDict is like <a href="#NewReader">NewReader</a> but uses a preset dictionary. NewReaderDict ignores the dictionary if the compressed data does not refer to it. If the compressed data refers to a different dictionary, NewReaderDict returns <a href="#ErrDictionary">ErrDictionary</a>. </p>
<p>The ReadCloser returned by NewReaderDict also implements <a href="#Resetter">Resetter</a>. </p>
<h2 id="Resetter">type <span>Resetter</span> <span title="Added in Go 1.4">1.4</span> </h2> <p>Resetter resets a ReadCloser returned by <a href="#NewReader">NewReader</a> or <a href="#NewReaderDict">NewReaderDict</a> to switch to a new underlying Reader. This permits reusing a ReadCloser instead of allocating a new one. </p>
<pre data-language="go">type Resetter interface {
// Reset discards any buffered data and resets the Resetter as if it was
// newly initialized with the given reader.
Reset(r io.Reader, dict []byte) error
}</pre> <h2 id="Writer">type <span>Writer</span> </h2> <p>A Writer takes data written to it and writes the compressed form of that data to an underlying writer (see NewWriter). </p>
<pre data-language="go">type Writer struct {
// contains filtered or unexported fields
}
</pre> <h3 id="NewWriter">func <span>NewWriter</span> </h3> <pre data-language="go">func NewWriter(w io.Writer) *Writer</pre> <p>NewWriter creates a new Writer. Writes to the returned Writer are compressed and written to w. </p>
<p>It is the caller's responsibility to call Close on the Writer when done. Writes may be buffered and not flushed until Close. </p> <h4 id="example_NewWriter"> <span class="text">Example</span>
</h4> <p>Code:</p> <pre class="code" data-language="go">var b bytes.Buffer
w := zlib.NewWriter(&b)
w.Write([]byte("hello, world\n"))
w.Close()
fmt.Println(b.Bytes())
</pre> <p>Output:</p> <pre class="output" data-language="go">[120 156 202 72 205 201 201 215 81 40 207 47 202 73 225 2 4 0 0 255 255 33 231 4 147]
</pre> <h3 id="NewWriterLevel">func <span>NewWriterLevel</span> </h3> <pre data-language="go">func NewWriterLevel(w io.Writer, level int) (*Writer, error)</pre> <p>NewWriterLevel is like NewWriter but specifies the compression level instead of assuming DefaultCompression. </p>
<p>The compression level can be DefaultCompression, NoCompression, HuffmanOnly or any integer value between BestSpeed and BestCompression inclusive. The error returned will be nil if the level is valid. </p>
<h3 id="NewWriterLevelDict">func <span>NewWriterLevelDict</span> </h3> <pre data-language="go">func NewWriterLevelDict(w io.Writer, level int, dict []byte) (*Writer, error)</pre> <p>NewWriterLevelDict is like NewWriterLevel but specifies a dictionary to compress with. </p>
<p>The dictionary may be nil. If not, its contents should not be modified until the Writer is closed. </p>
<h3 id="Writer.Close">func (*Writer) <span>Close</span> </h3> <pre data-language="go">func (z *Writer) Close() error</pre> <p>Close closes the Writer, flushing any unwritten data to the underlying io.Writer, but does not close the underlying io.Writer. </p>
<h3 id="Writer.Flush">func (*Writer) <span>Flush</span> </h3> <pre data-language="go">func (z *Writer) Flush() error</pre> <p>Flush flushes the Writer to its underlying io.Writer. </p>
<h3 id="Writer.Reset">func (*Writer) <span>Reset</span> <span title="Added in Go 1.2">1.2</span> </h3> <pre data-language="go">func (z *Writer) Reset(w io.Writer)</pre> <p>Reset clears the state of the Writer z such that it is equivalent to its initial state from NewWriterLevel or NewWriterLevelDict, but instead writing to w. </p>
<h3 id="Writer.Write">func (*Writer) <span>Write</span> </h3> <pre data-language="go">func (z *Writer) Write(p []byte) (n int, err error)</pre> <p>Write writes a compressed form of p to the underlying io.Writer. The compressed bytes are not necessarily flushed until the Writer is closed or explicitly flushed. </p><div class="_attribution">
<p class="_attribution-p">
© Google, Inc.<br>Licensed under the Creative Commons Attribution License 3.0.<br>
<a href="http://golang.org/pkg/compress/zlib/" class="_attribution-link">http://golang.org/pkg/compress/zlib/</a>
</p>
</div>
|
