gtsocial-umbx

writer.go (5596B)

---

 // Copyright 2009 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 zlib
 
 import (
 	"fmt"
 	"hash"
 	"hash/adler32"
 	"io"
 
 	"github.com/klauspost/compress/flate"
 )
 
 // These constants are copied from the flate package, so that code that imports
 // "compress/zlib" does not also have to import "compress/flate".
 const (
 	NoCompression       = flate.NoCompression
 	BestSpeed           = flate.BestSpeed
 	BestCompression     = flate.BestCompression
 	DefaultCompression  = flate.DefaultCompression
 	ConstantCompression = flate.ConstantCompression
 	HuffmanOnly         = flate.HuffmanOnly
 )
 
 // A Writer takes data written to it and writes the compressed
 // form of that data to an underlying writer (see NewWriter).
 type Writer struct {
 	w           io.Writer
 	level       int
 	dict        []byte
 	compressor  *flate.Writer
 	digest      hash.Hash32
 	err         error
 	scratch     [4]byte
 	wroteHeader bool
 }
 
 // NewWriter creates a new Writer.
 // Writes to the returned Writer are compressed and written to w.
 //
 // It is the caller's responsibility to call Close on the WriteCloser when done.
 // Writes may be buffered and not flushed until Close.
 func NewWriter(w io.Writer) *Writer {
 	z, _ := NewWriterLevelDict(w, DefaultCompression, nil)
 	return z
 }
 
 // NewWriterLevel is like NewWriter but specifies the compression level instead
 // of assuming DefaultCompression.
 //
 // 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.
 func NewWriterLevel(w io.Writer, level int) (*Writer, error) {
 	return NewWriterLevelDict(w, level, nil)
 }
 
 // NewWriterLevelDict is like NewWriterLevel but specifies a dictionary to
 // compress with.
 //
 // The dictionary may be nil. If not, its contents should not be modified until
 // the Writer is closed.
 func NewWriterLevelDict(w io.Writer, level int, dict []byte) (*Writer, error) {
 	if level < HuffmanOnly || level > BestCompression {
 		return nil, fmt.Errorf("zlib: invalid compression level: %d", level)
 	}
 	return &Writer{
 		w:     w,
 		level: level,
 		dict:  dict,
 	}, nil
 }
 
 // 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.
 func (z *Writer) Reset(w io.Writer) {
 	z.w = w
 	// z.level and z.dict left unchanged.
 	if z.compressor != nil {
 		z.compressor.Reset(w)
 	}
 	if z.digest != nil {
 		z.digest.Reset()
 	}
 	z.err = nil
 	z.scratch = [4]byte{}
 	z.wroteHeader = false
 }
 
 // writeHeader writes the ZLIB header.
 func (z *Writer) writeHeader() (err error) {
 	z.wroteHeader = true
 	// ZLIB has a two-byte header (as documented in RFC 1950).
 	// The first four bits is the CINFO (compression info), which is 7 for the default deflate window size.
 	// The next four bits is the CM (compression method), which is 8 for deflate.
 	z.scratch[0] = 0x78
 	// The next two bits is the FLEVEL (compression level). The four values are:
 	// 0=fastest, 1=fast, 2=default, 3=best.
 	// The next bit, FDICT, is set if a dictionary is given.
 	// The final five FCHECK bits form a mod-31 checksum.
 	switch z.level {
 	case -2, 0, 1:
 		z.scratch[1] = 0 << 6
 	case 2, 3, 4, 5:
 		z.scratch[1] = 1 << 6
 	case 6, -1:
 		z.scratch[1] = 2 << 6
 	case 7, 8, 9:
 		z.scratch[1] = 3 << 6
 	default:
 		panic("unreachable")
 	}
 	if z.dict != nil {
 		z.scratch[1] |= 1 << 5
 	}
 	z.scratch[1] += uint8(31 - (uint16(z.scratch[0])<<8+uint16(z.scratch[1]))%31)
 	if _, err = z.w.Write(z.scratch[0:2]); err != nil {
 		return err
 	}
 	if z.dict != nil {
 		// The next four bytes are the Adler-32 checksum of the dictionary.
 		checksum := adler32.Checksum(z.dict)
 		z.scratch[0] = uint8(checksum >> 24)
 		z.scratch[1] = uint8(checksum >> 16)
 		z.scratch[2] = uint8(checksum >> 8)
 		z.scratch[3] = uint8(checksum >> 0)
 		if _, err = z.w.Write(z.scratch[0:4]); err != nil {
 			return err
 		}
 	}
 	if z.compressor == nil {
 		// Initialize deflater unless the Writer is being reused
 		// after a Reset call.
 		z.compressor, err = flate.NewWriterDict(z.w, z.level, z.dict)
 		if err != nil {
 			return err
 		}
 		z.digest = adler32.New()
 	}
 	return nil
 }
 
 // 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.
 func (z *Writer) Write(p []byte) (n int, err error) {
 	if !z.wroteHeader {
 		z.err = z.writeHeader()
 	}
 	if z.err != nil {
 		return 0, z.err
 	}
 	if len(p) == 0 {
 		return 0, nil
 	}
 	n, err = z.compressor.Write(p)
 	if err != nil {
 		z.err = err
 		return
 	}
 	z.digest.Write(p)
 	return
 }
 
 // Flush flushes the Writer to its underlying io.Writer.
 func (z *Writer) Flush() error {
 	if !z.wroteHeader {
 		z.err = z.writeHeader()
 	}
 	if z.err != nil {
 		return z.err
 	}
 	z.err = z.compressor.Flush()
 	return z.err
 }
 
 // Close closes the Writer, flushing any unwritten data to the underlying
 // io.Writer, but does not close the underlying io.Writer.
 func (z *Writer) Close() error {
 	if !z.wroteHeader {
 		z.err = z.writeHeader()
 	}
 	if z.err != nil {
 		return z.err
 	}
 	z.err = z.compressor.Close()
 	if z.err != nil {
 		return z.err
 	}
 	checksum := z.digest.Sum32()
 	// ZLIB (RFC 1950) is big-endian, unlike GZIP (RFC 1952).
 	z.scratch[0] = uint8(checksum >> 24)
 	z.scratch[1] = uint8(checksum >> 16)
 	z.scratch[2] = uint8(checksum >> 8)
 	z.scratch[3] = uint8(checksum >> 0)
 	_, z.err = z.w.Write(z.scratch[0:4])
 	return z.err
 }