new repository

1 files changed, 95 insertions, 0 deletions

diff --git a/devdocs/go/compress%2Fzlib%2Findex.html b/devdocs/go/compress%2Fzlib%2Findex.html
new file mode 100644
index 00000000..393ad89d
--- /dev/null
+++ b/devdocs/go/compress%2Fzlib%2Findex.html
@@ -0,0 +1,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(&amp;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(&amp;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(&amp;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">
+    &copy; 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>