src/pkg/compress/zlib/writer.go

// 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 (
	"compress/flate";
	"hash";
	"hash/adler32";
	"io";
	"os";
)

// 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;
)

type writer struct {
	w		io.Writer;
	deflater	io.WriteCloser;
	digest		hash.Hash32;
	err		os.Error;
	scratch		[4]byte;
}

// NewDeflater calls NewDeflaterLevel with the default compression level.
func NewDeflater(w io.Writer) (io.WriteCloser, os.Error) {
	return NewDeflaterLevel(w, DefaultCompression)
}

// NewDeflater creates a new io.WriteCloser that satisfies writes by compressing data written to w.
// It is the caller's responsibility to call Close on the WriteCloser when done.
// level is the compression level, which can be DefaultCompression, NoCompression,
// or any integer value between BestSpeed and BestCompression (inclusive).
func NewDeflaterLevel(w io.Writer, level int) (io.WriteCloser, os.Error) {
	z := new(writer);
	// 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 unused, in this implementation.
	// The final five FCHECK bits form a mod-31 checksum.
	switch level {
	case 0, 1:
		z.scratch[1] = 0x01
	case 2, 3, 4, 5:
		z.scratch[1] = 0x5e
	case 6, -1:
		z.scratch[1] = 0x9c
	case 7, 8, 9:
		z.scratch[1] = 0xda
	default:
		return nil, os.NewError("level out of range")
	}
	_, err := w.Write(z.scratch[0:2]);
	if err != nil {
		return nil, err
	}
	z.w = w;
	z.deflater = flate.NewDeflater(w, level);
	z.digest = adler32.New();
	return z, nil;
}

func (z *writer) Write(p []byte) (n int, err os.Error) {
	if z.err != nil {
		return 0, z.err
	}
	if len(p) == 0 {
		return 0, nil
	}
	n, err = z.deflater.Write(p);
	if err != nil {
		z.err = err;
		return;
	}
	z.digest.Write(p);
	return;
}

// Calling Close does not close the wrapped io.Writer originally passed to NewDeflater.
func (z *writer) Close() os.Error {
	if z.err != nil {
		return z.err
	}
	z.err = z.deflater.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;
}